agentwheel 0.20.17 → 0.20.19

package/dist/index.js

@@ -37,7 +37,7 @@ import {
   uninstall,
   withManifestRevision,
   writeInstallManifest
-} from "./chunk-A44XYLUT.js";
+} from "./chunk-L37KQVRS.js";
 import {
   CURRENT_WORKSPACE_SCHEMA_VERSION,
   GovernedMutation,
@@ -98,26 +98,27 @@ import {
   workspaceSelectionImportSchema,
   writeApplyJournal,
   writeWorkspaceConfig
-} from "./chunk-FP26KSBM.js";
+} from "./chunk-BHT57MK5.js";
 import {
   inferSourceDriverName
-} from "./chunk-U2GRG4UI.js";
+} from "./chunk-QABA4WUP.js";
 import {
   hashPath,
   isAlreadyExists,
   isIgnoredGeneratedEntry,
   listFiles,
   pathExists,
+  removeOnFailure,
   withFilesystemLock,
   writeJsonAtomic
-} from "./chunk-GE7F76AC.js";
+} from "./chunk-BNIF3FUR.js";
 
 // src/cli/index.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { existsSync } from "fs";
-import { mkdir as mkdir16, mkdtemp as mkdtemp4, realpath as realpath2, rm as rm10, writeFile as writeFile13 } from "fs/promises";
-import { homedir as homedir12, tmpdir as tmpdir5 } from "os";
-import { basename as basename21, dirname as dirname23, isAbsolute as isAbsolute4, join as join46, relative as relative10, resolve as resolve26 } from "path";
+import { mkdir as mkdir16, mkdtemp as mkdtemp3, realpath as realpath3, rm as rm10, writeFile as writeFile13 } from "fs/promises";
+import { homedir as homedir12, tmpdir as tmpdir4 } from "os";
+import { basename as basename21, dirname as dirname23, isAbsolute as isAbsolute5, join as join46, relative as relative11, resolve as resolve27 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Command } from "commander";
 
@@ -3113,14 +3114,14 @@ async function writeMermaidAsset(response) {
     "content-type": "application/javascript; charset=utf-8",
     "cache-control": "public, max-age=3600"
   });
-  await new Promise((resolve27) => {
+  await new Promise((resolve28) => {
     const stream = createReadStream(assetPath);
     stream.on("error", () => {
       if (!response.headersSent) writeText(response, 404, "Mermaid asset unavailable.\n");
       else response.destroy();
-      resolve27();
+      resolve28();
     });
-    stream.on("end", resolve27);
+    stream.on("end", resolve28);
     stream.pipe(response);
   });
 }
@@ -3147,14 +3148,14 @@ function escapeHtml2(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
 function listen(server, port, bind) {
-  return new Promise((resolve27, reject) => {
+  return new Promise((resolve28, reject) => {
     const onError = (error) => {
       server.off("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve27();
+      resolve28();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -3162,7 +3163,7 @@ function listen(server, port, bind) {
   });
 }
 function waitForShutdown(server, beforeClose) {
-  return new Promise((resolve27) => {
+  return new Promise((resolve28) => {
     let closing = false;
     const shutdown = () => {
       if (closing) return;
@@ -3170,7 +3171,7 @@ function waitForShutdown(server, beforeClose) {
       process.off("SIGINT", shutdown);
       process.off("SIGTERM", shutdown);
       beforeClose();
-      server.close(() => resolve27());
+      server.close(() => resolve28());
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
@@ -3180,7 +3181,7 @@ function waitForShutdown(server, beforeClose) {
       process.off("SIGINT", shutdown);
       process.off("SIGTERM", shutdown);
       beforeClose();
-      resolve27();
+      resolve28();
     });
   });
 }
@@ -3733,7 +3734,7 @@ async function fetchClawHubPackage(fetchImpl, packageName) {
   throw new Error(`ClawHub lookup failed for ${packageName}`);
 }
 async function delay(ms) {
-  await new Promise((resolve27) => setTimeout(resolve27, ms));
+  await new Promise((resolve28) => setTimeout(resolve28, ms));
 }
 function parseClawHubSource(source) {
   if (!source.startsWith(sourcePrefix)) {
@@ -3910,7 +3911,7 @@ async function withGitCacheMaintenanceLock(cacheRoot, timeoutMs, fn) {
       if (Date.now() - started > timeoutMs) {
         throw new Error(`Timed out waiting for git cache maintenance lock at ${lockPath}`);
       }
-      await new Promise((resolve27) => setTimeout(resolve27, 50));
+      await new Promise((resolve28) => setTimeout(resolve28, 50));
     }
   }
   try {
@@ -4079,6 +4080,58 @@ function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// src/source/git-source.ts
+import { posix } from "path";
+var SUBPATH_SEPARATOR = "//";
+function parseGitSource(source) {
+  if (source.startsWith("github:")) {
+    const rest = source.slice("github:".length);
+    const hashIndex = rest.indexOf("#");
+    const repo = hashIndex >= 0 ? rest.slice(0, hashIndex) : rest;
+    if (!repo.includes("/")) throw new Error(`Invalid GitHub source: ${source}`);
+    return {
+      url: `https://github.com/${repo.replace(/\.git$/i, "")}.git`,
+      ...splitFragment(hashIndex >= 0 ? rest.slice(hashIndex + 1) : void 0, source)
+    };
+  }
+  if (source.startsWith("git:")) {
+    const rest = source.slice("git:".length);
+    const hashIndex = rest.lastIndexOf("#");
+    if (hashIndex < 0) return { url: rest };
+    return { url: rest.slice(0, hashIndex), ...splitFragment(rest.slice(hashIndex + 1), source) };
+  }
+  throw new Error(`Invalid git source: ${source}`);
+}
+function formatGitSource(url, ref, subpath) {
+  return subpath ? `git:${url}#${ref}${SUBPATH_SEPARATOR}${subpath}` : `git:${url}#${ref}`;
+}
+function normalizeGitSubpath(subpath, source) {
+  if (subpath === void 0) return void 0;
+  if (subpath.includes("\\")) throw new Error(`Git source subpath must use forward slashes: ${source}`);
+  if (subpath.startsWith("/")) throw new Error(`Git source subpath must be relative to the repository: ${source}`);
+  const normalized = posix.normalize(subpath).replace(/\/+$/g, "");
+  if (normalized === "." || normalized === "") return void 0;
+  if (normalized === ".." || normalized.startsWith("../")) {
+    throw new Error(`Git source subpath escapes the repository: ${source}`);
+  }
+  return normalized;
+}
+function resolveGitRelativeSubpath(declaringSubpath, relative12, source) {
+  const joined = posix.normalize(posix.join(declaringSubpath ?? ".", relative12));
+  if (joined === ".." || joined.startsWith("../")) {
+    throw new Error(`Relative dependency '${relative12}' escapes the git repository it is declared in: ${source}`);
+  }
+  return normalizeGitSubpath(joined, source);
+}
+function splitFragment(fragment, source) {
+  if (fragment === void 0) return {};
+  const separator = fragment.indexOf(SUBPATH_SEPARATOR);
+  if (separator < 0) return fragment ? { ref: fragment } : {};
+  const ref = fragment.slice(0, separator);
+  const subpath = normalizeGitSubpath(fragment.slice(separator + SUBPATH_SEPARATOR.length), source);
+  return { ...ref ? { ref } : {}, ...subpath ? { subpath } : {} };
+}
+
 // src/source/git.ts
 var execFileAsync = promisify(execFile);
 var GitSourceDriver = class {
@@ -4138,15 +4191,18 @@ var GitSourceDriver = class {
           return { path, leasePath };
         }
       );
-      const snapshotPath = snapshot.path;
-      const manifest = await readPackageManifest(snapshotPath);
+      const packageRoot = parsed.subpath ? join19(snapshot.path, parsed.subpath) : snapshot.path;
+      if (parsed.subpath && !await isDirectory(packageRoot)) {
+        throw new Error(`Git source subpath '${parsed.subpath}' does not exist at ${resolvedCommit} in ${parsed.url}`);
+      }
+      const manifest = await readPackageManifest(packageRoot);
       return {
         ...resolved,
-        resolvedPath: snapshotPath,
+        resolvedPath: packageRoot,
         packageName: manifest?.name,
         packageVersion: manifest?.version,
         resolvedCommit,
-        sourceHash: await hashPath(snapshotPath),
+        sourceHash: await hashPath(packageRoot),
         cacheLeasePath: snapshot.leasePath
       };
     }, "git cache");
@@ -4164,22 +4220,12 @@ var GitSourceDriver = class {
     return resolved;
   }
 };
-function parseGitSource(source) {
-  if (source.startsWith("github:")) {
-    const rest = source.slice("github:".length);
-    const [repo, ref] = rest.split("#", 2);
-    if (!repo.includes("/")) throw new Error(`Invalid GitHub source: ${source}`);
-    return { url: `https://github.com/${repo}.git`, ref };
-  }
-  if (source.startsWith("git:")) {
-    const rest = source.slice("git:".length);
-    const hashIndex = rest.lastIndexOf("#");
-    if (hashIndex >= 0) {
-      return { url: rest.slice(0, hashIndex), ref: rest.slice(hashIndex + 1) };
-    }
-    return { url: rest };
+async function isDirectory(path) {
+  try {
+    return (await stat4(path)).isDirectory();
+  } catch {
+    return false;
   }
-  throw new Error(`Invalid git source: ${source}`);
 }
 function cachePathFor2(url, cacheRoot) {
   const root = cacheRoot ? resolve5(cacheRoot) : join19(homedir2(), ".agentwheel", "cache");
@@ -5337,7 +5383,8 @@ function claudeAgentName(artifact) {
 
 // src/staging/staging.ts
 async function stageSource(driver, source, options = {}) {
-  return renderStagedBundle(await stageSourceRaw(driver, source, options), options);
+  const raw = await stageSourceRaw(driver, source, options);
+  return removeOnFailure(raw.root, () => renderStagedBundle(raw, options));
 }
 async function stageSourceRaw(driver, source, options = {}) {
   const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(source, options))));
@@ -5352,25 +5399,27 @@ async function stageResolvedSourceRaw(driver, resolved) {
   const artifacts = await driver.list(resolved);
   return stageResolvedArtifactsRaw(resolved, artifacts);
 }
-async function stageResolvedArtifactsRaw(resolved, artifacts) {
-  const root = await mkdtemp(join27(tmpdir2(), "agentwheel-stage-"));
+async function stageResolvedArtifactsRaw(resolved, artifacts, parentDir = tmpdir2()) {
+  const root = await mkdtemp(join27(parentDir, "agentwheel-stage-"));
   const stagedArtifacts = [];
-  for (const artifact of artifacts) {
-    const stagedPath = join27(root, artifact.relativePath);
-    await mkdir11(dirname13(stagedPath), { recursive: true });
-    await cp3(artifact.sourcePath, stagedPath, {
-      recursive: artifact.kind === "dir",
-      dereference: true,
-      filter: (path) => !isIgnoredGeneratedEntry(basename16(path))
-    });
-    await composeAssets(artifact, resolved.resolvedPath, stagedPath);
-    stagedArtifacts.push({
-      ...artifact,
-      stagedPath,
-      hash: await hashPath(stagedPath),
-      channel: artifact.channel ?? "managed"
-    });
-  }
+  await removeOnFailure(root, async () => {
+    for (const artifact of artifacts) {
+      const stagedPath = join27(root, artifact.relativePath);
+      await mkdir11(dirname13(stagedPath), { recursive: true });
+      await cp3(artifact.sourcePath, stagedPath, {
+        recursive: artifact.kind === "dir",
+        dereference: true,
+        filter: (path) => !isIgnoredGeneratedEntry(basename16(path))
+      });
+      await composeAssets(artifact, resolved.resolvedPath, stagedPath);
+      stagedArtifacts.push({
+        ...artifact,
+        stagedPath,
+        hash: await hashPath(stagedPath),
+        channel: artifact.channel ?? "managed"
+      });
+    }
+  });
   return {
     root,
     source: resolved,
@@ -5527,8 +5576,7 @@ import { dirname as dirname15, join as join30, relative as relative6 } from "pat
 
 // src/resolve/graph.ts
 import { createHash as createHash6 } from "crypto";
-import { mkdtemp as mkdtemp2, readdir as readdir7, readFile as readFile17, stat as stat11 } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
+import { readdir as readdir7, readFile as readFile17, stat as stat11 } from "fs/promises";
 import { basename as basename17, extname as extname4, join as join29 } from "path";
 
 // src/model/workspace-composition.ts
@@ -5789,7 +5837,7 @@ var RegistryClient = class {
   }
 };
 async function resolvePackageSource(source, workspaceRoot, options = {}) {
-  const { isExplicitSource } = await import("./identify-O54QXPQR.js");
+  const { isExplicitSource } = await import("./identify-M6IA4RS7.js");
   if (await isExplicitSource(source)) return { source };
   const entry = await new RegistryClient({ workspaceRoot, offline: options.offline, warn: options.warn }).resolve(source);
   if (!entry) {
@@ -5831,6 +5879,17 @@ async function normalizeDependencySource(source, options) {
   if (isBareRegistryName(trimmed)) {
     return normalizeRegistrySource(trimmed, options);
   }
+  if (options.declaringGitSource && (trimmed === "." || trimmed === ".." || trimmed.startsWith("./") || trimmed.startsWith("../"))) {
+    const declaring = options.declaringGitSource;
+    const subpath = resolveGitRelativeSubpath(declaring.subpath, trimmed, source);
+    const normalizedSource = formatGitSource(declaring.url, declaring.commit, subpath);
+    return {
+      source: normalizedSource,
+      normalizedSource,
+      driver: "git",
+      requestedRef: declaring.commit
+    };
+  }
   if (isLocalSource(trimmed)) {
     const path = localSourcePath(trimmed);
     const resolvedPath = resolveLocalPath(path, options.declaringPackageRoot);
@@ -5841,10 +5900,10 @@ async function normalizeDependencySource(source, options) {
     };
   }
   if (trimmed.startsWith("github:") || trimmed.startsWith("git:")) {
-    const parsed = parseGitSource2(trimmed);
+    const parsed = parseGitSource(trimmed);
     const requestedRef = options.ref ?? parsed.ref ?? "HEAD";
     const url = normalizeGitRemoteUrl(parsed.url, options.declaringPackageRoot);
-    const normalizedSource = `git:${url}#${requestedRef}`;
+    const normalizedSource = formatGitSource(url, requestedRef, parsed.subpath);
     return {
       source: normalizedSource,
       normalizedSource,
@@ -5921,20 +5980,6 @@ async function normalizeRegistrySource(name, options) {
     normalizedSource: `registry:${name}:${resolved.normalizedSource}`
   };
 }
-function parseGitSource2(source) {
-  if (source.startsWith("github:")) {
-    const rest2 = source.slice("github:".length);
-    const [repo, ref] = rest2.split("#", 2);
-    if (!repo.includes("/")) throw new Error(`Invalid GitHub dependency source: ${source}`);
-    return { url: `https://github.com/${repo.replace(/\.git$/i, "")}.git`, ref };
-  }
-  const rest = source.slice("git:".length);
-  const hashIndex = rest.lastIndexOf("#");
-  if (hashIndex >= 0) {
-    return { url: rest.slice(0, hashIndex), ref: rest.slice(hashIndex + 1) };
-  }
-  return { url: rest };
-}
 function normalizeGitRemoteUrl(url, declaringPackageRoot) {
   if (url.startsWith("./") || url.startsWith("../") || url.startsWith("/") || url === "~" || url.startsWith("~/")) {
     return resolveLocalPath(url, declaringPackageRoot);
@@ -5986,7 +6031,6 @@ var SnapshotConflictError = class extends Error {
 var cacheLocks = /* @__PURE__ */ new Map();
 async function resolveDependencyGraph(roots, options) {
   if (roots.length === 0) throw new Error("At least one graph root is required.");
-  const graphRoot = await mkdtemp2(join29(tmpdir3(), "agentwheel-graph-"));
   const fetchCache = /* @__PURE__ */ new Map();
   const nodesByKey = /* @__PURE__ */ new Map();
   const nodesBySource = /* @__PURE__ */ new Map();
@@ -6052,7 +6096,6 @@ async function resolveDependencyGraph(roots, options) {
   }
   detectDirectCollisions(rawNodes);
   return {
-    root: graphRoot,
     roots: rootResults.sort((a, b) => a.rootId.localeCompare(b.rootId)),
     nodes: rawNodes.map((state) => state.node),
     rawNodes,
@@ -6094,6 +6137,7 @@ async function processRequirement(requirement, options, fetchCache, nodesByKey,
     let lockedByReference = lockedNodeForRequirementReference(requirement, options, lockLabel);
     let normalized = lockedByReference ? normalizedSourceFromLockedNode(lockedByReference.node) : await normalizeDependencySource(requirement.source, {
       declaringPackageRoot: requirement.declaringPackageRoot,
+      declaringGitSource: requirement.declaringGitSource,
       workspaceRoot: options.workspaceRoot,
       ref: requirement.ref,
       registryClient: options.registryClient
@@ -6101,6 +6145,7 @@ async function processRequirement(requirement, options, fetchCache, nodesByKey,
     if (lockedByReference && shouldCheckLockedRootSource(requirement)) {
       const declared = await normalizeDependencySource(requirement.source, {
         declaringPackageRoot: requirement.declaringPackageRoot,
+        declaringGitSource: requirement.declaringGitSource,
         workspaceRoot: options.workspaceRoot,
         ref: requirement.ref,
         registryClient: options.registryClient
@@ -6378,6 +6423,7 @@ function dependencyRequirement(state, fetched, alias, dependency, select, chain,
     useLock: dependency.mode !== "tracking" || options.lockedResolution === true && !updateClosure,
     updateClosure,
     declaringPackageRoot: fetched.resolved.resolvedPath,
+    declaringGitSource: declaringGitSource(fetched),
     requiredBy: state.node.id,
     alias,
     parentId: state.node.id,
@@ -6776,8 +6822,8 @@ function verifyIntegrity(integrity, sourceHash, label) {
 async function withCachePathLock(path, fn) {
   const previous = cacheLocks.get(path) ?? Promise.resolve();
   let release = () => void 0;
-  const current = previous.then(() => new Promise((resolve27) => {
-    release = resolve27;
+  const current = previous.then(() => new Promise((resolve28) => {
+    release = resolve28;
   }));
   cacheLocks.set(path, current);
   await previous;
@@ -6885,6 +6931,15 @@ async function mapLimit(items, limit, fn) {
   if (failure !== void 0) throw failure;
   return out;
 }
+function declaringGitSource(fetched) {
+  if (fetched.resolved.driver !== "git" || !fetched.resolved.resolvedCommit) return void 0;
+  const parsed = parseGitSource(fetched.resolved.source);
+  return {
+    url: normalizeGitRemoteUrl(parsed.url, fetched.resolved.resolvedPath),
+    commit: fetched.resolved.resolvedCommit,
+    subpath: parsed.subpath
+  };
+}
 
 // src/lifecycle/customization.ts
 async function remember(workspaceRoot, runtime, text) {
@@ -7039,7 +7094,7 @@ import { rm as rm7 } from "fs/promises";
 // src/lifecycle/source-plan.ts
 import { createHash as createHash8 } from "crypto";
 import { mkdir as mkdir14, readdir as readdir9 } from "fs/promises";
-import { basename as basename18, dirname as dirname17, join as join33, posix as posix2, resolve as resolve16 } from "path";
+import { basename as basename18, dirname as dirname17, join as join33, posix as posix3, resolve as resolve16 } from "path";
 
 // src/resolve/graph-diff.ts
 function diffGraphLocks(previous, next) {
@@ -7202,11 +7257,14 @@ function formatSelectionImport(root) {
 
 // src/resolve/render.ts
 import { createHash as createHash7 } from "crypto";
-import { readFile as readFile18, mkdtemp as mkdtemp3 } from "fs/promises";
-import { tmpdir as tmpdir4 } from "os";
+import { readFile as readFile18, mkdtemp as mkdtemp2 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
 import { join as join31 } from "path";
 async function renderGraphForTarget(graph, targetContext = {}) {
-  const root = await mkdtemp3(join31(tmpdir4(), "agentwheel-render-"));
+  const root = await mkdtemp2(join31(tmpdir3(), "agentwheel-render-"));
+  return removeOnFailure(root, () => renderGraphIntoRoot(root, graph, targetContext));
+}
+async function renderGraphIntoRoot(root, graph, targetContext) {
   const artifacts = [];
   const stagedNodes = /* @__PURE__ */ new Map();
   const includeEdges = /* @__PURE__ */ new Map();
@@ -7214,7 +7272,7 @@ async function renderGraphForTarget(graph, targetContext = {}) {
   for (const rawNode of graph.rawNodes) {
     const ownsCompositionRules = rawNode.depth === 0 && rawNode.manifest?.schemaVersion === 3 && Boolean(rawNode.manifest.compositionRules?.length);
     if (rawNode.node.selected.length === 0 && !ownsCompositionRules) continue;
-    const rawBundle = await stageResolvedArtifactsRaw(rawNode.resolved, rawNode.artifacts);
+    const rawBundle = await stageResolvedArtifactsRaw(rawNode.resolved, rawNode.artifacts, root);
     const fragmentCustomized = targetContext.workspaceRoot && targetContext.adapter ? await applyFragmentCustomizations(rawBundle.artifacts, {
       workspaceRoot: targetContext.workspaceRoot,
       adapter: targetContext.adapter,
@@ -8081,7 +8139,7 @@ function containsPath(parent, candidate) {
 }
 
 // src/model/target-state.ts
-import { posix, resolve as resolve15 } from "path";
+import { posix as posix2, resolve as resolve15 } from "path";
 var targetEvolutionFields = /* @__PURE__ */ new Set([
   "adapterCodeHash",
   "adapterConfig",
@@ -8114,7 +8172,7 @@ function persistentTargetParts(value) {
   );
 }
 function normalizeInstallRoot(path, transportKind) {
-  return transportKind === "ssh" ? posix.normalize(path) : resolve15(path);
+  return transportKind === "ssh" ? posix2.normalize(path) : resolve15(path);
 }
 function targetEndpoint(value, transportKind) {
   if (transportKind !== "ssh") return { kind: "local" };
@@ -8271,85 +8329,87 @@ async function createGraphSourcePlan(options) {
     noDeps: options.noDeps,
     warn
   });
-  const desiredArtifacts = filterArtifactsByAdapterTargets(
-    desiredArtifactsFromGraphBundle(bundle),
-    options.adapter,
-    installationType,
-    { warn }
-  );
-  const resolvedInstallationType = resolveInstallationTypeForArtifacts(options.adapter, desiredArtifacts.map((artifact) => artifact.type), installationType);
-  const resolvedInstallRoot = installRootForArtifacts(options.adapter, options.targetRoot, resolvedInstallationType, desiredArtifacts.map((artifact) => artifact.type), transport.kind === "ssh");
-  const graphLockDigest = digestGraphLock(bundle.graphLock);
-  const graphDiff = diffGraphLocks(previousLock, bundle.graphLock);
-  if (normalizeInstallRoot2(resolvedInstallRoot, transport.kind) !== normalizeInstallRoot2(installRoot, transport.kind)) {
-    throw new Error(
-      `Adapter ${options.adapter.name} resolved a different install root after rendering; target state identity cannot be proven.`
+  return removeOnFailure(bundle.root, async () => {
+    const desiredArtifacts = filterArtifactsByAdapterTargets(
+      desiredArtifactsFromGraphBundle(bundle),
+      options.adapter,
+      installationType,
+      { warn }
     );
-  }
-  const manifest = priorState.manifest;
-  const basePlan = options.retireExactMcp ? await createExactMcpRetirementPlan(
-    desiredArtifacts,
-    options.adapter,
-    options.targetRoot,
-    manifest,
-    transport,
-    {
-      installationType: resolvedInstallationType,
-      stateKey,
-      workspaceOwner,
-      expectedFromWorkspaceOwner: options.expectedFromWorkspaceOwner,
-      graphLockDigest
+    const resolvedInstallationType = resolveInstallationTypeForArtifacts(options.adapter, desiredArtifacts.map((artifact) => artifact.type), installationType);
+    const resolvedInstallRoot = installRootForArtifacts(options.adapter, options.targetRoot, resolvedInstallationType, desiredArtifacts.map((artifact) => artifact.type), transport.kind === "ssh");
+    const graphLockDigest = digestGraphLock(bundle.graphLock);
+    const graphDiff = diffGraphLocks(previousLock, bundle.graphLock);
+    if (normalizeInstallRoot2(resolvedInstallRoot, transport.kind) !== normalizeInstallRoot2(installRoot, transport.kind)) {
+      throw new Error(
+        `Adapter ${options.adapter.name} resolved a different install root after rendering; target state identity cannot be proven.`
+      );
     }
-  ) : await createCombinedInstallPlan(desiredArtifacts, options.adapter, options.targetRoot, manifest, transport, {
-    baseRevision: manifest?.revision ?? null,
-    graphLockDigest,
-    workspaceOwner,
-    installationType: resolvedInstallationType,
-    stateKey,
-    forceDrift: options.forceDrift,
-    forceConflict: options.forceConflict,
-    replaceConflict: options.replaceConflict,
-    stateMigration: priorState.migration,
-    warn
-  });
-  const plan = priorState.migration && !basePlan.stateMigration ? { ...basePlan, stateMigration: priorState.migration } : basePlan;
-  plan.targetStateFilePreconditions = {
-    graphLockPath,
-    graphLockRevision: stableLock ? digestGraphLock(stableLock) : null,
-    sourceLockRevision: computeSourceLockRevision(stableSourceLock)
-  };
-  let foreignStateObservations = [];
-  if (options.forceForeignState !== true && options.deferForeignStateCheck !== true) {
-    foreignStateObservations = await assertNoForeignWorkspaceState({
-      installRoot: resolvedInstallRoot,
-      adapter: options.adapter.name,
+    const manifest = priorState.manifest;
+    const basePlan = options.retireExactMcp ? await createExactMcpRetirementPlan(
+      desiredArtifacts,
+      options.adapter,
+      options.targetRoot,
+      manifest,
       transport,
-      workspaceRoot,
+      {
+        installationType: resolvedInstallationType,
+        stateKey,
+        workspaceOwner,
+        expectedFromWorkspaceOwner: options.expectedFromWorkspaceOwner,
+        graphLockDigest
+      }
+    ) : await createCombinedInstallPlan(desiredArtifacts, options.adapter, options.targetRoot, manifest, transport, {
+      baseRevision: manifest?.revision ?? null,
+      graphLockDigest,
       workspaceOwner,
-      globalRoot: options.globalRoot,
+      installationType: resolvedInstallationType,
       stateKey,
-      migratingStateKey: priorState.migration?.fromStateKey,
-      plannedPaths: plan.operations.map((operation) => operation.relativeDestPath),
-      plannedOperations: plan.operations
+      forceDrift: options.forceDrift,
+      forceConflict: options.forceConflict,
+      replaceConflict: options.replaceConflict,
+      stateMigration: priorState.migration,
+      warn
     });
-    plan.hasBlockingChanges = plan.operations.some((operation) => operation.action === "drift" || operation.action === "conflict");
-  }
-  return {
-    plan,
-    graph,
-    bundle,
-    desiredArtifacts,
-    graphLockPath,
-    graphLockDigest,
-    targetFingerprint,
-    warnings,
-    newTransitiveSources: trustEvaluation.promptSources,
-    graphDiff,
-    recoveredPendingApply,
-    previousManifest: priorState.manifest,
-    previousGraphLock: priorState.graphLock,
-    foreignStateObservations
-  };
+    const plan = priorState.migration && !basePlan.stateMigration ? { ...basePlan, stateMigration: priorState.migration } : basePlan;
+    plan.targetStateFilePreconditions = {
+      graphLockPath,
+      graphLockRevision: stableLock ? digestGraphLock(stableLock) : null,
+      sourceLockRevision: computeSourceLockRevision(stableSourceLock)
+    };
+    let foreignStateObservations = [];
+    if (options.forceForeignState !== true && options.deferForeignStateCheck !== true) {
+      foreignStateObservations = await assertNoForeignWorkspaceState({
+        installRoot: resolvedInstallRoot,
+        adapter: options.adapter.name,
+        transport,
+        workspaceRoot,
+        workspaceOwner,
+        globalRoot: options.globalRoot,
+        stateKey,
+        migratingStateKey: priorState.migration?.fromStateKey,
+        plannedPaths: plan.operations.map((operation) => operation.relativeDestPath),
+        plannedOperations: plan.operations
+      });
+      plan.hasBlockingChanges = plan.operations.some((operation) => operation.action === "drift" || operation.action === "conflict");
+    }
+    return {
+      plan,
+      graph,
+      bundle,
+      desiredArtifacts,
+      graphLockPath,
+      graphLockDigest,
+      targetFingerprint,
+      warnings,
+      newTransitiveSources: trustEvaluation.promptSources,
+      graphDiff,
+      recoveredPendingApply,
+      previousManifest: priorState.manifest,
+      previousGraphLock: priorState.graphLock,
+      foreignStateObservations
+    };
+  });
 }
 async function assertNoForeignWorkspaceStateForPlan(plan, options) {
   if (!plan.stateKey) throw new Error(`Foreign-state validation requires a state key for ${plan.adapter}.`);
@@ -8708,7 +8768,7 @@ function stableJson2(value) {
   return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort((left, right) => left.localeCompare(right)).map((key) => `${JSON.stringify(key)}:${stableJson2(record[key])}`).join(",")}}`;
 }
 function normalizeInstallRoot2(path, transportKind) {
-  return transportKind === "ssh" ? posix2.normalize(path) : resolve16(path);
+  return transportKind === "ssh" ? posix3.normalize(path) : resolve16(path);
 }
 var workspaceOwnerPrefix2 = "workspace-root:";
 async function assertNoForeignWorkspaceState(check) {
@@ -8785,6 +8845,7 @@ async function assertNoForeignWorkspaceState(check) {
   }
   const foreign = [...foreignByOwner.values()];
   if (foreign.length === 0) return observations.sort((left, right) => left.path.localeCompare(right.path));
+  const currentOwner = parseWorkspaceOwner(check.workspaceOwner);
   throw new Error([
     `Refusing to plan ${check.adapter} at ${check.installRoot}.`,
     "This runtime root already carries Agentwheel state owned by another workspace, at paths this run would install:",
@@ -8795,7 +8856,10 @@ async function assertNoForeignWorkspaceState(check) {
     `Current workspace: ${check.workspaceRoot} (state key ${check.stateKey})`,
     "Agentwheel keys install state by target fingerprint, so this run cannot read that manifest and",
     "would report those paths as unmanaged conflicts or drift.",
-    parseWorkspaceOwner(check.workspaceOwner)?.fleetId ? "Reconcile the owners with an explicit agentwheel fleet normalize operation before planning this fleet." : "Re-run from the owning workspace, or pass --force-foreign-state to plan against it anyway."
+    ...currentOwner?.fleetId ? [
+      "Reconcile the owners with an explicit agentwheel fleet normalize operation before planning this fleet.",
+      ...currentOwner.root !== root ? ["For this nested workspace, adopt legacy fingerprint-keyed claims with agentwheel ownership adopt-legacy."] : []
+    ] : ["Re-run from the owning workspace, or pass --force-foreign-state to plan against it anyway."]
   ].join("\n"));
 }
 async function exactForeignKeepOperation(check, collision, operations) {
@@ -9781,6 +9845,7 @@ function resolveCliVersion() {
 
 // src/lifecycle/ownership.ts
 import { resolve as resolve20 } from "path";
+var unknownWorkspaceOwner = "workspace:unknown";
 async function planArtifactOwnershipHandoff(request) {
   return validateOwnershipHandoff(request, request.transport ?? localTransport);
 }
@@ -9799,6 +9864,9 @@ async function applyArtifactOwnershipHandoff(request) {
       throw new Error("Cannot hand off ownership while an apply journal is pending. Recover or abort it first.");
     }
     const plan = await validateOwnershipHandoff(request, transport);
+    if (plan.drifted && !request.expectedRuntimeHash) {
+      throw new Error("Applying a drifted ownership handoff requires expectedRuntimeHash from a reviewed dry-run.");
+    }
     const manifest = await readInstallManifest(request.targetRoot, request.adapter, transport, scope);
     if (!manifest || manifest.version !== 2) {
       throw new Error("Ownership handoff requires an Agentwheel v2 install manifest.");
@@ -9829,6 +9897,13 @@ async function applyArtifactOwnershipHandoff(request) {
 async function validateOwnershipHandoff(request, transport) {
   if (request.expectedHash) assertSha256(request.expectedHash, "expected artifact hash");
   if (request.expectedRevision) assertSha256(request.expectedRevision, "expected manifest revision");
+  if (request.expectedRuntimeHash) {
+    assertSha256(request.expectedRuntimeHash, "expected runtime hash");
+    if (request.carryDrift !== true) throw new Error("An expected runtime hash is only valid with carryDrift.");
+  }
+  if (request.fromWorkspaceRoot === void 0 === (request.fromUnknownOwner !== true)) {
+    throw new Error("Ownership handoff requires exactly one of fromWorkspaceRoot or fromUnknownOwner.");
+  }
   const scope = { installationType: request.installationType, stateKey: request.stateKey };
   const manifest = await readInstallManifest(request.targetRoot, request.adapter, transport, scope);
   if (!manifest) throw new Error(`No install manifest for ${request.adapter} at ${request.targetRoot}`);
@@ -9846,7 +9921,7 @@ async function validateOwnershipHandoff(request, transport) {
     );
   }
   const entry = matches[0];
-  const fromOwner = workspaceOwnerForRoot(request.fromWorkspaceRoot);
+  const fromOwner = request.fromUnknownOwner === true ? unknownWorkspaceOwner : workspaceOwnerForRoot(request.fromWorkspaceRoot);
   const toOwner = workspaceOwnerForRoot(request.toWorkspaceRoot, request.toFleetId);
   if (fromOwner === toOwner) throw new Error("Ownership handoff requires different workspace roots.");
   if (entry.workspaceOwner !== fromOwner) {
@@ -9857,9 +9932,14 @@ async function validateOwnershipHandoff(request, transport) {
   }
   const destPath = containedArtifactPath(request.targetRoot, entry.path);
   if (!await transport.pathExists(destPath)) throw new Error(`Managed artifact is missing: ${entry.path}`);
-  const currentHash = await verifiedEntryHash(entry, destPath, transport);
-  if (request.expectedHash && currentHash !== request.expectedHash) {
-    throw new Error(`Current hash precondition failed for ${entry.path}: expected ${request.expectedHash}, found ${currentHash}`);
+  const runtimeHash = await verifiedEntryHash(entry, destPath, transport, request.carryDrift === true);
+  const drifted = runtimeHash !== entry.hash;
+  if (drifted) {
+    if (request.expectedRuntimeHash && runtimeHash !== request.expectedRuntimeHash) {
+      throw new Error(`Runtime hash precondition failed for ${entry.path}: expected ${request.expectedRuntimeHash}, found ${runtimeHash}`);
+    }
+  } else if (request.expectedRuntimeHash) {
+    throw new Error(`Runtime hash precondition failed for ${entry.path}: the artifact is no longer drifted`);
   }
   return {
     adapter: request.adapter,
@@ -9868,13 +9948,15 @@ async function validateOwnershipHandoff(request, transport) {
     targetRoot: request.targetRoot,
     selector: `${request.artifactType}/${request.artifactName}`,
     path: entry.path,
-    artifactHash: currentHash,
+    artifactHash: entry.hash,
+    runtimeHash,
+    drifted,
     manifestRevision: manifest.revision,
     fromOwner,
     toOwner
   };
 }
-async function verifiedEntryHash(entry, destPath, transport) {
+async function verifiedEntryHash(entry, destPath, transport, carryFileDrift = false) {
   if (entry.semanticPlugin) throw new Error(`Ownership handoff cannot verify semantic plugin state at ${destPath}`);
   if (entry.mode === "managed-block") {
     const selector = managedInstructionSelector(entry.logicalSelector, entry.artifactType, entry.artifactName);
@@ -9892,7 +9974,7 @@ async function verifiedEntryHash(entry, destPath, transport) {
     return entry.hash;
   }
   const currentHash = await transport.hashPath(destPath);
-  if (currentHash !== entry.hash) {
+  if (currentHash !== entry.hash && !carryFileDrift) {
     throw new Error(`Managed artifact is drifted at ${destPath}: manifest ${entry.hash}, current ${currentHash}`);
   }
   return currentHash;
@@ -10107,7 +10189,7 @@ async function requireManifest(request, stateKey, transport, label) {
     stateKey
   });
   if (!manifest) throw new Error(`No ${label} install manifest for state key ${stateKey}.`);
-  if (manifest.version !== 2) throw new Error(`${label} ownership retirement requires an Agentwheel v2 install manifest.`);
+  if (manifest.version !== 2) throw new Error(`The ${label} install manifest must be an Agentwheel v2 manifest.`);
   const actualStateKey = stateKeyFor(manifest.adapter, {
     installationType: manifest.installationType,
     stateKey: manifest.stateKey
@@ -10214,10 +10296,15 @@ function canonicalJson(value) {
   return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
 }
 
+// src/lifecycle/ownership-adopt-legacy.ts
+import { createHash as createHash11 } from "crypto";
+import { realpath as realpath2 } from "fs/promises";
+import { isAbsolute as isAbsolute3, relative as relative9, resolve as resolve23 } from "path";
+
 // src/lifecycle/legacy-recovery-plan.ts
 import { createHash as createHash10 } from "crypto";
-import { readdir as readdir10 } from "fs/promises";
-import { basename as basename20, dirname as dirname21, join as join39, posix as posix3, relative as relative8, resolve as resolve22 } from "path";
+import { lstat as lstat3, readdir as readdir10 } from "fs/promises";
+import { basename as basename20, dirname as dirname21, join as join39, posix as posix4, relative as relative8, resolve as resolve22 } from "path";
 async function inventoryHistoricalLocks(fleetRoot) {
   const root = join39(fleetRoot, ".agentwheel", "locks");
   const found = [];
@@ -10228,15 +10315,38 @@ async function inventoryHistoricalLocks(fleetRoot) {
     })) {
       const path = join39(dir, entry.name);
       if (entry.isDirectory()) await visit(path);
-      else if (entry.isFile() && entry.name.endsWith(".graph-lock.json")) {
-        const lock = await readGraphLock(path);
-        found.push({ path, digest: sha2564(canonicalGraphLockJson(lock)), lock });
-      }
+      else if (entry.isFile() && entry.name.endsWith(".graph-lock.json")) found.push(await historicalLock(path));
     }
   }
   await visit(root);
   return found.sort((a, b) => a.path.localeCompare(b.path));
 }
+async function findLegacyNamedLocks(workspaceRoot, adapter, fingerprint) {
+  const root = join39(workspaceRoot, ".agentwheel", "locks");
+  const found = [];
+  for (const target of await readdir10(root, { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  })) {
+    if (!target.isDirectory()) continue;
+    const path = join39(root, target.name, adapter, `${fingerprint}.graph-lock.json`);
+    const stats = await lstat3(path).catch((error) => {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    });
+    if (!stats?.isFile()) continue;
+    const item = await historicalLock(path);
+    if (item.lock.canonical.targetFingerprint === fingerprint) found.push(item);
+  }
+  return found.sort((a, b) => a.path.localeCompare(b.path));
+}
+function lockCoversEntry(lock, entry) {
+  return lock.canonical.artifacts.some((artifact) => artifact.graphNodeId === entry.graphNodeId && artifact.logicalSelector === entry.logicalSelector && artifact.hash === entry.sourceHash);
+}
+async function historicalLock(path) {
+  const lock = await readGraphLock(path);
+  return { path, digest: sha2564(canonicalGraphLockJson(lock)), lock };
+}
 async function planLegacyRecovery(input) {
   const { graphPlan, installRoot, targetKey: targetKey2, adapter, installationType, historicalLocks, transport } = input;
   assertCompleteGraphPlan(graphPlan);
@@ -10352,7 +10462,7 @@ function claimFor(item, entry, locks, binding) {
   const matches = locks.filter((candidate) => candidate.digest === digest2);
   const evidence = [];
   const owner = "workspaceOwner" in entry ? entry.workspaceOwner : legacyUnownedWorkspaceOwner;
-  const sameRoot = binding.transportKind === "ssh" ? posix3.normalize(item.manifest.targetRoot) === posix3.normalize(binding.installRoot) : resolve22(item.manifest.targetRoot) === resolve22(binding.installRoot);
+  const sameRoot = binding.transportKind === "ssh" ? posix4.normalize(item.manifest.targetRoot) === posix4.normalize(binding.installRoot) : resolve22(item.manifest.targetRoot) === resolve22(binding.installRoot);
   const inTargetDir = matches.filter((candidate) => resolve22(dirname21(candidate.path)) === resolve22(binding.targetLockDir));
   const boundLocks = inTargetDir.filter((candidate) => lockBindsState(candidate, item, binding));
   if (owner !== binding.expectedOwner) evidence.push("workspace owner differs from selected Fleet target");
@@ -10367,7 +10477,7 @@ function claimFor(item, entry, locks, binding) {
   if (inTargetDir.length && !boundLocks.length) evidence.push("graph-lock fingerprint, filename, or state key does not bind claim");
   if (boundLocks.length && !boundLocks.some((candidate) => candidate.lock.canonical.artifacts.some((artifact) => artifact.graphNodeId === nodeId && artifact.logicalSelector === selector))) {
     evidence.push("historical graph-lock selector/node does not cover claim");
-  } else if (boundLocks.length && !boundLocks.some((candidate) => candidate.lock.canonical.artifacts.some((artifact) => artifact.graphNodeId === nodeId && artifact.logicalSelector === selector && artifact.hash === entry.sourceHash))) {
+  } else if (boundLocks.length && !boundLocks.some((candidate) => lockCoversEntry(candidate.lock, { graphNodeId: nodeId, logicalSelector: selector, sourceHash: entry.sourceHash }))) {
     evidence.push("historical graph-lock artifact hash differs from manifest source hash");
   }
   const foreign = owner !== binding.expectedOwner || !sameRoot || item.manifest.version !== 2 || item.manifest.installationType !== binding.installationType || item.manifest.version === 2 && (item.manifest.stateKey !== item.stateKey || item.manifest.adapter !== binding.adapter) || matches.length > 0 && inTargetDir.length === 0;
@@ -10466,10 +10576,394 @@ function sha2564(value) {
   return createHash10("sha256").update(value).digest("hex");
 }
 
+// src/lifecycle/ownership-adopt-legacy.ts
+var absentRevision = "absent";
+function desiredCoverageFromPlan(plan) {
+  return plan.operations.filter((operation) => operation.desiredHash && operation.action !== "remove" && operation.action !== "keep").map((operation) => ({
+    path: operation.relativeDestPath,
+    artifactType: operation.artifactType,
+    artifactName: operation.artifactName,
+    kind: operation.kind,
+    ...operation.packageName ? { packageName: operation.packageName } : {}
+  })).sort((left, right) => left.path.localeCompare(right.path));
+}
+async function planAdoptLegacyOwnership(request) {
+  return observe2(request, request.transport ?? localTransport);
+}
+async function applyAdoptLegacyOwnership(request) {
+  assertApplyPreconditions2(request);
+  const transport = request.transport ?? localTransport;
+  const targetRoot = resolve23(request.targetRoot);
+  const installationType = request.installationType.trim();
+  const lock = await acquireApplyLock(targetRoot, request.adapter, transport, {}, {
+    installationType,
+    stateKey: request.destinationStateKey
+  });
+  try {
+    await assertNoPendingJournals(targetRoot, request.adapter, transport);
+    const current = await observe2(request, transport);
+    assertExpected(request.planDigest, current.planDigest, "plan digest");
+    assertExpected(request.expectedSourceRevision, current.source.revision, "source manifest revision");
+    assertExpected(request.expectedDestinationRevision, current.destination.revision ?? absentRevision, "destination manifest revision");
+    assertExpected(request.expectedInventoryRevision, current.manifestInventoryRevision, "manifest inventory revision");
+    const identity = { targetRoot, adapter: request.adapter, installationType };
+    const source = await requireManifest(identity, current.source.stateKey, transport, "source");
+    const destination = await readDestination(identity, current.destination.stateKey, transport);
+    const selectedByDigest = new Map(current.selected.map((entry) => [entry.sourceEntryDigest, entry]));
+    const adopted = [];
+    const retained = [];
+    for (const entry of source.entries) {
+      const selected = selectedByDigest.get(entryDigest(entry));
+      if (!selected) retained.push(entry);
+      else if (selected.action === "adopt") adopted.push({ ...entry, workspaceOwner: current.destination.owner });
+    }
+    if (source.entries.length - retained.length !== current.selected.length) {
+      throw new Error("Source manifest selection changed while locked; replan required.");
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (adopted.length > 0) {
+      declareMutationPath(current.destination.manifestPath);
+      const base = destination ?? {
+        version: 2,
+        adapter: request.adapter,
+        installationType,
+        stateKey: current.destination.stateKey,
+        targetRoot,
+        generatedAt: now,
+        revision: "pending-apply-0000",
+        legacy: false,
+        entries: []
+      };
+      await commitMetadata({
+        ...base,
+        entries: [...base.entries, ...adopted].sort((left, right) => left.path.localeCompare(right.path))
+      }, destination?.revision ?? null, now, transport);
+    }
+    declareMutationPath(current.source.manifestPath);
+    await commitMetadata({ ...source, entries: retained }, source.revision, now, transport);
+    return {
+      ...current,
+      applied: true,
+      adoptedEntries: adopted.length,
+      retiredCoveredEntries: current.selected.length - adopted.length,
+      sourceManifestRemoved: retained.length === 0,
+      retainedSourceEntries: retained.length
+    };
+  } finally {
+    await lock.release();
+  }
+}
+async function commitMetadata(manifest, baseRevision, now, transport) {
+  const mutation = mutationMetadataForApplyJournal();
+  const journal = {
+    version: mutation ? 2 : 1,
+    ...mutation ? { mutation } : {},
+    mode: "uninstall",
+    adapter: manifest.adapter,
+    installationType: manifest.installationType,
+    stateKey: manifest.stateKey,
+    targetRoot: manifest.targetRoot,
+    baseRevision,
+    createdAt: now,
+    updatedAt: now,
+    operations: [],
+    completed: [],
+    manifest
+  };
+  await writeApplyJournal(journal, transport);
+  await commitManifestMetadataJournal(journal, transport);
+}
+async function observe2(request, transport) {
+  if (transport.kind === "ssh") {
+    throw new Error("Legacy ownership adoption does not support SSH targets; legacy SSH state does not prove its endpoint.");
+  }
+  const input = await normalizeRequest2(request);
+  const { targetRoot, adapter, installationType } = input;
+  await assertNoPendingJournals(targetRoot, adapter, transport);
+  const identity = { targetRoot, adapter, installationType };
+  if (!await readInstallManifest(targetRoot, adapter, transport, { installationType, stateKey: input.sourceStateKey })) {
+    throw new Error(`Nothing to adopt: no source install manifest for state key ${input.sourceStateKey}.`);
+  }
+  const source = await requireManifest(identity, input.sourceStateKey, transport, "source");
+  const destination = await readDestination(identity, input.destinationStateKey, transport);
+  if (!destination && await pathExists(request.destinationGraphLockPath)) {
+    throw new Error(
+      `Destination has a stable graph lock without a stable manifest at ${request.destinationGraphLockPath}; reconcile it before adopting legacy ownership.`
+    );
+  }
+  const desiredByPath = /* @__PURE__ */ new Map();
+  for (const item of request.desiredCoverage) desiredByPath.set(item.path, [...desiredByPath.get(item.path) ?? [], item]);
+  const { entries: selectedEntries, retained, provenance } = await selectLegacySource(
+    input,
+    input.sourceStateKey,
+    input.fingerprint,
+    source,
+    desiredByPath
+  );
+  const selectedPaths = new Set(selectedEntries.map((entry) => entry.path));
+  const selected = [];
+  for (const entry of selectedEntries) {
+    const runtimePath = containedArtifactPath(targetRoot, entry.path);
+    const runtimeHash = await transport.pathExists(runtimePath) ? await transport.hashPath(runtimePath) : null;
+    const drift = runtimeHash !== entry.hash;
+    if (drift && request.carryDrift !== true) {
+      throw new Error(
+        runtimeHash === null ? `Managed artifact is missing at ${entry.path}; pass --carry-drift to keep the recorded hash.` : `Managed artifact is drifted at ${entry.path}: manifest ${entry.hash}, current ${runtimeHash}; pass --carry-drift to keep the recorded hash.`
+      );
+    }
+    const atPath = destination?.entries.filter((candidate) => candidate.path === entry.path) ?? [];
+    let destinationEntryDigest;
+    if (atPath.length > 0) {
+      const covering = atPath.length === 1 ? atPath[0] : void 0;
+      if (!covering || !coversSourceEntry(covering, entry, input.destinationOwner)) {
+        throw new Error(`Destination state at ${entry.path} is not an exact copy of the source claim owned by this workspace.`);
+      }
+      if (!drift) await verifyManifestEntryRuntime(targetRoot, covering, transport);
+      destinationEntryDigest = entryDigest(covering);
+    }
+    selected.push({
+      path: entry.path,
+      action: destinationEntryDigest ? "retire-covered" : "adopt",
+      sourceEntryDigest: entryDigest(entry),
+      ...destinationEntryDigest ? { destinationEntryDigest } : {},
+      recordedHash: entry.hash,
+      runtimeHash,
+      drift
+    });
+  }
+  const remainingDuplicates = [];
+  const selectedByPath = new Map(selectedEntries.map((entry) => [entry.path, entry]));
+  for (const item of await listInstallManifests(targetRoot, adapter, transport)) {
+    if (item.stateKey === input.destinationStateKey) continue;
+    const duplicatePaths = [];
+    for (const entry of item.manifest.entries) {
+      if (!selectedPaths.has(entry.path)) continue;
+      const owner = "workspaceOwner" in entry ? entry.workspaceOwner : legacyUnownedWorkspaceOwner;
+      if (owner !== input.sourceOwner) {
+        throw new Error(`${entry.path} is also claimed by ${owner} in ${item.fileName}; legacy ownership cannot be adopted.`);
+      }
+      if (item.stateKey !== input.sourceStateKey) duplicatePaths.push(entry.path);
+    }
+    if (duplicatePaths.length === 0) continue;
+    await assertRetirableDuplicate(input, item, duplicatePaths, selectedByPath, desiredByPath, transport);
+    for (const path of duplicatePaths) remainingDuplicates.push({ stateKey: item.stateKey, path });
+  }
+  const withoutDigest = {
+    adapter,
+    installationType,
+    targetRoot,
+    source: {
+      stateKey: input.sourceStateKey,
+      manifestPath: installManifestPath(targetRoot, adapter, { installationType, stateKey: input.sourceStateKey }),
+      revision: source.revision,
+      owner: input.sourceOwner,
+      class: input.sourceClass,
+      provenanceLock: { path: provenance.path, digest: provenance.digest }
+    },
+    destination: {
+      stateKey: input.destinationStateKey,
+      manifestPath: installManifestPath(targetRoot, adapter, { installationType, stateKey: input.destinationStateKey }),
+      revision: destination?.revision ?? null,
+      owner: input.destinationOwner,
+      workspaceRoot: input.workspaceRoot
+    },
+    manifestInventoryRevision: await computeInstallManifestInventoryRevision(targetRoot, adapter, transport),
+    selected: selected.sort((left, right) => left.path.localeCompare(right.path)),
+    retained: retained.sort((left, right) => left.path.localeCompare(right.path) || left.owner.localeCompare(right.owner)),
+    remainingDuplicates: remainingDuplicates.sort((left, right) => left.stateKey.localeCompare(right.stateKey) || left.path.localeCompare(right.path)),
+    // identity only, so a newer package revision doesn't invalidate a reviewed plan
+    desiredCoverage: request.desiredCoverage.filter((item) => selectedPaths.has(item.path)).map(({ path, artifactType, artifactName, kind }) => ({ path, artifactType, artifactName, kind })).sort((left, right) => left.path.localeCompare(right.path) || left.artifactType.localeCompare(right.artifactType) || left.artifactName.localeCompare(right.artifactName))
+  };
+  return { ...withoutDigest, planDigest: createHash11("sha256").update(canonicalJson(withoutDigest)).digest("hex") };
+}
+async function normalizeRequest2(request) {
+  if (request.destinationFleetId !== void 0) {
+    throw new Error("Legacy ownership adoption targets a nested workspace; a Fleet target uses fleet normalize or ownership retire-stale.");
+  }
+  const targetRoot = resolve23(request.targetRoot);
+  const installationType = request.installationType.trim();
+  const sourceStateKey = exactStateKey(request.adapter, request.sourceStateKey, installationType, "source");
+  const destinationStateKey = exactStateKey(request.adapter, request.destinationStateKey, installationType, "destination");
+  const fingerprint = legacyFingerprint(request.adapter, installationType, sourceStateKey);
+  if (!fingerprint) {
+    throw new Error(`The source must be a legacy state key of the form ${request.adapter}.${installationType}.<64-hex target fingerprint>.`);
+  }
+  if (sourceStateKey === destinationStateKey) throw new Error("Source and destination state keys must differ.");
+  const scope = await resolveWorkspaceOwnershipScope(request.workspaceRoot, { globalRoot: request.globalRoot });
+  const destinationOwner = workspaceOwnerForRoot(scope.root, scope.fleetId);
+  const workspaceRoot = await realpath2(request.workspaceRoot);
+  const sourceRoot = resolve23(request.fromWorkspaceRoot);
+  const sourceOwner = workspaceOwnerForRoot(sourceRoot);
+  let sourceClass;
+  if (sourceRoot === workspaceRoot || sourceRoot === resolve23(request.workspaceRoot)) {
+    if (sourceOwner === destinationOwner) {
+      throw new Error(`${sourceOwner} is already the destination owner; ordinary install migration handles its legacy state.`);
+    }
+    sourceClass = "own-legacy-owner";
+  } else {
+    const sourceForms = [sourceRoot, ...await realpath2(sourceRoot).then((path) => [path], () => [])];
+    const workspaceForms = [workspaceRoot, resolve23(request.workspaceRoot), scope.root];
+    if (sourceForms.some((source) => workspaceForms.some((workspace) => containsPath2(source, workspace) || containsPath2(workspace, source)))) {
+      throw new Error(`Source root ${sourceRoot} contains or is contained by the destination workspace; it cannot be adopted as a foreign root.`);
+    }
+    for (const fleet of await listRegisteredFleets({ globalRoot: request.globalRoot })) {
+      const fleetForms = [resolve23(fleet.root), ...await realpath2(fleet.root).then((path) => [path], () => [])];
+      if (sourceForms.some((source) => fleetForms.some((root) => containsPath2(root, source)))) {
+        throw new Error(`Source root ${sourceRoot} is inside registered Fleet '${fleet.id}'; use fleet normalize or ownership retire-stale.`);
+      }
+    }
+    sourceClass = "foreign-root";
+  }
+  return {
+    targetRoot,
+    adapter: request.adapter,
+    installationType,
+    sourceStateKey,
+    destinationStateKey,
+    fingerprint,
+    sourceRoot,
+    sourceOwner,
+    workspaceRoot,
+    destinationOwner,
+    sourceClass
+  };
+}
+function legacyFingerprint(adapter, installationType, stateKey) {
+  const prefix = `${adapter}.${installationType}.`;
+  const fingerprint = stateKey.startsWith(prefix) ? stateKey.slice(prefix.length) : "";
+  return /^[a-f0-9]{64}$/u.test(fingerprint) ? fingerprint : void 0;
+}
+async function selectLegacySource(input, stateKey, fingerprint, source, desiredByPath) {
+  if (source.adapterCode) {
+    throw new Error(`The install manifest for ${stateKey} records programmatic adapter code; legacy ownership adoption refuses it.`);
+  }
+  if (source.entries.some((entry) => entry.workspaceOwner === input.destinationOwner)) {
+    throw new Error(
+      `Source state ${stateKey} has entries already owned by the destination owner; run a normal install to migrate them first.`
+    );
+  }
+  for (const entry of source.entries) {
+    if (entry.workspaceOwner === input.sourceOwner) assertPlainEntry(entry, input.targetRoot);
+  }
+  const entries = [];
+  const retained = [];
+  for (const entry of source.entries) {
+    if (entry.workspaceOwner !== input.sourceOwner) {
+      retained.push({ path: entry.path, owner: entry.workspaceOwner, reason: "other-owner" });
+      continue;
+    }
+    const desired = desiredByPath.get(entry.path) ?? [];
+    if (desired.length === 0) {
+      retained.push({ path: entry.path, owner: entry.workspaceOwner, reason: "not-desired" });
+      continue;
+    }
+    if (!desired.some((item) => desiredCovers(item, entry))) {
+      throw new Error(`The current graph plans a different artifact at ${entry.path}; legacy ownership cannot be adopted there.`);
+    }
+    entries.push(entry);
+  }
+  if (entries.length === 0) {
+    throw new Error(`Nothing to adopt: no entry owned by ${input.sourceOwner} in ${stateKey} is desired by this workspace.`);
+  }
+  const paths = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (paths.has(entry.path)) throw new Error(`Source state ${stateKey} has more than one entry at ${entry.path}.`);
+    paths.add(entry.path);
+  }
+  return { entries, retained, provenance: await resolveProvenance(input, fingerprint, entries) };
+}
+async function assertRetirableDuplicate(input, item, paths, selectedByPath, desiredByPath, transport) {
+  const refuse = (path, reason) => new Error(
+    `${path} is also claimed by ${input.sourceOwner} in ${item.fileName}, which a follow-up adopt-legacy run could not retire: ${reason}`
+  );
+  const fingerprint = legacyFingerprint(input.adapter, input.installationType, item.stateKey);
+  if (!fingerprint) throw refuse(paths[0], `${item.stateKey} is not a legacy fingerprint state key for ${input.adapter}/${input.installationType}.`);
+  let duplicates;
+  try {
+    const identity = { targetRoot: input.targetRoot, adapter: input.adapter, installationType: input.installationType };
+    const manifest = await requireManifest(identity, item.stateKey, transport, "duplicate source");
+    duplicates = (await selectLegacySource(input, item.stateKey, fingerprint, manifest, desiredByPath)).entries;
+  } catch (error) {
+    throw refuse(paths[0], error instanceof Error ? error.message : String(error));
+  }
+  for (const path of paths) {
+    const duplicate = duplicates.find((entry) => entry.path === path);
+    if (!duplicate || !sameRecordedArtifact(duplicate, selectedByPath.get(path))) {
+      throw refuse(path, "its artifact identity or recorded hashes differ from the adopted entry.");
+    }
+  }
+}
+async function resolveProvenance(input, fingerprint, entries) {
+  const locks = await findLegacyNamedLocks(input.sourceRoot, input.adapter, fingerprint);
+  if (locks.length === 0) {
+    throw new Error(
+      `Source root ${input.sourceRoot} has no legacy-named graph lock for ${input.adapter}/${fingerprint}; provenance cannot be proven.`
+    );
+  }
+  if (input.sourceClass === "own-legacy-owner") return locks[0];
+  if (locks.length !== 1) {
+    throw new Error(`Source root ${input.sourceRoot} must have exactly one legacy-named graph lock for ${fingerprint}, found ${locks.length}.`);
+  }
+  const lock = locks[0];
+  for (const entry of entries) {
+    if (entry.graphLockDigest !== lock.digest) {
+      throw new Error(`Recorded graph-lock digest for ${entry.path} does not match ${lock.path}.`);
+    }
+    if (!lockCoversEntry(lock.lock, entry)) {
+      throw new Error(`Legacy graph lock ${lock.path} does not cover ${entry.path} with its recorded node, selector, and source hash.`);
+    }
+  }
+  return lock;
+}
+async function readDestination(identity, stateKey, transport) {
+  if (!await readInstallManifest(identity.targetRoot, identity.adapter, transport, { installationType: identity.installationType, stateKey })) {
+    return void 0;
+  }
+  return requireManifest(identity, stateKey, transport, "destination");
+}
+function assertPlainEntry(entry, targetRoot) {
+  if (entry.mode || entry.mergeStrategy || entry.semanticPlugin || entry.semanticCommand || entry.executed) {
+    throw new Error(`Legacy ownership adoption supports only plain file or directory entries; ${entry.path} is not one.`);
+  }
+  containedArtifactPath(targetRoot, entry.path);
+}
+function desiredCovers(item, entry) {
+  return item.artifactType === entry.artifactType && item.artifactName === entry.artifactName && item.kind === entry.kind && (!item.packageName || !entry.packageName || item.packageName === entry.packageName);
+}
+function coversSourceEntry(destination, source, owner) {
+  return destination.workspaceOwner === owner && !destination.mode && !destination.mergeStrategy && !destination.semanticPlugin && sameRecordedArtifact(destination, source);
+}
+function sameRecordedArtifact(left, right) {
+  return left.artifactType === right.artifactType && left.artifactName === right.artifactName && left.kind === right.kind && left.hash === right.hash && left.sourceHash === right.sourceHash;
+}
+async function assertNoPendingJournals(targetRoot, adapter, transport) {
+  const pending = await listAllApplyJournals(targetRoot, adapter, transport);
+  if (pending.length > 0) {
+    throw new Error(`Cannot adopt legacy ownership while runtime apply journal(s) are pending: ${pending.map((item) => item.path).join(", ")}`);
+  }
+}
+function assertApplyPreconditions2(request) {
+  for (const [label, value, allowAbsent] of [
+    ["plan digest", request.planDigest, false],
+    ["source manifest revision", request.expectedSourceRevision, false],
+    ["destination manifest revision", request.expectedDestinationRevision, true],
+    ["manifest inventory revision", request.expectedInventoryRevision, false]
+  ]) {
+    if (allowAbsent && value === absentRevision) continue;
+    if (!value || !/^[a-f0-9]{64}$/.test(value)) {
+      throw new Error(`Applying legacy ownership adoption requires a reviewed lowercase SHA-256 ${label}${allowAbsent ? " or 'absent'" : ""}.`);
+    }
+  }
+}
+function containsPath2(parent, candidate) {
+  const path = relative9(parent, candidate);
+  return path === "" || !path.startsWith("..") && !isAbsolute3(path);
+}
+
 // src/version/policy.ts
 import { execFile as execFile3 } from "child_process";
 import { readFile as readFile23 } from "fs/promises";
-import { join as join40, resolve as resolve23 } from "path";
+import { join as join40, resolve as resolve24 } from "path";
 import { promisify as promisify3 } from "util";
 import { parse as parseJsonc } from "jsonc-parser";
 import { z as z5 } from "zod";
@@ -10563,7 +11057,7 @@ async function discoverVersionsFromSource(pkg, workspaceRoot) {
     if (tagged.length > 0) return tagged;
   }
   if (driverName === "local") {
-    const root = resolve23(workspaceRoot, pkg.source);
+    const root = resolve24(workspaceRoot, pkg.source);
     const manifest2 = await readPackageManifest(root);
     const current = manifest2 ? [{ version: manifest2.version, ref: pkg.requestedRef ?? root }] : [];
     try {
@@ -10686,7 +11180,7 @@ async function readVersionCache(path) {
 // src/profile/members.ts
 import { execFile as execFile4 } from "child_process";
 import { readFile as readFile24 } from "fs/promises";
-import { join as join41, resolve as resolve24 } from "path";
+import { join as join41, resolve as resolve25 } from "path";
 import { promisify as promisify4 } from "util";
 import { z as z7 } from "zod";
 
@@ -10861,7 +11355,7 @@ async function invokeMemberStatus(member, parentWorkspace, chain, options, cliEn
   let stderr = "";
   try {
     if (member.transport === "local") {
-      const workspace = resolve24(parentWorkspace, member.workspace);
+      const workspace = resolve25(parentWorkspace, member.workspace);
       const result = await execFileAsync4(process.execPath, [cliEntry, ...args], {
         cwd: workspace,
         env: env2,
@@ -10907,7 +11401,7 @@ async function runMemberAgentwheel(member, parentWorkspace, args, chain) {
         process.execPath,
         [process.argv[1], ...memberCommandArgs(member, args)],
         {
-          cwd: resolve24(parentWorkspace, member.workspace),
+          cwd: resolve25(parentWorkspace, member.workspace),
           env: env2,
           maxBuffer: 20 * 1024 * 1024
         }
@@ -11013,7 +11507,7 @@ function assertNoCompositeCycle(workspaceRoot, profileName, chain) {
   }
 }
 function compositeKey(workspaceRoot, profileName) {
-  return `${resolve24(workspaceRoot)}#${profileName}`;
+  return `${resolve25(workspaceRoot)}#${profileName}`;
 }
 
 // src/status/repository.ts
@@ -11060,7 +11554,7 @@ function valueAfter(lines, prefix) {
 }
 
 // src/catalogue/client.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { readFile as readFile25, rm as rm8 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 import { join as join42 } from "path";
@@ -11335,7 +11829,7 @@ var CatalogueClient = class {
     }
     return {
       value: schema.parse(value),
-      digest: createHash11("sha256").update(bytes).digest("hex")
+      digest: createHash12("sha256").update(bytes).digest("hex")
     };
   }
 };
@@ -11346,7 +11840,7 @@ function sameSources2(a, b) {
   return a.length === b.length && a.every((source, index) => source === b[index]);
 }
 function catalogueContentHash(enriched, vercel) {
-  return createHash11("sha256").update(JSON.stringify({ enriched, vercel })).digest("hex");
+  return createHash12("sha256").update(JSON.stringify({ enriched, vercel })).digest("hex");
 }
 
 // src/search/index.ts
@@ -11708,7 +12202,7 @@ function includesToken(normalizedText, token) {
 }
 
 // src/semantic/index.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { homedir as homedir10 } from "os";
 import { join as join43 } from "path";
 import { env, pipeline } from "@huggingface/transformers";
@@ -11798,7 +12292,7 @@ var SemanticSearchClient = class {
     if (!response.ok) throw new Error(`Semantic index file failed (${response.status}): ${descriptor.path}`);
     const bytes = new Uint8Array(await response.arrayBuffer());
     if (bytes.byteLength !== descriptor.bytes) throw new Error(`Semantic index file size does not match: ${descriptor.path}`);
-    const digest2 = createHash12("sha256").update(bytes).digest("hex");
+    const digest2 = createHash13("sha256").update(bytes).digest("hex");
     if (digest2 !== descriptor.sha256) throw new Error(`Semantic index checksum does not match: ${descriptor.path}`);
     return bytes;
   }
@@ -11888,7 +12382,7 @@ function ensureTrailingSlash(value) {
 }
 
 // src/trial/skill.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import { readFile as readFile26, stat as stat13 } from "fs/promises";
 import { join as join44 } from "path";
 import { parse as parseYaml2 } from "yaml";
@@ -11918,7 +12412,7 @@ async function createSkillTrial(driver, resolved, selectors) {
     skill: {
       name: artifact.name,
       relativePath: artifact.relativePath,
-      sha256: createHash13("sha256").update(content).digest("hex"),
+      sha256: createHash14("sha256").update(content).digest("hex"),
       frontmatter,
       content
     }
@@ -11937,12 +12431,12 @@ function readSkillFrontmatter(content, artifact) {
 }
 
 // src/lifecycle/fleet-normalize.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { readFile as readFile27, readdir as readdir11, rm as rm9 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname22, isAbsolute as isAbsolute3, join as join45, relative as relative9, resolve as resolve25 } from "path";
+import { dirname as dirname22, isAbsolute as isAbsolute4, join as join45, relative as relative10, resolve as resolve26 } from "path";
 async function planFleetNormalization(request) {
-  const normalizedRequest = normalizeRequest2(request);
+  const normalizedRequest = normalizeRequest3(request);
   const destinationScope = await resolveWorkspaceScope({
     fleet: normalizedRequest.destinationFleet,
     globalRoot: normalizedRequest.globalRoot
@@ -12014,7 +12508,7 @@ async function applyFleetNormalization(request, hooks = {}) {
   if (!request.apply) throw new Error("Fleet normalization is dry-run by default; pass --apply with --plan-digest <digest>.");
   if (!request.planDigest) throw new Error("Applying fleet normalization requires --plan-digest <digest> from a reviewed dry-run.");
   assertDigest(request.planDigest);
-  const normalizedRequest = normalizeRequest2(request);
+  const normalizedRequest = normalizeRequest3(request);
   const roots = await normalizationRoots(normalizedRequest);
   const ordered = [.../* @__PURE__ */ new Set([roots.source, roots.destination])].sort((a, b) => a.localeCompare(b));
   return withOrderedLocks(ordered, async () => {
@@ -12153,7 +12647,7 @@ async function assertNormalizationPostconditions(journal) {
   }
 }
 async function recoverFleetNormalization(request) {
-  const normalizedRequest = normalizeRequest2(request);
+  const normalizedRequest = normalizeRequest3(request);
   const roots = await normalizationRoots(normalizedRequest);
   const ordered = [.../* @__PURE__ */ new Set([roots.source, roots.destination])].sort((a, b) => a.localeCompare(b));
   return withOrderedLocks(ordered, async () => {
@@ -12196,7 +12690,7 @@ async function assertSourceFleetPostcondition(request, source, selectedPackages)
     );
   }
 }
-function normalizeRequest2(request) {
+function normalizeRequest3(request) {
   const packages = request.packages === void 0 ? void 0 : sortedUnique6(request.packages);
   if (request.packages !== void 0 && packages?.length === 0) throw new Error("--package requires at least one package name.");
   const artifacts = request.artifacts === void 0 ? void 0 : sortedUnique6(request.artifacts.map((artifact) => normalizeArtifactSelector(artifact)));
@@ -12218,17 +12712,17 @@ function normalizeRequest2(request) {
     ...profile ? { profile } : {},
     ...agent ? { agent } : {},
     ...orphanedOwnerRoots ? { orphanedOwnerRoots } : {},
-    ...request.globalRoot ? { globalRoot: resolve25(request.globalRoot) } : {}
+    ...request.globalRoot ? { globalRoot: resolve26(request.globalRoot) } : {}
   };
 }
 function normalizeOrphanedOwnerRoot(value) {
   const root = value.trim();
-  if (!root || !isAbsolute3(root)) throw new Error(`Invalid orphaned owner root '${value}'; expected an absolute workspace path.`);
-  return resolve25(root);
+  if (!root || !isAbsolute4(root)) throw new Error(`Invalid orphaned owner root '${value}'; expected an absolute workspace path.`);
+  return resolve26(root);
 }
 async function normalizationRoots(request) {
   const destination = await showRegisteredFleet(request.destinationFleet, { globalRoot: request.globalRoot });
-  const source = request.from === "user" ? resolve25(request.globalRoot ?? homedir11()) : (await showRegisteredFleet(request.from.slice("fleet:".length), { globalRoot: request.globalRoot })).root;
+  const source = request.from === "user" ? resolve26(request.globalRoot ?? homedir11()) : (await showRegisteredFleet(request.from.slice("fleet:".length), { globalRoot: request.globalRoot })).root;
   return { source, destination: destination.root };
 }
 async function withOrderedLocks(roots, fn) {
@@ -12443,7 +12937,7 @@ async function inspectLegacySelfInstalledState(fleet, packageNames, profileName,
   let normalizedGraphCount = 0;
   for (const graph of graphCandidates) {
     const destinationState = await targetStateForGraph(fleet, graph, fleet.fleetId, allowOrphanedRetiredPackages);
-    if (resolve25(destinationState.graphLockPath) === resolve25(graph.path)) {
+    if (resolve26(destinationState.graphLockPath) === resolve26(graph.path)) {
       const destinationManifest = (await collectManifestPaths([destinationState.manifestPath]))[0];
       if (destinationManifest?.manifest.entries.some((entry) => entry.workspaceOwner === fleetOwner && entryMatchesPackages(entry, selected))) {
         assertCorrelatedGraphManifest(
@@ -12458,7 +12952,7 @@ async function inspectLegacySelfInstalledState(fleet, packageNames, profileName,
       }
     }
     const legacyState = await legacyTargetStateForGraph(fleet, graph, allowOrphanedRetiredPackages);
-    if (resolve25(legacyState.graphLockPath) !== resolve25(graph.path)) {
+    if (resolve26(legacyState.graphLockPath) !== resolve26(graph.path)) {
       throw new Error(`Legacy graph lock target identity is stale or noncanonical: ${graph.path}`);
     }
     const legacyManifest = (await collectManifestPaths([legacyState.manifestPath]))[0];
@@ -12633,7 +13127,7 @@ function targetKeysForAgent(scope, 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")) {
-    roots.add(resolve25(process.env.AGENTWHEEL_TEST_HOME || process.env.HOME || homedir11()));
+    roots.add(resolve26(process.env.AGENTWHEEL_TEST_HOME || process.env.HOME || homedir11()));
   }
   for (const [name, agent] of Object.entries(scope.config.agents)) {
     if (agent.transport === "ssh") throw new Error(`Installed-state normalization cannot inspect SSH agent '${name}' locally.`);
@@ -12670,14 +13164,14 @@ async function collectManifests(roots) {
         }
         continue;
       }
-      if (resolve25(parsed.targetRoot) !== resolve25(root)) {
+      if (resolve26(parsed.targetRoot) !== resolve26(root)) {
         throw new Error(`Install manifest target root does not match its enumerated runtime root: ${path}`);
       }
       const expectedPath = installManifestPath(parsed.targetRoot, parsed.adapter, {
         installationType: parsed.installationType,
         stateKey: parsed.stateKey
       });
-      if (resolve25(expectedPath) !== resolve25(path)) {
+      if (resolve26(expectedPath) !== resolve26(path)) {
         throw new Error(`Install manifest state identity does not match its canonical path: ${path}`);
       }
       found.set(path, { path, raw, manifest: { ...parsed, revision: computeManifestRevision(raw), legacy: false } });
@@ -12698,7 +13192,7 @@ async function collectManifestPaths(paths) {
       installationType: parsed.installationType,
       stateKey: parsed.stateKey
     });
-    if (resolve25(expectedPath) !== resolve25(path)) {
+    if (resolve26(expectedPath) !== resolve26(path)) {
       throw new Error(`Install manifest state identity does not match its canonical path: ${path}`);
     }
     found.push({ path, raw, manifest: { ...parsed, revision: computeManifestRevision(raw), legacy: false } });
@@ -12724,7 +13218,7 @@ async function relevantGraphLocks(workspaceRoot, selected, targetKeys, include)
     if (!path.endsWith(".graph-lock.json")) continue;
     const lock = await readGraphLock(path);
     if (!lock.canonical.roots.some((candidate2) => selected.has(candidate2.rootId))) continue;
-    const parts = relative9(root, path).split(/[\\/]/);
+    const parts = relative10(root, path).split(/[\\/]/);
     if (parts.length !== 3) throw new Error(`Graph lock path is not canonical: ${path}`);
     const [targetKey2, adapter] = parts;
     if (targetKeys && !targetKeys.has(targetKey2)) continue;
@@ -12766,7 +13260,7 @@ async function hasRelevantLegacyManifestCandidate(scope, graph, selected) {
   const legacyManifest = (await collectManifestPaths([legacyState.manifestPath]))[0];
   if (legacyManifest?.manifest.entries.some((entry) => entryMatchesGraphPackages(entry, graph.lock, selected))) return true;
   const stableState = await targetStateForGraph(scope, graph, scope.fleetId ?? null);
-  if (resolve25(stableState.graphLockPath) !== resolve25(graph.path)) return false;
+  if (resolve26(stableState.graphLockPath) !== resolve26(graph.path)) return false;
   const stableManifest = (await collectManifestPaths([stableState.manifestPath]))[0];
   return stableManifest?.manifest.entries.some((entry) => entryMatchesGraphPackages(entry, graph.lock, selected)) ?? false;
 }
@@ -12787,7 +13281,7 @@ async function legacyManifestPathForConfiguredTarget(scope, graph) {
     baseDir: scope.root
   });
   const targetRoot = resolveConfigPath(agent.root, scope.root);
-  const installRoot = resolve25(installRootForAdapterInstallationType(adapter, targetRoot, agent.installationType, false));
+  const installRoot = resolve26(installRootForAdapterInstallationType(adapter, targetRoot, agent.installationType, false));
   const stateKey = stateKeyFor(adapter.name, {
     installationType: agent.installationType,
     stateKey: agent.stateKey,
@@ -12855,7 +13349,7 @@ async function targetStateForGraph(scope, graph, identityFleetId = scope.fleetId
     ssh: void 0,
     ...agent?.stateKey ? { stateKey: agent.stateKey } : {}
   };
-  const installRoot = resolve25(installRootForAdapterInstallationType(adapter, targetRoot, installationType, false));
+  const installRoot = resolve26(installRootForAdapterInstallationType(adapter, targetRoot, installationType, false));
   const targetIdentity = resolveTargetStateIdentity({
     targetFingerprintParts: fingerprintParts,
     workspaceRoot: scope.root,
@@ -12887,16 +13381,16 @@ async function targetStateForGraph(scope, graph, identityFleetId = scope.fleetId
 async function installedTargetStateForGraph(scope, graph, manifests, owners, selected, identityFleetId = scope.fleetId ?? null) {
   const stable = await targetStateForGraph(scope, graph, identityFleetId);
   let state;
-  if (resolve25(graph.path) === resolve25(stable.graphLockPath)) {
+  if (resolve26(graph.path) === resolve26(stable.graphLockPath)) {
     state = stable;
   } else {
     const released = await releasedTargetStateForGraph(scope, graph, identityFleetId);
-    if (resolve25(graph.path) !== resolve25(released.graphLockPath)) {
+    if (resolve26(graph.path) !== resolve26(released.graphLockPath)) {
       throw new Error(`Graph lock target identity is stale or noncanonical: ${graph.path}`);
     }
     state = released;
   }
-  const manifest = manifests.find((candidate) => resolve25(candidate.path) === resolve25(state.manifestPath));
+  const manifest = manifests.find((candidate) => resolve26(candidate.path) === resolve26(state.manifestPath));
   if (!manifest) {
     throw new Error(`Graph lock is not covered by its canonical install manifest: ${state.manifestPath}`);
   }
@@ -12928,7 +13422,7 @@ async function releasedTargetStateForGraph(scope, graph, identityFleetId = scope
   };
 }
 function assertCorrelatedGraphManifest(graph, state, manifest, owners, selected) {
-  if (manifest.manifest.adapter !== state.adapter || manifest.manifest.installationType !== state.installationType || manifest.manifest.stateKey !== state.stateKey || resolve25(manifest.manifest.targetRoot) !== resolve25(state.installRoot)) {
+  if (manifest.manifest.adapter !== state.adapter || manifest.manifest.installationType !== state.installationType || manifest.manifest.stateKey !== state.stateKey || resolve26(manifest.manifest.targetRoot) !== resolve26(state.installRoot)) {
     throw new Error(`Install manifest identity does not match graph target state: ${manifest.path}`);
   }
   const entries = manifest.manifest.entries.filter((entry) => entryMatchesGraphPackages(entry, graph.lock, selected));
@@ -12985,7 +13479,7 @@ function destinationGraphFromSource(source, targetFingerprint) {
 function mergeDestinationManifest(existing, state, generatedAt, desiredEntries, replaceOwners = /* @__PURE__ */ new Set()) {
   if (existing) {
     const manifest2 = existing.manifest;
-    if (manifest2.adapter !== state.adapter || manifest2.installationType !== state.installationType || manifest2.stateKey !== state.stateKey || resolve25(manifest2.targetRoot) !== state.installRoot) {
+    if (manifest2.adapter !== state.adapter || manifest2.installationType !== state.installationType || manifest2.stateKey !== state.stateKey || resolve26(manifest2.targetRoot) !== state.installRoot) {
       throw new Error(`Destination manifest identity diverges from the derived target: ${existing.path}`);
     }
   }
@@ -13045,7 +13539,7 @@ async function assertEquivalentRuntimeState(entry, sourcePath, destinationPath)
       const content = await readFile27(path, "utf8");
       if (hasMergeRemovalContent(entry.mergeRemoval)) {
         assertExactMergeContribution(entry.mergeRemoval, entry.mergeStrategy, content);
-      } else if (resolve25(sourcePath) === resolve25(destinationPath) && entry.mergeStrategy !== "codex-toml-mcp") {
+      } else if (resolve26(sourcePath) === resolve26(destinationPath) && entry.mergeStrategy !== "codex-toml-mcp") {
         assertExactMergeContribution({}, entry.mergeStrategy, content);
       } else {
         throw new Error(`Installed-state normalization cannot prove incomplete merge ownership at ${path}.`);
@@ -13056,8 +13550,8 @@ async function assertEquivalentRuntimeState(entry, sourcePath, destinationPath)
   await assertEquivalentRuntimeBytes(sourcePath, destinationPath, entry.hash);
 }
 function renderedEntryPathForRoot(root, entryPath) {
-  const normalizedRoot = resolve25(root);
-  const candidate = resolve25(normalizedRoot, entryPath);
+  const normalizedRoot = resolve26(root);
+  const candidate = resolve26(normalizedRoot, entryPath);
   if (candidate !== normalizedRoot && !candidate.startsWith(`${normalizedRoot}/`)) {
     throw new Error(`Install manifest entry escapes its target root: ${entryPath}`);
   }
@@ -13148,8 +13642,8 @@ function ownerMatchesGraphPackage(lock, owner, selected) {
   return ownerMatchesPackage(owner, selected) || lock.canonical.roots.some((root) => selected.has(root.rootId) && root.graphNodeId === owner);
 }
 function renderedEntryPath(manifest, entry) {
-  const root = resolve25(manifest.targetRoot);
-  const candidate = resolve25(root, entry.path);
+  const root = resolve26(manifest.targetRoot);
+  const candidate = resolve26(root, entry.path);
   if (candidate !== root && !candidate.startsWith(`${root}/`)) {
     throw new Error(`Install manifest entry escapes its target root: ${entry.path}`);
   }
@@ -13503,7 +13997,7 @@ function sortValue(value) {
   return value;
 }
 function sha2565(value) {
-  return createHash14("sha256").update(value).digest("hex");
+  return createHash15("sha256").update(value).digest("hex");
 }
 function assertDigest(value) {
   if (!/^[a-f0-9]{64}$/.test(value)) throw new Error(`Invalid plan digest: ${value}`);
@@ -13543,6 +14037,7 @@ var commandGovernance = {
   "ownership handoff": "governed-unless-dry-run",
   "ownership recovery-plan": "incidental-cache",
   "ownership retire-stale": "governed-apply",
+  "ownership adopt-legacy": "governed-apply",
   "mcp retire": "governed-apply",
   eject: "governed-always",
   uninstall: "governed-unless-dry-run",
@@ -13938,10 +14433,13 @@ program.command("remember").description("append text to the local instructions o
   console.log(nextInstallNudge());
 });
 var ownershipCommand = program.command("ownership").description("inspect and transfer manifest ownership without rewriting runtime artifacts");
-ownershipCommand.command("handoff").description("transfer one managed artifact between Agentwheel workspace roots").argument("<selector>", "exact artifact selector in type/name form").requiredOption("--from-workspace-root <path>", "current owning workspace root").requiredOption("--to-workspace-root <path>", "new owning workspace root").option("--to-fleet <id>", "qualify the new owner with a registered fleet id").option("--expected-hash <sha256>", "expected current artifact hash; required when applying").option("--expected-revision <sha256>", "expected install manifest revision; required when applying").option("--adapter <adapter>", "built-in adapter").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "use the user workspace", false).option("--local", "use the nearest local workspace", false).option("--fleet <id>", "use one registered named fleet").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--profile <name>", "workspace runtime profile (must resolve to one target)").option("--dry-run", "validate all preconditions without writing the manifest", false).action(async (selector, options) => {
+ownershipCommand.command("handoff").description("transfer one managed artifact between Agentwheel workspace roots").argument("<selector>", "exact artifact selector in type/name form").option("--from-workspace-root <path>", "current owning workspace root").option("--from-unknown-owner", "hand off an artifact recorded as workspace:unknown", false).requiredOption("--to-workspace-root <path>", "new owning workspace root").option("--to-fleet <id>", "qualify the new owner with a registered fleet id").option("--expected-hash <sha256>", "expected recorded artifact hash; required when applying").option("--expected-revision <sha256>", "expected install manifest revision; required when applying").option("--carry-drift", "accept a file or directory whose runtime differs from the recorded hash; the recorded hash is kept", false).option("--expected-runtime-hash <sha256>", "expected drifted runtime hash; required when applying with --carry-drift").option("--adapter <adapter>", "built-in adapter").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "use the user workspace", false).option("--local", "use the nearest local workspace", false).option("--fleet <id>", "use one registered named fleet").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--profile <name>", "workspace runtime profile (must resolve to one target)").option("--dry-run", "validate all preconditions without writing the manifest", false).action(async (selector, options) => {
   if (!options.dryRun && (!options.expectedHash || !options.expectedRevision)) {
     throw new Error("Applying an ownership handoff requires --expected-hash and --expected-revision from a reviewed --dry-run.");
   }
+  if (Boolean(options.fromWorkspaceRoot) === (options.fromUnknownOwner === true)) {
+    throw new Error("Ownership handoff requires exactly one of --from-workspace-root or --from-unknown-owner.");
+  }
   const normalizedOptions = normalizeRuntimeScopeOptions(options);
   const targets = await resolveCliTargets(normalizedOptions);
   if (targets.length !== 1) {
@@ -13962,7 +14460,7 @@ ownershipCommand.command("handoff").description("transfer one managed artifact b
   const toWorkspaceRoot = normalizeCliPath(options.toWorkspaceRoot);
   if (options.toFleet) {
     const fleet = await showRegisteredFleet(options.toFleet);
-    if (resolve26(fleet.root) !== resolve26(toWorkspaceRoot)) {
+    if (resolve27(fleet.root) !== resolve27(toWorkspaceRoot)) {
       throw new Error(`Destination fleet '${options.toFleet}' is registered at ${fleet.root}, not ${toWorkspaceRoot}.`);
     }
   }
@@ -13973,11 +14471,13 @@ ownershipCommand.command("handoff").description("transfer one managed artifact b
     adapter: adapter.name,
     artifactType,
     artifactName,
-    fromWorkspaceRoot: normalizeCliPath(options.fromWorkspaceRoot),
+    ...options.fromUnknownOwner === true ? { fromUnknownOwner: true } : { fromWorkspaceRoot: normalizeCliPath(options.fromWorkspaceRoot) },
     toWorkspaceRoot,
     toFleetId: options.toFleet,
     expectedHash: options.expectedHash,
     expectedRevision: options.expectedRevision,
+    carryDrift: options.carryDrift === true,
+    expectedRuntimeHash: options.expectedRuntimeHash,
     transport: transportForTarget(target)
   };
   const result = options.dryRun ? await planArtifactOwnershipHandoff(request) : await applyArtifactOwnershipHandoff(request);
@@ -13985,6 +14485,7 @@ ownershipCommand.command("handoff").description("transfer one managed artifact b
   console.log(`Target: ${result.adapter}/${result.installationType ?? "default"} at ${result.targetRoot}`);
   console.log(`Path: ${result.path}`);
   console.log(`Hash: ${result.artifactHash}`);
+  if (result.drifted) console.log(`Runtime hash: ${result.runtimeHash} (drift carried; the recorded hash is kept)`);
   console.log(`Manifest revision: ${result.manifestRevision}`);
   console.log(`Owner: ${result.fromOwner} -> ${result.toOwner}`);
 });
@@ -13996,49 +14497,15 @@ ownershipCommand.command("recovery-plan").description("write a read-only per-pat
   const adapter = await resolveAdapterForTarget(target, {});
   const transport = transportForTarget(target);
   const requestedReport = normalizeCliPath(options.report);
-  const reportPath = join46(await realpath2(dirname23(requestedReport)), basename21(requestedReport));
-  const reportInsideTarget = relative10(resolve26(target.targetRoot), reportPath);
-  if (reportInsideTarget === "" || !reportInsideTarget.startsWith("..") && !isAbsolute4(reportInsideTarget)) {
+  const reportPath = join46(await realpath3(dirname23(requestedReport)), basename21(requestedReport));
+  const reportInsideTarget = relative11(resolve27(target.targetRoot), reportPath);
+  if (reportInsideTarget === "" || !reportInsideTarget.startsWith("..") && !isAbsolute5(reportInsideTarget)) {
     throw new Error("Recovery report must be outside the runtime target root.");
   }
   const installationType = target.installationType ?? resolveInstallationTypeForAdapter(adapter, void 0);
   const config = await readMergedWorkspaceConfig(target.workspaceRoot);
   if (config.packages.length === 0) throw new Error("Fleet has no configured source packages.");
-  const stage = await mkdtemp4(join46(tmpdir5(), "agentwheel-recovery-"));
-  const priorTmpdir = process.env.TMPDIR;
-  try {
-    process.env.TMPDIR = stage;
-    const graphPlan = await createGraphSourcePlan({
-      roots: config.packages.map((pkg) => ({
-        rootId: pkg.name,
-        source: pkg.source,
-        mode: pkg.mode,
-        version: pkg.version,
-        ref: pkg.requestedRef,
-        select: pkg.selection ? void 0 : normalizeArtifactSelectors(pkg.select, pkg.skills),
-        selection: pkg.selection,
-        aliases: pkg.aliases,
-        overrides: pkg.overrides,
-        includeSuggestions: pkg.withSuggestions,
-        suggestionAliases: pkg.suggestions,
-        useLock: false
-      })),
-      targetRoot: target.targetRoot,
-      workspaceRoot: target.workspaceRoot,
-      fleetId: target.fleetId,
-      adapter,
-      transport,
-      targetKey: targetKeyForTarget(target, adapter.name),
-      targetFingerprintParts: targetFingerprintParts(target, adapter, adapterOptionsForTarget(target, {}), installationType),
-      installationType,
-      stateKey: target.stateKey,
-      readOnly: true,
-      yes: true,
-      freshGraphOnly: true,
-      deferForeignStateCheck: true,
-      cacheRoot: join46(stage, "source-cache"),
-      registryCachePath: join46(stage, "registry.json")
-    });
+  await withFreshReadOnlyGraphPlan(target, adapter, adapterOptionsForTarget(target, {}), installationType, config.packages, async (graphPlan) => {
     const installRoot = installRootForAdapterInstallationType(adapter, target.targetRoot, installationType, transport.kind === "ssh");
     const report = await planLegacyRecovery({
       graphPlan,
@@ -14056,17 +14523,13 @@ ownershipCommand.command("recovery-plan").description("write a read-only per-pat
 `, { mode: 384, flag: "wx" });
     console.log(`Recovery report: ${reportPath}`);
     console.log(JSON.stringify(report.counts));
-  } finally {
-    if (priorTmpdir === void 0) delete process.env.TMPDIR;
-    else process.env.TMPDIR = priorTmpdir;
-    await rm10(stage, { recursive: true, force: true });
-  }
+  });
 });
 ownershipCommand.command("retire-stale").description("retire stale source-manifest ownership already covered by one Fleet manifest").requiredOption("--from-workspace-root <path>", "exact stale workspace owner root").option("--from-fleet-id <id>", "exact stale Fleet owner id for same-Fleet duplicate state").requiredOption("--to-workspace-root <path>", "registered destination Fleet root").requiredOption("--source-state-key <key>", "exact source install-manifest state key").option("--destination-state-key <key>", "exact Fleet-owned destination install-manifest state key (defaults to the stable target state)").requiredOption("--fleet <id>", "registered destination Fleet").option("--adapter <adapter>", "built-in adapter").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named destination Fleet agent").option("--profile <name>", "destination Fleet profile resolving to one target").option("--plan-digest <sha256>", "reviewed plan digest; required with --apply").option("--expected-source-revision <sha256>", "reviewed source manifest revision; required with --apply").option("--expected-destination-revision <sha256>", "reviewed destination manifest revision; required with --apply").option("--expected-inventory-revision <sha256>", "reviewed runtime manifest inventory revision; required with --apply").option("--abandon-incomplete-merge-owner", "explicitly retire incomplete legacy merge metadata without changing runtime bytes", false).option("--apply", "apply the exact reviewed metadata-only retirement", false).option("--json", "print the complete deterministic plan as JSON", false).action(async (options) => {
   const normalizedOptions = normalizeRuntimeScopeOptions(options);
   const fleet = await showRegisteredFleet(options.fleet);
   const toWorkspaceRoot = normalizeCliPath(options.toWorkspaceRoot);
-  if (resolve26(fleet.root) !== resolve26(toWorkspaceRoot)) {
+  if (resolve27(fleet.root) !== resolve27(toWorkspaceRoot)) {
     throw new Error(`Destination Fleet '${options.fleet}' is registered at ${fleet.root}, not ${toWorkspaceRoot}.`);
   }
   const targets = await resolveCliTargets(normalizedOptions);
@@ -14074,7 +14537,7 @@ ownershipCommand.command("retire-stale").description("retire stale source-manife
     throw new Error(`Stale ownership retirement requires exactly one destination Fleet target, found ${targets.length}.`);
   }
   const target = targets[0];
-  if (target.fleetId !== options.fleet || resolve26(target.workspaceRoot) !== resolve26(fleet.root)) {
+  if (target.fleetId !== options.fleet || resolve27(target.workspaceRoot) !== resolve27(fleet.root)) {
     throw new Error(`Resolved target does not belong to destination Fleet '${options.fleet}'.`);
   }
   const adapterOptions = adapterOptionsForTarget(target, normalizedOptions);
@@ -14146,6 +14609,138 @@ ownershipCommand.command("retire-stale").description("retire stale source-manife
   console.log(`Plan digest: ${result.planDigest}`);
   if (!options.apply) console.log(`Apply: ${applyCommand}`);
 });
+ownershipCommand.command("adopt-legacy").description("move proven legacy-keyed ownership into this workspace's stable target state without rewriting runtime artifacts").requiredOption("--source-state-key <key>", "exact legacy install-manifest state key").requiredOption("--from-workspace-root <path>", "exact plain workspace owner root of the entries to move").option("--agent <name>", "named agent of this workspace").option("--profile <name>", "workspace profile resolving to one target").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("--carry-drift", "also move entries whose runtime differs from the recorded hash; the recorded hash is kept", false).option("--plan-digest <sha256>", "reviewed plan digest; required with --apply").option("--expected-source-revision <sha256>", "reviewed source manifest revision; required with --apply").option("--expected-destination-revision <sha256|absent>", "reviewed destination manifest revision; required with --apply").option("--expected-inventory-revision <sha256>", "reviewed runtime manifest inventory revision; required with --apply").option("--apply", "apply the exact reviewed metadata-only adoption", false).option("--json", "print the complete deterministic plan as JSON", false).action(async (options) => {
+  if (Boolean(options.agent) === Boolean(options.profile)) {
+    throw new Error("Legacy ownership adoption requires exactly one of --agent or --profile.");
+  }
+  const normalizedOptions = normalizeRuntimeScopeOptions(options);
+  const requestedInstallationType = normalizedOptions.installationType;
+  const plainInstallOptions = {
+    ...normalizedOptions,
+    installationType: void 0,
+    adapterConfig: void 0,
+    adapterModule: void 0
+  };
+  const targets = await resolveCliTargets(plainInstallOptions);
+  if (targets.length !== 1) {
+    throw new Error(`Legacy ownership adoption requires exactly one runtime target, found ${targets.length}.`);
+  }
+  const target = targets[0];
+  if (target.fleetId) {
+    throw new Error("Legacy ownership adoption targets a nested workspace; a Fleet target uses fleet normalize or ownership retire-stale.");
+  }
+  if (target.transport === "ssh") throw new Error("Legacy ownership adoption does not support SSH targets.");
+  const config = await readMergedWorkspaceConfig(target.workspaceRoot);
+  const groups = /* @__PURE__ */ new Map();
+  for (const pkg of config.packages) graphGroupForPackage(groups, target, pkg, plainInstallOptions).packages.push(pkg);
+  if (groups.size === 0) throw new Error(`No configured source packages in ${target.workspaceRoot}.`);
+  const installationTypes = [...new Set([...groups.values()].map((candidate) => candidate.installationType))];
+  if (installationTypes.length > 1) {
+    throw new Error(
+      `Configured packages use installation types ${installationTypes.join(", ")}, each with its own install state; legacy ownership adoption needs exactly one.`
+    );
+  }
+  if (requestedInstallationType !== void 0 && requestedInstallationType !== installationTypes[0]) {
+    throw new Error(
+      `--installation-type ${requestedInstallationType} does not match installation type ${installationTypes[0]}, which install uses for the configured packages.`
+    );
+  }
+  if (groups.size > 1) {
+    throw new Error(
+      `Configured packages resolve to ${groups.size} adapter configurations for ${installationTypes[0]}, each with its own install state; legacy ownership adoption needs exactly one.`
+    );
+  }
+  const group = [...groups.values()][0];
+  const { installationType, adapterOptions } = group;
+  const requestedAdapterSettings = [
+    { flag: "--adapter-config", requested: normalizedOptions.adapterConfig, resolved: adapterOptions.adapterConfig, none: "no adapter config" },
+    { flag: "--adapter-module", requested: normalizedOptions.adapterModule, resolved: adapterOptions.adapterModule, none: "no adapter module" }
+  ];
+  for (const { flag, requested, resolved, none } of requestedAdapterSettings) {
+    if (requested === void 0) continue;
+    if (resolved !== void 0 && resolve27(target.workspaceRoot, requested) === resolve27(target.workspaceRoot, resolved)) continue;
+    throw new Error(`${flag} ${requested} does not match what install resolves for the configured packages: ${resolved ?? none}.`);
+  }
+  const adapter = await resolveAdapterForTarget(group.target, adapterOptions);
+  const stable = installStateForTarget(group.target, adapter, adapterOptions, installationType);
+  const stableGraphLockPath = graphLockPathForTarget(
+    group.target.workspaceRoot,
+    targetKeyForTarget(group.target, adapter.name),
+    adapter.name,
+    targetFingerprintParts(group.target, adapter, adapterOptions, installationType),
+    targetIdentityContext(group.target, adapter, installationType)
+  );
+  const desiredCoverage = await withFreshReadOnlyGraphPlan(group.target, adapter, adapterOptions, installationType, group.packages, async (graphPlan) => {
+    if (graphPlan.plan.stateKey !== stable.stateKey || graphPlan.graphLockPath !== stableGraphLockPath) {
+      throw new Error("Current source graph resolved a different target state identity; legacy ownership adoption cannot proceed.");
+    }
+    return desiredCoverageFromPlan(graphPlan.plan);
+  });
+  const request = {
+    targetRoot: stable.installRoot,
+    adapter: adapter.name,
+    installationType,
+    sourceStateKey: options.sourceStateKey,
+    destinationStateKey: stable.stateKey,
+    fromWorkspaceRoot: normalizeCliPath(options.fromWorkspaceRoot),
+    workspaceRoot: target.workspaceRoot,
+    destinationFleetId: target.fleetId,
+    destinationGraphLockPath: stableGraphLockPath,
+    desiredCoverage,
+    carryDrift: options.carryDrift === true,
+    planDigest: options.planDigest,
+    expectedSourceRevision: options.expectedSourceRevision,
+    expectedDestinationRevision: options.expectedDestinationRevision,
+    expectedInventoryRevision: options.expectedInventoryRevision,
+    transport: transportForTarget(target)
+  };
+  const result = options.apply ? await applyAdoptLegacyOwnership(request) : await planAdoptLegacyOwnership(request);
+  const destinationRevision = result.destination.revision ?? "absent";
+  const applyArgs = [
+    "agentwheel",
+    "ownership",
+    "adopt-legacy",
+    "--source-state-key",
+    result.source.stateKey,
+    "--from-workspace-root",
+    request.fromWorkspaceRoot,
+    ...options.profile ? ["--profile", options.profile] : ["--agent", options.agent],
+    "--installation-type",
+    installationType,
+    ...options.adapterConfig ? ["--adapter-config", options.adapterConfig] : [],
+    ...options.adapterModule ? ["--adapter-module", options.adapterModule] : [],
+    ...options.allowAdapterCode ? ["--allow-adapter-code"] : [],
+    ...request.carryDrift ? ["--carry-drift"] : [],
+    "--plan-digest",
+    result.planDigest,
+    "--expected-source-revision",
+    result.source.revision,
+    "--expected-destination-revision",
+    destinationRevision,
+    "--expected-inventory-revision",
+    result.manifestInventoryRevision,
+    "--apply"
+  ];
+  const applyCommand = applyArgs.map(shellQuoteArgument).join(" ");
+  if (options.json) {
+    console.log(JSON.stringify({ ...result, applyCommand }, null, 2));
+    return;
+  }
+  console.log(`${options.apply ? "Adopted legacy ownership" : "Legacy ownership adoption plan"}: ${result.selected.length} entr${result.selected.length === 1 ? "y" : "ies"}`);
+  console.log(`Target: ${result.adapter}/${result.installationType} at ${result.targetRoot}`);
+  console.log(`Source: ${result.source.stateKey} revision ${result.source.revision} (${result.source.class}, ${result.source.owner})`);
+  console.log(`Provenance: ${result.source.provenanceLock.path} (${result.source.provenanceLock.digest})`);
+  console.log(`Destination: ${result.destination.stateKey} revision ${destinationRevision} (${result.destination.owner})`);
+  console.log(`Manifest inventory revision: ${result.manifestInventoryRevision}`);
+  for (const entry of result.selected) {
+    const drift = entry.drift ? ` drift: recorded ${entry.recordedHash}, runtime ${entry.runtimeHash ?? "missing"}` : "";
+    console.log(`- ${entry.path}: ${entry.action}${drift}`);
+  }
+  for (const entry of result.retained) console.log(`  retained ${entry.path} (${entry.reason}, ${entry.owner})`);
+  for (const entry of result.remainingDuplicates) console.log(`  duplicate claim remains in ${entry.stateKey}: ${entry.path}`);
+  console.log(`Plan digest: ${result.planDigest}`);
+  if (!options.apply) console.log(`Apply from ${target.workspaceRoot}: ${applyCommand}`);
+});
 var mcpCommand = program.command("mcp").description("operate on MCP runtime configuration");
 mcpCommand.command("retire").description("remove one exact legacy MCP contribution with explicit state ownership").argument("<package>", "configured package containing exactly one legacy MCP artifact").option("--user", "use the user workspace", false).option("--local", "use the nearest local workspace", false).option("--fleet <id>", "use one registered named fleet").option("-t, --target-root <path>", "explicit runtime/project root").option("--agent <name>", "one named agent from merged config").option("--profile <name>", "workspace runtime profile resolving to one target").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--from-workspace-root <path>", "required previous owner when managed legacy state exists").option("--dry-run", "show the retirement plan without writing (default)", false).option("--apply", "apply the exact reviewed retirement plan", false).option("--json", "print the install plan as JSON", false).action(async (packageName, options) => {
   if (options.apply && options.dryRun) throw new Error("--apply cannot be combined with --dry-run.");
@@ -14400,30 +14995,34 @@ async function runInstallCommand(nameOrSource, options, behavior) {
         throw teachingInstallError(nameOrSource, error);
       }
     }
-    for (const result of await buildGraphPlansForTarget(target, source, { ...targetOptions, scope, extraPackage, reportFormat: outputFormat }, { mode: "install" })) {
-      if (!behavior.quiet) console.log(formatGraphPlan(result));
-      if (behavior.apply) {
-        declareMutationPath(result.graphLockPath);
-        if (extraPackage && !targetOptions.onlySource) declareMutationPath(workspaceConfigPath(target.workspaceRoot));
-        const transport = transportForTarget(target);
-        const executePlugins = target.executePlugins ?? targetOptions.executePlugins;
-        await applyCombinedInstallPlan(result.plan, {
-          executePlugins,
-          transport,
-          graphLockDigest: result.graphLockDigest,
-          graphLock: { path: result.graphLockPath, lock: result.bundle.graphLock }
-        });
-        const reloaded = await reloadRuntimeAfterPluginChanges(result.plan, target, transport, {
-          enabled: target.reloadRuntimes ?? shouldReloadRuntimes(targetOptions),
-          executePlugins
-        });
-        if (!behavior.quiet) {
-          console.log(`Applied ${result.plan.adapter} at ${result.plan.targetRoot}.`);
-          if (reloaded) console.log(`Reloaded runtime via ${formatReloadCommands(target.reloadCommands)}.`);
+    const results = await buildGraphPlansForTarget(target, source, { ...targetOptions, scope, extraPackage, reportFormat: outputFormat }, { mode: "install" });
+    try {
+      for (const result of results) {
+        if (!behavior.quiet) console.log(formatGraphPlan(result));
+        if (behavior.apply) {
+          declareMutationPath(result.graphLockPath);
+          if (extraPackage && !targetOptions.onlySource) declareMutationPath(workspaceConfigPath(target.workspaceRoot));
+          const transport = transportForTarget(target);
+          const executePlugins = target.executePlugins ?? targetOptions.executePlugins;
+          await applyCombinedInstallPlan(result.plan, {
+            executePlugins,
+            transport,
+            graphLockDigest: result.graphLockDigest,
+            graphLock: { path: result.graphLockPath, lock: result.bundle.graphLock }
+          });
+          const reloaded = await reloadRuntimeAfterPluginChanges(result.plan, target, transport, {
+            enabled: target.reloadRuntimes ?? shouldReloadRuntimes(targetOptions),
+            executePlugins
+          });
+          if (!behavior.quiet) {
+            console.log(`Applied ${result.plan.adapter} at ${result.plan.targetRoot}.`);
+            if (reloaded) console.log(`Reloaded runtime via ${formatReloadCommands(target.reloadCommands)}.`);
+          }
         }
+        if (result.plan.hasBlockingChanges) process.exitCode = 1;
       }
-      await rm10(result.bundle.root, { recursive: true, force: true });
-      if (result.plan.hasBlockingChanges) process.exitCode = 1;
+    } finally {
+      await Promise.all(results.map((result) => rm10(result.bundle.root, { recursive: true, force: true })));
     }
     if (behavior.apply && extraPackage && !targetOptions.onlySource) {
       await writeWorkspaceConfig(target.workspaceRoot, upsertPackage(await readWorkspaceConfig(target.workspaceRoot), extraPackage));
@@ -14874,31 +15473,43 @@ async function runSkillUpdateCommand(skillName, options) {
 }
 async function runConfiguredGraphPackages(target, options, behavior) {
   const results = await buildGraphPlansForTarget(target, void 0, options, behavior);
-  for (const result of results) {
-    console.log(`${behavior.mode === "update" ? "Update" : "Install"} ${result.plan.adapter} at ${result.plan.targetRoot}:`);
-    console.log(formatGraphPlan(result));
-    if (!options.dryRun) {
-      declareMutationPath(result.graphLockPath);
-      const transport = transportForTarget(target);
-      const executePlugins = target.executePlugins ?? options.executePlugins;
-      await applyCombinedInstallPlan(result.plan, {
-        executePlugins,
-        transport,
-        graphLockDigest: result.graphLockDigest,
-        graphLock: { path: result.graphLockPath, lock: result.bundle.graphLock }
-      });
-      const reloaded = await reloadRuntimeAfterPluginChanges(result.plan, target, transport, {
-        enabled: target.reloadRuntimes ?? shouldReloadRuntimes(options),
-        executePlugins
-      });
-      console.log(`Applied ${result.plan.adapter} at ${result.plan.targetRoot}.`);
-      if (reloaded) console.log(`Reloaded runtime via ${formatReloadCommands(target.reloadCommands)}.`);
+  try {
+    for (const result of results) {
+      console.log(`${behavior.mode === "update" ? "Update" : "Install"} ${result.plan.adapter} at ${result.plan.targetRoot}:`);
+      console.log(formatGraphPlan(result));
+      if (!options.dryRun) {
+        declareMutationPath(result.graphLockPath);
+        const transport = transportForTarget(target);
+        const executePlugins = target.executePlugins ?? options.executePlugins;
+        await applyCombinedInstallPlan(result.plan, {
+          executePlugins,
+          transport,
+          graphLockDigest: result.graphLockDigest,
+          graphLock: { path: result.graphLockPath, lock: result.bundle.graphLock }
+        });
+        const reloaded = await reloadRuntimeAfterPluginChanges(result.plan, target, transport, {
+          enabled: target.reloadRuntimes ?? shouldReloadRuntimes(options),
+          executePlugins
+        });
+        console.log(`Applied ${result.plan.adapter} at ${result.plan.targetRoot}.`);
+        if (reloaded) console.log(`Reloaded runtime via ${formatReloadCommands(target.reloadCommands)}.`);
+      }
+      if (result.plan.hasBlockingChanges) process.exitCode = 1;
     }
-    await rm10(result.bundle.root, { recursive: true, force: true });
-    if (result.plan.hasBlockingChanges) process.exitCode = 1;
+  } finally {
+    await Promise.all(results.map((result) => rm10(result.bundle.root, { recursive: true, force: true })));
   }
 }
 async function buildGraphPlansForTarget(target, source, options, behavior) {
+  const bundleRoots = [];
+  try {
+    return await collectGraphPlansForTarget(target, source, options, behavior, bundleRoots);
+  } catch (error) {
+    await Promise.all(bundleRoots.map((root) => rm10(root, { recursive: true, force: true })));
+    throw error;
+  }
+}
+async function collectGraphPlansForTarget(target, source, options, behavior, bundleRoots) {
   const targetOptions = optionsForResolvedTarget(options, target);
   const config = await readMergedWorkspaceConfig(target.workspaceRoot);
   const groups = /* @__PURE__ */ new Map();
@@ -15092,6 +15703,7 @@ async function buildGraphPlansForTarget(target, source, options, behavior) {
       expectedFromWorkspaceOwner: targetOptions.expectedFromWorkspaceOwner,
       recoverLegacyState: targetOptions.recoverLegacyState
     });
+    bundleRoots.push(result.bundle.root);
     if ((behavior.mode === "install" || behavior.mode === "update") && scopedRootId) {
       const manifest = result.previousManifest;
       const previousLock = result.previousGraphLock;
@@ -15161,7 +15773,7 @@ function scopeUpdatePlanToDependencies(result, selectors, previousLock, manifest
     selectedPreviousNodeIds,
     selectedRootIds
   );
-  const graphLockDigest = createHash15("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
+  const graphLockDigest = createHash16("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
   return {
     ...result,
     bundle: { ...result.bundle, graphLock },
@@ -15287,7 +15899,7 @@ function operationBelongsToDependencyUpdate(operation, allowedNodeIds, allowedNa
 function scopeInstallPlanToArtifact(result, rootId, focused, manifest) {
   const scoped = scopePlanOperationsToArtifact(result, rootId, focused, manifest);
   const graphLock = focusedGraphLockForInstall(scoped.bundle.graphLock, rootId, focused);
-  const graphLockDigest = createHash15("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
+  const graphLockDigest = createHash16("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
   return {
     ...scoped,
     bundle: { ...scoped.bundle, graphLock },
@@ -15298,7 +15910,7 @@ function scopeInstallPlanToArtifact(result, rootId, focused, manifest) {
 function scopeUpdatePlanToArtifact(result, rootId, focused, previousLock, manifest) {
   const scoped = scopePlanOperationsToArtifact(result, rootId, focused, manifest, previousLock);
   const graphLock = mergeFocusedArtifactGraphLock(scoped.bundle.graphLock, previousLock, rootId, focused);
-  const graphLockDigest = createHash15("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
+  const graphLockDigest = createHash16("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
   return {
     ...scoped,
     bundle: { ...scoped.bundle, graphLock },
@@ -15593,7 +16205,7 @@ function scopeUpdatePlanToRoot(result, rootId, previousLock, manifest) {
     selectedPreviousNodeIds,
     /* @__PURE__ */ new Set([rootId])
   );
-  const graphLockDigest = createHash15("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
+  const graphLockDigest = createHash16("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
   return {
     ...scoped,
     bundle: { ...scoped.bundle, graphLock },
@@ -15728,7 +16340,7 @@ async function uninstallConfiguredPackage(target, packageName, options) {
     let renderedRoot;
     if (remainingGroup && remainingGroup.packages.length > 0) {
       const remainingAdapter = await resolveAdapterForTarget(remainingGroup.target, remainingGroup.adapterOptions);
-      const result2 = await createGraphSourcePlan({
+      const result = await createGraphSourcePlan({
         roots: remainingGroup.packages.map((pkg2) => ({
           rootId: pkg2.name,
           source: pkg2.source,
@@ -15760,46 +16372,49 @@ async function uninstallConfiguredPackage(target, packageName, options) {
         readOnly: options.dryRun === true,
         isTTY: process.stdin.isTTY === true
       });
-      remainingGraphPlan = result2;
-      remainingDesired = desiredArtifactsFromGraphBundle(result2.bundle);
-      renderedRoot = result2.bundle.root;
+      remainingGraphPlan = result;
+      remainingDesired = desiredArtifactsFromGraphBundle(result.bundle);
+      renderedRoot = result.bundle.root;
     }
-    const uninstallPlan = await createOwnershipUninstallPlan(manifest, remainingDesired, adapter, transport, {
-      graphLockDigest: remainingGraphPlan?.graphLockDigest
-    });
-    const transitionPlan = remainingGraphPlan?.plan;
-    const plan = {
-      ...uninstallPlan,
-      stateKey: transitionPlan?.stateKey ?? removedState.stableStateKey,
-      stateMigration: transitionPlan?.stateMigration ?? removedState.migration,
-      targetStateFilePreconditions: transitionPlan?.targetStateFilePreconditions ?? removedState.targetStateFilePreconditions
-    };
-    console.log(`Uninstall ${pkg.name} (${adapter.name} at ${removedTarget.targetRoot}):`);
-    console.log(formatPlan(plan));
-    const graphLockFinalState = remainingGraphPlan ? { graphLock: { path: remainingGraphPlan.graphLockPath, lock: remainingGraphPlan.bundle.graphLock } } : {
-      removeGraphLockPath: removedState.graphLockPath ?? removedState.stableGraphLockPath
-    };
-    if (!options.dryRun) {
-      declareMutationPath(workspaceConfigPath(target.workspaceRoot));
-      const declarativeGraphPath = remainingGraphPlan ? remainingGraphPlan.graphLockPath : removedState.graphLockPath ?? removedState.stableGraphLockPath;
-      declareMutationPath(declarativeGraphPath);
-    }
-    const result = await uninstall(plan, {
-      dryRun: options.dryRun,
-      force: options.force,
-      keepFiles: options.keepFiles,
-      transport,
-      ...graphLockFinalState,
-      workspaceConfig: {
-        path: workspaceConfigPath(target.workspaceRoot),
-        data: { ...config, packages: remaining }
+    try {
+      const uninstallPlan = await createOwnershipUninstallPlan(manifest, remainingDesired, adapter, transport, {
+        graphLockDigest: remainingGraphPlan?.graphLockDigest
+      });
+      const transitionPlan = remainingGraphPlan?.plan;
+      const plan = {
+        ...uninstallPlan,
+        stateKey: transitionPlan?.stateKey ?? removedState.stableStateKey,
+        stateMigration: transitionPlan?.stateMigration ?? removedState.migration,
+        targetStateFilePreconditions: transitionPlan?.targetStateFilePreconditions ?? removedState.targetStateFilePreconditions
+      };
+      console.log(`Uninstall ${pkg.name} (${adapter.name} at ${removedTarget.targetRoot}):`);
+      console.log(formatPlan(plan));
+      const graphLockFinalState = remainingGraphPlan ? { graphLock: { path: remainingGraphPlan.graphLockPath, lock: remainingGraphPlan.bundle.graphLock } } : {
+        removeGraphLockPath: removedState.graphLockPath ?? removedState.stableGraphLockPath
+      };
+      if (!options.dryRun) {
+        declareMutationPath(workspaceConfigPath(target.workspaceRoot));
+        const declarativeGraphPath = remainingGraphPlan ? remainingGraphPlan.graphLockPath : removedState.graphLockPath ?? removedState.stableGraphLockPath;
+        declareMutationPath(declarativeGraphPath);
       }
-    });
-    if (!options.dryRun) {
-      console.log(formatUninstallResult(result));
+      const result = await uninstall(plan, {
+        dryRun: options.dryRun,
+        force: options.force,
+        keepFiles: options.keepFiles,
+        transport,
+        ...graphLockFinalState,
+        workspaceConfig: {
+          path: workspaceConfigPath(target.workspaceRoot),
+          data: { ...config, packages: remaining }
+        }
+      });
+      if (!options.dryRun) {
+        console.log(formatUninstallResult(result));
+      }
+      if (plan.hasBlockingChanges) process.exitCode = 1;
+    } finally {
+      if (renderedRoot) await rm10(renderedRoot, { recursive: true, force: true });
     }
-    if (renderedRoot) await rm10(renderedRoot, { recursive: true, force: true });
-    if (plan.hasBlockingChanges) process.exitCode = 1;
   }
 }
 function graphGroupForPackage(groups, target, pkg, options) {
@@ -15855,6 +16470,49 @@ function targetFingerprintParts(target, adapter, options, installationType) {
     stateKey: target.stateKey
   };
 }
+async function withFreshReadOnlyGraphPlan(target, adapter, adapterOptions, installationType, packages, use) {
+  const stage = await mkdtemp3(join46(tmpdir4(), "agentwheel-recovery-"));
+  const priorTmpdir = process.env.TMPDIR;
+  try {
+    process.env.TMPDIR = stage;
+    const graphPlan = await createGraphSourcePlan({
+      roots: packages.map((pkg) => ({
+        rootId: pkg.name,
+        source: pkg.source,
+        mode: pkg.mode,
+        version: pkg.version,
+        ref: pkg.requestedRef,
+        select: pkg.selection ? void 0 : normalizeArtifactSelectors(pkg.select, pkg.skills),
+        selection: pkg.selection,
+        aliases: pkg.aliases,
+        overrides: pkg.overrides,
+        includeSuggestions: pkg.withSuggestions,
+        suggestionAliases: pkg.suggestions,
+        useLock: false
+      })),
+      targetRoot: target.targetRoot,
+      workspaceRoot: target.workspaceRoot,
+      fleetId: target.fleetId,
+      adapter,
+      transport: transportForTarget(target),
+      targetKey: targetKeyForTarget(target, adapter.name),
+      targetFingerprintParts: targetFingerprintParts(target, adapter, adapterOptions, installationType),
+      installationType,
+      stateKey: target.stateKey,
+      readOnly: true,
+      yes: true,
+      freshGraphOnly: true,
+      deferForeignStateCheck: true,
+      cacheRoot: join46(stage, "source-cache"),
+      registryCachePath: join46(stage, "registry.json")
+    });
+    return await use(graphPlan);
+  } finally {
+    if (priorTmpdir === void 0) delete process.env.TMPDIR;
+    else process.env.TMPDIR = priorTmpdir;
+    await rm10(stage, { recursive: true, force: true });
+  }
+}
 function installStateForTarget(target, adapter, options, installationType) {
   const installRoot = installRootForAdapterInstallationType(adapter, target.targetRoot, installationType, target.transport === "ssh");
   const targetIdentity = resolveTargetStateIdentity({
@@ -15933,7 +16591,7 @@ async function resolveCliTargetState(target, options) {
     migration: prior.migration,
     targetStateFilePreconditions: {
       graphLockPath: stableGraphLockPath,
-      graphLockRevision: stableLock ? createHash15("sha256").update(canonicalGraphLockJson(stableLock)).digest("hex") : null,
+      graphLockRevision: stableLock ? createHash16("sha256").update(canonicalGraphLockJson(stableLock)).digest("hex") : null,
       sourceLockRevision: computeSourceLockRevision(stableSourceLock)
     }
   };
@@ -15956,7 +16614,7 @@ async function collectTargetStatus(target, options) {
   const pending = await collectPendingInstallWork(target, options);
   const foreignObservations = pending.foreignStateObservations;
   const effectiveGraphLock = graphLock ?? pending.observedGraphLock;
-  const observedManifestRevision = foreignObservations.length > 0 ? createHash15("sha256").update(JSON.stringify(foreignObservations.map((observation) => [
+  const observedManifestRevision = foreignObservations.length > 0 ? createHash16("sha256").update(JSON.stringify(foreignObservations.map((observation) => [
     observation.fileName,
     observation.manifestRevision
   ]).sort())).digest("hex") : null;
@@ -16203,7 +16861,7 @@ async function assertCompositeMutationSupported(workspaceRoot, profile, readOnly
         `Composite-profile mutation is refused before member execution because ${member.id} uses ${member.transport}; durable remote policy and recovery preflight is not implemented.`
       );
     }
-    const memberRoot = resolve26(workspaceRoot, member.workspace);
+    const memberRoot = resolve27(workspaceRoot, member.workspace);
     const memberPolicy = await mutationPolicyForWorkspace(memberRoot);
     if (memberPolicy?.revisioning.mode === "commit-after-verify") {
       throw new Error(
@@ -16688,14 +17346,14 @@ function looksLikeSourceSpecifier(value) {
 }
 function normalizeCliPath(value) {
   if (value === "~") return homedir12();
-  if (value.startsWith("~/")) return resolve26(homedir12(), value.slice(2));
-  return resolve26(value);
+  if (value.startsWith("~/")) return resolve27(homedir12(), value.slice(2));
+  return resolve27(value);
 }
 function shellQuoteArgument(value) {
   return /^[a-z0-9_./:@%+=,-]+$/i.test(value) ? value : `'${value.replace(/'/g, `'"'"'`)}'`;
 }
 function isHomePath(path) {
-  return resolve26(path) === resolve26(homedir12());
+  return resolve27(path) === resolve27(homedir12());
 }
 function adapterListFromOption(adapter) {
   if (!adapter) return [];
@@ -16816,7 +17474,7 @@ function withFleetExample(config) {
   };
 }
 async function findAgentwheelPackageRoot(start) {
-  let current = resolve26(start);
+  let current = resolve27(start);
   while (true) {
     if (await findPackageManifestPath(current, { warnLegacy: false })) return current;
     const parent = dirname23(current);