agentwheel 0.18.2 → 0.18.4

package/dist/index.js

@@ -13260,7 +13260,7 @@ function sortedUnique7(values) {
 import { createHash as createHash15 } from "crypto";
 import { readFile as readFile37, readdir as readdir9, rm as rm13 } from "fs/promises";
 import { homedir as homedir13 } from "os";
-import { basename as basename22, join as join50, relative as relative8, resolve as resolve25 } from "path";
+import { basename as basename22, isAbsolute as isAbsolute4, join as join50, relative as relative8, resolve as resolve25 } from "path";
 async function planFleetNormalization(request) {
   const normalizedRequest = normalizeRequest(request);
   const destinationScope = await resolveWorkspaceScope({
@@ -13293,10 +13293,17 @@ async function planFleetNormalization(request) {
     packages.push({ name, declarationDigest: sha2564(sourceDeclaration) });
   }
   if (!legacySelfNormalization) await assertSourceFleetPostcondition(normalizedRequest, sourceScope, candidates);
-  if ((normalizedRequest.profile || normalizedRequest.artifacts) && !legacySelfNormalization) {
-    throw new Error("--profile and --artifact are supported only for legacy same-fleet ownership normalization.");
-  }
-  const installedState = legacySelfNormalization ? await inspectLegacySelfInstalledState(destinationScope, candidates, normalizedRequest.profile, normalizedRequest.artifacts) : await inspectInstalledState(sourceScope, destinationScope, candidates);
+  if ((normalizedRequest.profile || normalizedRequest.agent || normalizedRequest.artifacts || normalizedRequest.orphanedOwnerRoots) && !legacySelfNormalization) {
+    throw new Error("--profile, --agent, --artifact, and --orphaned-owner are supported only for legacy same-fleet ownership normalization.");
+  }
+  const installedState = legacySelfNormalization ? await inspectLegacySelfInstalledState(
+    destinationScope,
+    candidates,
+    normalizedRequest.profile,
+    normalizedRequest.agent,
+    normalizedRequest.artifacts,
+    normalizedRequest.orphanedOwnerRoots
+  ) : await inspectInstalledState(sourceScope, destinationScope, candidates);
   const planWithoutDigest = {
     version: 1,
     request: normalizedRequest,
@@ -13464,15 +13471,29 @@ function normalizeRequest(request) {
   if (request.artifacts !== void 0 && artifacts?.length === 0) throw new Error("--artifact requires at least one type/name selector.");
   const profile = request.profile?.trim();
   if (request.profile !== void 0 && !profile) throw new Error("--profile requires a profile name.");
+  const agent = request.agent?.trim();
+  if (request.agent !== void 0 && !agent) throw new Error("--agent requires a configured agent name.");
+  if (profile && agent) throw new Error("--profile and --agent cannot be combined.");
+  const orphanedOwnerRoots = request.orphanedOwnerRoots === void 0 ? void 0 : sortedUnique8(request.orphanedOwnerRoots.map((root) => normalizeOrphanedOwnerRoot(root)));
+  if (request.orphanedOwnerRoots !== void 0 && orphanedOwnerRoots?.length === 0) {
+    throw new Error("--orphaned-owner requires at least one absolute workspace root.");
+  }
   return {
     destinationFleet: request.destinationFleet.trim(),
     from: request.from,
     ...packages ? { packages } : {},
     ...artifacts ? { artifacts } : {},
     ...profile ? { profile } : {},
+    ...agent ? { agent } : {},
+    ...orphanedOwnerRoots ? { orphanedOwnerRoots } : {},
     ...request.globalRoot ? { globalRoot: resolve25(request.globalRoot) } : {}
   };
 }
+function normalizeOrphanedOwnerRoot(value) {
+  const root = value.trim();
+  if (!root || !isAbsolute4(root)) throw new Error(`Invalid orphaned owner root '${value}'; expected an absolute workspace path.`);
+  return resolve25(root);
+}
 async function normalizationRoots(request) {
   const destination = await showRegisteredFleet(request.destinationFleet, { globalRoot: request.globalRoot });
   const source = request.from === "user" ? resolve25(request.globalRoot ?? homedir13()) : (await showRegisteredFleet(request.from.slice("fleet:".length), { globalRoot: request.globalRoot })).root;
@@ -13519,6 +13540,7 @@ async function inspectInstalledState(source, destination, packageNames) {
       sourceManifestCount: 0,
       destinationManifestCount: 0,
       renderedPathCount: 0,
+      orphanedUnmanagedPaths: [],
       sourceGraphLockPaths: [],
       graphTransfers: [],
       transfers: []
@@ -13616,7 +13638,8 @@ async function inspectInstalledState(source, destination, packageNames) {
       installationType: destinationState.installationType,
       adapter: destinationState.adapter,
       renderedPaths: sortedUnique8(sourceRenderedPaths),
-      destinationRenderedPaths: sortedUnique8(destinationRenderedPaths)
+      destinationRenderedPaths: sortedUnique8(destinationRenderedPaths),
+      unmanagedSourceRenderedPaths: []
     });
   }
   if (coveredSourceEntries.size !== sourceEntries.length) {
@@ -13648,18 +13671,19 @@ async function inspectInstalledState(source, destination, packageNames) {
     sourceManifestCount: new Set(sourceEntries.map((entry) => entry.manifest.path)).size,
     destinationManifestCount: new Set(destinationEntries.map((entry) => entry.manifest.path)).size,
     renderedPathCount: plannedDestinationPaths.size,
+    orphanedUnmanagedPaths: [],
     sourceGraphLockPaths: sourceGraphs.map((graph) => graph.path).sort((a, b) => a.localeCompare(b)),
     graphTransfers: graphTransfers.sort((a, b) => a.sourceGraphLockPath.localeCompare(b.sourceGraphLockPath)),
     transfers: [...transfers.values()].sort((a, b) => `${a.sourceManifestPath}:${a.destinationManifestPath}`.localeCompare(`${b.sourceManifestPath}:${b.destinationManifestPath}`))
   };
 }
-async function inspectLegacySelfInstalledState(fleet, packageNames, profileName, artifactNames) {
+async function inspectLegacySelfInstalledState(fleet, packageNames, profileName, agentName, artifactNames, orphanedOwnerRoots) {
   if (fleet.kind !== "fleet" || !fleet.fleetId) {
     throw new Error("Legacy self-normalization requires a registered named fleet destination.");
   }
   const selected = new Set(packageNames);
   const selectedArtifacts = artifactNames ? new Set(artifactNames) : void 0;
-  const targetKeys = profileName ? targetKeysForProfile(fleet, profileName) : void 0;
+  const targetKeys = agentName ? targetKeysForAgent(fleet, agentName) : profileName ? targetKeysForProfile(fleet, profileName) : void 0;
   const graphCandidates = await relevantGraphLocks(
     fleet.root,
     selected,
@@ -13669,6 +13693,9 @@ async function inspectLegacySelfInstalledState(fleet, packageNames, profileName,
   const graphs = [];
   const legacyOwner = workspaceOwnerForRoot(fleet.root);
   const fleetOwner = workspaceOwnerForRoot(fleet.root, fleet.fleetId);
+  const orphanedOwners = await orphanedWorkspaceOwners(orphanedOwnerRoots);
+  const knownLegacyOwners = /* @__PURE__ */ new Set([legacyOwner, ...orphanedOwners]);
+  const transferableOwners = orphanedOwners.size > 0 ? orphanedOwners : /* @__PURE__ */ new Set([legacyOwner]);
   let normalizedGraphCount = 0;
   for (const graph of graphCandidates) {
     const legacyState = await legacyTargetStateForGraph(fleet, graph);
@@ -13692,14 +13719,19 @@ async function inspectLegacySelfInstalledState(fleet, packageNames, profileName,
   }
   const manifests = await collectManifestPaths([...manifestPaths]);
   const relevantEntries = manifests.flatMap((manifest) => manifest.manifest.entries.filter((entry) => graphs.some((graph) => entryMatchesGraphPackages(entry, graph.lock, selected)) && entryMatchesArtifacts(entry, selectedArtifacts)).map((entry) => ({ manifest, entry, renderedPath: renderedEntryPath(manifest.manifest, entry) })));
-  const legacyEntries = relevantEntries.filter((entry) => entry.entry.workspaceOwner === legacyOwner);
+  const legacyEntries = relevantEntries.filter((entry) => transferableOwners.has(entry.entry.workspaceOwner));
   const qualifiedEntries = relevantEntries.filter((entry) => entry.entry.workspaceOwner === fleetOwner);
-  const foreignEntries = relevantEntries.filter((entry) => entry.entry.workspaceOwner !== legacyOwner && entry.entry.workspaceOwner !== fleetOwner);
+  const foreignEntries = relevantEntries.filter((entry) => !knownLegacyOwners.has(entry.entry.workspaceOwner) && entry.entry.workspaceOwner !== fleetOwner);
   if (foreignEntries.length > 0) {
     throw new Error(
       `Legacy self-normalization owner mismatch at ${foreignEntries[0].renderedPath}: expected ${legacyOwner}, found foreign owner ${foreignEntries[0].entry.workspaceOwner}.`
     );
   }
+  for (const orphanedOwner of orphanedOwners) {
+    if (!legacyEntries.some((entry) => entry.entry.workspaceOwner === orphanedOwner)) {
+      throw new Error(`Accepted orphaned owner '${orphanedOwner}' has no matching installed-state entries for this normalization.`);
+    }
+  }
   if (legacyEntries.length === 0) {
     if (qualifiedEntries.length > 0) {
       throw new Error(`Fleet '${fleet.fleetId}' installed state is already normalized to fleet-qualified ownership.`);
@@ -13718,6 +13750,7 @@ async function inspectLegacySelfInstalledState(fleet, packageNames, profileName,
   const graphTransfers = [];
   const coveredEntries = /* @__PURE__ */ new Set();
   const renderedPaths = /* @__PURE__ */ new Set();
+  const orphanedUnmanagedPaths = /* @__PURE__ */ new Set();
   for (const graph of graphs) {
     const legacyState = await legacyTargetStateForGraph(fleet, graph);
     const destinationState = await targetStateForGraph(fleet, graph, fleet.fleetId);
@@ -13731,35 +13764,48 @@ async function inspectLegacySelfInstalledState(fleet, packageNames, profileName,
     const graphArtifacts = new Set(graph.artifactIdentities);
     const existingManifest = manifests.find((manifest) => manifest.path === destinationState.manifestPath);
     const desiredEntries = [];
+    const sourceRenderedPaths = [];
+    const destinationRenderedPaths = [];
     for (const entry of expectedEntries) {
       coveredEntries.add(entry);
       assertSimpleVerifiableEntry(entry.entry, entry.renderedPath);
-      if (!graphArtifacts.has(graphEntryIdentity(entry.entry))) {
+      const coveredByCurrentGraph = graphArtifacts.has(graphEntryIdentity(entry.entry));
+      const matchesCurrentGraph = orphanedOwners.has(entry.entry.workspaceOwner) && orphanedEntryMatchesCurrentGraph(entry, graph, selected);
+      if (!coveredByCurrentGraph && !matchesCurrentGraph && !orphanedOwners.has(entry.entry.workspaceOwner)) {
         throw new Error(`Legacy manifest entry is not covered by its graph lock: ${entry.renderedPath}`);
       }
       await assertEquivalentRuntimeBytes(entry.renderedPath, entry.renderedPath, entry.entry.hash);
       renderedPaths.add(entry.renderedPath);
-      desiredEntries.push({ ...entry.entry, workspaceOwner: fleetOwner });
+      sourceRenderedPaths.push(entry.renderedPath);
+      if (coveredByCurrentGraph || matchesCurrentGraph) {
+        desiredEntries.push({ ...entry.entry, workspaceOwner: fleetOwner });
+        destinationRenderedPaths.push(entry.renderedPath);
+      } else {
+        orphanedUnmanagedPaths.add(entry.renderedPath);
+      }
     }
-    const after = mergeDestinationManifest(
+    const after = desiredEntries.length > 0 || existingManifest ? mergeDestinationManifest(
       existingManifest,
       destinationState,
       expectedEntries[0].manifest.manifest.generatedAt,
       desiredEntries,
-      /* @__PURE__ */ new Set([legacyOwner])
-    );
+      transferableOwners
+    ) : void 0;
     transfers.set(legacyState.manifestPath, {
       sourceManifestPath: legacyState.manifestPath,
       sourceManifestRevision: expectedEntries[0].manifest.manifest.revision,
       destinationManifestPath: destinationState.manifestPath,
       destinationManifestRevision: existingManifest?.manifest.revision ?? null,
-      destinationManifestAfterRevision: computeManifestRevision(after),
+      destinationManifestAfterRevision: after ? computeManifestRevision(after) : null,
       destinationTargetRoot: destinationState.installRoot,
       destinationStateKey: destinationState.stateKey,
       installationType: destinationState.installationType,
       adapter: destinationState.adapter,
-      renderedPaths: sortedUnique8(expectedEntries.map((entry) => entry.renderedPath)),
-      destinationRenderedPaths: sortedUnique8(expectedEntries.map((entry) => entry.renderedPath))
+      renderedPaths: sortedUnique8(sourceRenderedPaths),
+      destinationRenderedPaths: sortedUnique8(destinationRenderedPaths),
+      unmanagedSourceRenderedPaths: sortedUnique8(
+        sourceRenderedPaths.filter((path) => !destinationRenderedPaths.includes(path))
+      )
     });
     if (!selectedArtifacts) {
       const fullDigest = sha2564(canonicalJson2(graph.lock));
@@ -13786,11 +13832,22 @@ async function inspectLegacySelfInstalledState(fleet, packageNames, profileName,
     sourceManifestCount: new Set(legacyEntries.map((entry) => entry.manifest.path)).size,
     destinationManifestCount: new Set(qualifiedEntries.map((entry) => entry.manifest.path)).size,
     renderedPathCount: renderedPaths.size,
+    orphanedUnmanagedPaths: [...orphanedUnmanagedPaths].sort((a, b) => a.localeCompare(b)),
     sourceGraphLockPaths: graphs.map((graph) => graph.path).sort((a, b) => a.localeCompare(b)),
     graphTransfers: graphTransfers.sort((a, b) => a.sourceGraphLockPath.localeCompare(b.sourceGraphLockPath)),
     transfers: [...transfers.values()].sort((a, b) => a.sourceManifestPath.localeCompare(b.sourceManifestPath))
   };
 }
+async function orphanedWorkspaceOwners(roots) {
+  const owners = /* @__PURE__ */ new Set();
+  for (const root of roots ?? []) {
+    if (await pathExists(root)) {
+      throw new Error(`Orphaned owner root still exists and cannot be adopted: ${root}. Recover or normalize it from that workspace instead.`);
+    }
+    owners.add(workspaceOwnerForRoot(root));
+  }
+  return owners;
+}
 function targetKeysForProfile(scope, name) {
   const profile = scope.config.profiles[name];
   if (!profile) throw new Error(`Unknown fleet profile '${name}'.`);
@@ -13799,6 +13856,14 @@ function targetKeysForProfile(scope, name) {
   }
   return new Set(profile.runtimes.map((runtime) => runtime.agent ?? runtime.adapter));
 }
+function targetKeysForAgent(scope, name) {
+  const agent = scope.config.agents[name];
+  if (!agent) throw new Error(`Unknown fleet agent '${name}'.`);
+  if (agent.transport === "ssh") {
+    throw new Error(`Installed-state normalization cannot hand off SSH agent '${name}' locally.`);
+  }
+  return /* @__PURE__ */ new Set([name]);
+}
 async function runtimeRoots(scope) {
   const roots = /* @__PURE__ */ new Set([scope.root]);
   if (scope.config.packages.some((pkg) => pkg.installationType === "user") || Object.values(scope.config.agents).some((agent) => agent.installationType === "user")) {
@@ -13918,10 +13983,34 @@ function isCurrentLocalTarget(scope, graph) {
 }
 async function hasRelevantLegacyManifestCandidate(scope, graph, selected) {
   if (!isCurrentLocalTarget(scope, graph)) return false;
-  const state = await legacyTargetStateForGraph(scope, graph);
-  const manifest = (await collectManifestPaths([state.manifestPath]))[0];
+  const manifestPath = await legacyManifestPathForConfiguredTarget(scope, graph) ?? (await legacyTargetStateForGraph(scope, graph)).manifestPath;
+  const manifest = (await collectManifestPaths([manifestPath]))[0];
   return manifest?.manifest.entries.some((entry) => entryMatchesGraphPackages(entry, graph.lock, selected)) ?? false;
 }
+async function legacyManifestPathForConfiguredTarget(scope, graph) {
+  const agent = scope.config.agents[graph.targetKey];
+  if (!agent || !agent.installationType) return void 0;
+  if (agent.transport === "ssh") {
+    throw new Error(`Installed-state normalization cannot hand off SSH target '${graph.targetKey}' locally.`);
+  }
+  if (agent.adapter !== graph.adapter) {
+    throw new Error(`Graph adapter '${graph.adapter}' does not match configured target adapter '${agent.adapter}'.`);
+  }
+  const adapter = await resolveAdapter({
+    adapter: agent.adapter,
+    adapterConfig: agent.adapterConfig,
+    adapterModule: agent.adapterModule,
+    allowAdapterCode: false,
+    baseDir: scope.root
+  });
+  const targetRoot = resolveConfigPath(agent.root, scope.root);
+  const installRoot = resolve25(installRootForAdapterInstallationType(adapter, targetRoot, agent.installationType, false));
+  const stateKey = stateKeyFor(adapter.name, {
+    installationType: agent.installationType,
+    targetFingerprint: graph.lock.canonical.targetFingerprint
+  });
+  return installManifestPath(installRoot, adapter.name, { installationType: agent.installationType, stateKey });
+}
 async function targetStateForGraph(scope, graph, identityFleetId = scope.fleetId ?? null) {
   const agent = scope.config.agents[graph.targetKey];
   if (agent?.transport === "ssh") {
@@ -14253,6 +14342,11 @@ function graphEntryIdentity(entry) {
     channel: entry.channel
   });
 }
+function orphanedEntryMatchesCurrentGraph(entry, graph, selected) {
+  return graph.lock.canonical.artifacts.some(
+    (artifact) => artifact.owners.some((owner) => ownerMatchesGraphPackage(graph.lock, owner, selected)) && artifact.type === entry.entry.artifactType && artifact.name === entry.entry.artifactName && artifact.installName === entry.entry.installName && artifact.kind === entry.entry.kind
+  );
+}
 async function readExactConfig(path) {
   return workspaceConfigSchema.parse(JSON.parse(await readFile37(path, "utf8")));
 }
@@ -14290,7 +14384,7 @@ async function buildJournalManifestStates(plan, selected) {
     if (source.manifest.revision !== transfer.sourceManifestRevision) {
       throw new Error(`Source manifest changed after planning: ${transfer.sourceManifestPath}`);
     }
-    const desiredEntries = source.manifest.entries.filter((entry) => entryMatchesPackages(entry, selected) && transfer.renderedPaths.includes(renderedEntryPath(source.manifest, entry))).map((entry) => ({ ...entry, workspaceOwner: workspaceOwnerForRoot(plan.destination.root, plan.destination.fleetId) }));
+    const desiredEntries = source.manifest.entries.filter((entry) => entryMatchesPackages(entry, selected) && transfer.renderedPaths.includes(renderedEntryPath(source.manifest, entry)) && !transfer.unmanagedSourceRenderedPaths.includes(renderedEntryPath(source.manifest, entry))).map((entry) => ({ ...entry, workspaceOwner: workspaceOwnerForRoot(plan.destination.root, plan.destination.fleetId) }));
     const before = await readOptionalRecord(transfer.destinationManifestPath);
     const parsedBefore = before ? installManifestSchema.parse(before) : void 0;
     if (parsedBefore && parsedBefore.version !== 2) {
@@ -14311,25 +14405,25 @@ async function buildJournalManifestStates(plan, selected) {
       graphLockPath: "journaled",
       manifestPath: transfer.destinationManifestPath
     };
-    const after = mergeDestinationManifest(
+    const after = desiredEntries.length > 0 || existing ? mergeDestinationManifest(
       existing,
       state,
       source.manifest.generatedAt,
       desiredEntries,
       workspaceOwnersForPlanSource(plan)
-    );
+    ) : void 0;
     const beforeRevision = before ? computeManifestRevision(before) : null;
-    const afterRevision = computeManifestRevision(after);
+    const afterRevision = after ? computeManifestRevision(after) : null;
     if (beforeRevision !== transfer.destinationManifestRevision || afterRevision !== transfer.destinationManifestAfterRevision) {
       throw new Error(`Destination manifest changed after planning: ${transfer.destinationManifestPath}`);
     }
     if (transfer.sourceManifestPath === transfer.destinationManifestPath) {
       const sourceState = states.find((candidate) => candidate.path === transfer.sourceManifestPath);
       if (!sourceState) throw new Error(`Source manifest journal state is missing: ${transfer.sourceManifestPath}`);
-      sourceState.after = after;
+      sourceState.after = after ?? null;
       sourceState.afterRevision = afterRevision;
     } else {
-      states.push({ path: transfer.destinationManifestPath, before, after, beforeRevision, afterRevision });
+      if (after || before) states.push({ path: transfer.destinationManifestPath, before, after: after ?? null, beforeRevision, afterRevision });
     }
   }
   return states;
@@ -14471,7 +14565,8 @@ async function assertJournalRecoverable(journal) {
 function workspaceOwnersForPlanSource(plan) {
   return /* @__PURE__ */ new Set([
     workspaceOwnerForRoot(plan.source.root),
-    ...plan.source.fleetId ? [workspaceOwnerForRoot(plan.source.root, plan.source.fleetId)] : []
+    ...plan.source.fleetId ? [workspaceOwnerForRoot(plan.source.root, plan.source.fleetId)] : [],
+    ...(plan.request.orphanedOwnerRoots ?? []).map((root) => workspaceOwnerForRoot(root))
   ]);
 }
 async function readOptionalRecord(path) {
@@ -14587,16 +14682,18 @@ fleetCommand.command("show").description("show one registered fleet").argument("
 Root: ${fleet.root}
 Required packages: ${fleet.requiredPackages.join(", ")}`);
 });
-fleetCommand.command("normalize").description("plan or apply duplicate desired-state ownership normalization").argument("<destinationFleet>", "destination fleet id").requiredOption("--from <scope>", "user or fleet:<sourceFleet>").option("--package <name>", "limit to one duplicate package (repeatable)", collectValueOption, []).option("--artifact <type/name>", "limit same-fleet ownership normalization to one artifact (repeatable)", collectValueOption, []).option("--profile <name>", "limit same-fleet installed-state normalization to one concrete profile").option("--apply", "apply a reviewed plan", false).option("--recover", "restore source state from a pending normalization journal", false).option("--plan-digest <sha256>", "exact digest from the reviewed dry-run").option("--json", "print the plan or result as JSON", false).action(async (destinationFleet, options) => {
+fleetCommand.command("normalize").description("plan or apply duplicate desired-state ownership normalization").argument("<destinationFleet>", "destination fleet id").requiredOption("--from <scope>", "user or fleet:<sourceFleet>").option("--package <name>", "limit to one duplicate package (repeatable)", collectValueOption, []).option("--artifact <type/name>", "limit same-fleet ownership normalization to one artifact (repeatable)", collectValueOption, []).option("--profile <name>", "limit same-fleet installed-state normalization to one concrete profile").option("--agent <name>", "limit same-fleet ownership normalization to one configured local agent").option("--orphaned-owner <workspace-root>", "explicit missing workspace root whose verified runtime ownership may be recovered (repeatable)", collectValueOption, []).option("--apply", "apply a reviewed plan", false).option("--recover", "restore source state from a pending normalization journal", false).option("--plan-digest <sha256>", "exact digest from the reviewed dry-run").option("--json", "print the plan or result as JSON", false).action(async (destinationFleet, options) => {
   const request = {
     destinationFleet,
     from: options.from,
     ...options.package.length > 0 ? { packages: options.package } : {},
     ...options.artifact.length > 0 ? { artifacts: options.artifact } : {},
-    ...options.profile ? { profile: options.profile } : {}
+    ...options.profile ? { profile: options.profile } : {},
+    ...options.agent ? { agent: options.agent } : {},
+    ...options.orphanedOwner.length > 0 ? { orphanedOwnerRoots: options.orphanedOwner } : {}
   };
-  if (options.recover && (options.apply || options.planDigest || options.package.length > 0 || options.artifact.length > 0 || options.profile)) {
-    throw new Error("--recover cannot be combined with --apply, --plan-digest, --package, --artifact, or --profile.");
+  if (options.recover && (options.apply || options.planDigest || options.package.length > 0 || options.artifact.length > 0 || options.profile || options.agent || options.orphanedOwner.length > 0)) {
+    throw new Error("--recover cannot be combined with --apply, --plan-digest, --package, --artifact, --profile, --agent, or --orphaned-owner.");
   }
   const result = options.recover ? await recoverFleetNormalization(request) : options.apply ? await applyFleetNormalization({ ...request, apply: true, planDigest: options.planDigest }) : await planFleetNormalization(request);
   console.log(options.json ? JSON.stringify(result, null, 2) : formatFleetNormalization(result));
@@ -17240,11 +17337,15 @@ function formatFleetNormalization(result) {
   const packageArgs = result.packages.map((pkg) => `--package ${shellQuoteArg2(pkg.name)}`).join(" ");
   const artifactArgs = result.request.artifacts?.map((artifact) => ` --artifact ${shellQuoteArg2(artifact)}`).join("") ?? "";
   const profileArg = result.request.profile ? ` --profile ${shellQuoteArg2(result.request.profile)}` : "";
+  const agentArg = result.request.agent ? ` --agent ${shellQuoteArg2(result.request.agent)}` : "";
+  const orphanedOwnerArgs = result.request.orphanedOwnerRoots?.map((root) => ` --orphaned-owner ${shellQuoteArg2(root)}`).join("") ?? "";
+  const orphanedUnmanaged = result.installedState.orphanedUnmanagedPaths;
   return [
     `Fleet normalization plan: ${result.source.root} -> ${result.destination.root}`,
     `Packages: ${result.packages.map((pkg) => pkg.name).join(", ")}`,
+    ...orphanedUnmanaged.length > 0 ? [`Retired orphan ownership (files retained unmanaged): ${orphanedUnmanaged.join(", ")}`] : [],
     `Plan digest: ${result.planDigest}`,
-    `Apply: agentwheel fleet normalize ${result.destination.fleetId} --from ${result.request.from} ${packageArgs}${artifactArgs}${profileArg} --apply --plan-digest ${result.planDigest}`
+    `Apply: agentwheel fleet normalize ${result.destination.fleetId} --from ${result.request.from} ${packageArgs}${artifactArgs}${profileArg}${agentArg}${orphanedOwnerArgs} --apply --plan-digest ${result.planDigest}`
   ].join("\n");
 }
 function shouldDefaultUserInstall(nameOrSource, options) {

package/openpack.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 2,
   "name": "NestDevLab/agentwheel",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "provides": [
     { "type": "skills", "path": "skills" }
   ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentwheel",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "description": "Weave skills, rules, and instructions across every AI agent.",
   "type": "module",
   "license": "MIT",

package/skills/agentwheel/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: [Bash]
 license: MIT
 metadata:
   author: NestDevLab
-  version: "0.18.2"
+  version: "0.18.4"
 ---
 
 # agentwheel

package/skills/agentwheel-discovery/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: [Bash]
 license: MIT
 metadata:
   author: NestDevLab
-  version: "0.18.2"
+  version: "0.18.4"
 ---
 
 # Agentwheel Discovery