agentwheel 0.21.0 → 0.21.3

package/dist/index.js

@@ -522,13 +522,13 @@ async function hashPath(path) {
   if (!stats.isDirectory()) {
     throw new Error(`Unsupported path kind: ${path}`);
   }
-  const hash = createHash("sha256").update("dir\0");
+  const hash2 = createHash("sha256").update("dir\0");
   const files = await listFiles(path);
   for (const file of files) {
-    hash.update(relative(path, file).replaceAll("\\", "/")).update("\0");
-    hash.update(await hashPath(file)).update("\0");
+    hash2.update(relative(path, file).replaceAll("\\", "/")).update("\0");
+    hash2.update(await hashPath(file)).update("\0");
   }
-  return hash.digest("hex");
+  return hash2.digest("hex");
 }
 async function listFiles(root) {
   const out = [];
@@ -583,7 +583,7 @@ async function withFilesystemLock(lockPath, timeoutMs, fn, description = "cache"
       if (Date.now() - started > timeoutMs) {
         throw new Error(`Timed out waiting for ${description} lock at ${lockPath}`);
       }
-      await new Promise((resolve44) => setTimeout(resolve44, 50));
+      await new Promise((resolve45) => setTimeout(resolve45, 50));
     }
   }
   try {
@@ -853,7 +853,7 @@ var init_protocol = __esm({
 // src/mutation/process.ts
 import { spawn } from "child_process";
 async function runProcess(command, args, options = {}) {
-  return new Promise((resolve44, reject) => {
+  return new Promise((resolve45, reject) => {
     const useProcessGroup = options.killProcessGroup === true && process.platform !== "win32";
     const child = spawn(command, args, {
       cwd: options.cwd,
@@ -913,7 +913,7 @@ async function runProcess(command, args, options = {}) {
         reject(new Error(`${command} exited ${exitCode}${detail ? `: ${detail}` : ""}`));
         return;
       }
-      resolve44(result);
+      resolve45(result);
     });
     if (options.input !== void 0) child.stdin.end(options.input);
     else child.stdin.end();
@@ -939,8 +939,8 @@ function agentMeshGraphPath() {
 function agentwheelResourceRef(gitCommonDir, repositoryRelativePath) {
   const commonDir = resolve5(gitCommonDir);
   const normalizedPath = normalizeRepositoryRelativePath(repositoryRelativePath);
-  const digest2 = createHash3("sha256").update(commonDir).update("\0").update(normalizedPath).digest("hex");
-  return `agentwheel-resource:${digest2}`;
+  const digest3 = createHash3("sha256").update(commonDir).update("\0").update(normalizedPath).digest("hex");
+  return `agentwheel-resource:${digest3}`;
 }
 async function resourceRefsForRepositoryPaths(repositoryRoot, paths) {
   const result = await runProcess("git", [
@@ -1213,8 +1213,8 @@ async function listMutationReceipts() {
 }
 async function acquireMutationLock(repositoryRoot, operationId) {
   const root = mutationStateRoot();
-  const digest2 = createHash4("sha256").update(resolve6(repositoryRoot)).digest("hex");
-  const lockPath = join4(root, "locks", `${digest2}.lock`);
+  const digest3 = createHash4("sha256").update(resolve6(repositoryRoot)).digest("hex");
+  const lockPath = join4(root, "locks", `${digest3}.lock`);
   await mkdir2(join4(root, "locks"), { recursive: true, mode: 448 });
   await chmod(join4(root, "locks"), 448);
   try {
@@ -1961,13 +1961,13 @@ async function spawnWithInput(command, args, input) {
   if (result.stderr) throw new Error(result.stderr);
 }
 function waitForProcess(child, label) {
-  return new Promise((resolve44, reject) => {
+  return new Promise((resolve45, reject) => {
     const stderr = [];
     child.stderr?.on("data", (chunk) => stderr.push(chunk));
     child.on("error", reject);
     child.on("close", (code) => {
       const message = Buffer.concat(stderr).toString("utf8");
-      if (code === 0) resolve44({ stderr: "" });
+      if (code === 0) resolve45({ stderr: "" });
       else reject(new Error(`${label} exited ${code}${message ? `: ${message}` : ""}`));
     });
   });
@@ -2582,7 +2582,7 @@ async function listInstallManifests(targetRoot, adapter, transport = localTransp
     try {
       const raw = JSON.parse(await transport.readFile(path));
       const parsed = installManifestSchema.parse(raw);
-      if (parsed.adapter !== adapter) continue;
+      if (adapter !== void 0 && parsed.adapter !== adapter) continue;
       found.push({ path, fileName, stateKey, manifest: { ...parsed, revision: computeManifestRevision(raw) } });
     } catch (error) {
       throw new Error(`Unreadable install manifest at ${path}: ${error instanceof Error ? error.message : String(error)}`);
@@ -2805,6 +2805,62 @@ var init_semver = __esm({
   }
 });
 
+// src/model/selection.ts
+function artifactSelectorKey(artifact) {
+  return `${artifact.type}/${artifact.name}`;
+}
+function artifactSelectorAliases(artifact) {
+  const primary = artifactSelectorKey(artifact);
+  if (artifact.type !== "subagents") return [primary];
+  const baseName = subagentBaseName(artifact.name);
+  if (baseName === artifact.name) return [primary];
+  return [primary, `subagents/${baseName}`];
+}
+function normalizeArtifactSelectors(select, legacySkills) {
+  const selected = [
+    ...select ?? [],
+    ...(legacySkills ?? []).map((name) => `skills/${name}`)
+  ].flatMap(splitSelectorList);
+  if (selected.length === 0) return void 0;
+  return [...new Set(selected.map(parseArtifactSelector))];
+}
+function filterArtifactsBySelection(artifacts, selectors, legacySkills, options = {}) {
+  const selected = normalizeArtifactSelectors(selectors, legacySkills);
+  if (!selected?.length) return artifacts;
+  const selectedSet = new Set(selected);
+  const available = new Set((options.validationArtifacts ?? artifacts).flatMap(artifactSelectorAliases));
+  const missing = selected.filter((selector) => !available.has(selector));
+  if (missing.length > 0) {
+    throw new Error(`Selected artifact not found in package: ${missing.join(", ")}`);
+  }
+  return artifacts.filter((artifact) => artifact.required || artifactSelectorAliases(artifact).some((selector) => selectedSet.has(selector)));
+}
+function splitSelectorList(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function parseArtifactSelector(value) {
+  const slash = value.indexOf("/");
+  if (slash <= 0 || slash === value.length - 1) {
+    throw new Error(`Invalid artifact selector: ${value}. Expected <type>/<name>.`);
+  }
+  const type = value.slice(0, slash);
+  const name = value.slice(slash + 1);
+  const parsedType = artifactTypeSchema.safeParse(type);
+  if (!parsedType.success) {
+    throw new Error(`Invalid artifact selector type: ${type}`);
+  }
+  return `${parsedType.data}/${name}`;
+}
+function subagentBaseName(name) {
+  return name.replace(/\.agent\.md$/i, "").replace(/\.toml$/i, "").replace(/\.md$/i, "");
+}
+var init_selection = __esm({
+  "src/model/selection.ts"() {
+    "use strict";
+    init_artifact();
+  }
+});
+
 // src/model/workspace.ts
 import { readFile as readFile10 } from "fs/promises";
 import { homedir as homedir4 } from "os";
@@ -2829,6 +2885,43 @@ async function writeWorkspaceConfig(workspaceRoot, config) {
   declareMutationPath(path);
   await writeJsonAtomic(path, workspaceConfigSchema.parse(config));
 }
+async function pinConfiguredPackages(workspaceRoot, input) {
+  const pins = z10.array(z10.object({
+    alias: z10.string().min(1),
+    commit: z10.string().regex(/^[a-f0-9]{40}$/i, "Pin requires an exact 40-hex commit SHA."),
+    select: z10.array(z10.string().min(1)).min(1).optional()
+  }).strict()).min(1).parse(input).map((pin) => {
+    const select = pin.select === void 0 ? void 0 : normalizeArtifactSelectors(pin.select);
+    if (pin.select !== void 0 && !select?.length) throw new Error("Explicit pin selection must not be empty.");
+    return { ...pin, select };
+  });
+  if (new Set(pins.map((pin) => pin.alias)).size !== pins.length) {
+    throw new Error("Pin requires unique configured aliases.");
+  }
+  const path = workspaceConfigPath(workspaceRoot);
+  const config = JSON.parse(await readFile10(path, "utf8"));
+  workspaceConfigSchema.parse(config);
+  const updates = pins.map(({ alias, commit, select }) => {
+    const matches = (config.packages ?? []).filter((pkg2) => pkg2.name === alias);
+    if (matches.length !== 1) {
+      throw new Error(matches.length === 0 ? `Configured package alias not found: ${alias}` : `Ambiguous configured package alias: ${alias}`);
+    }
+    const pkg = matches[0];
+    if (pkg.mode === "tracking") throw new Error(`Configured package ${alias} is tracking; pin requires pinned mode.`);
+    return { pkg, requestedRef: commit, select };
+  });
+  for (const { pkg, requestedRef, select } of updates) {
+    pkg.requestedRef = requestedRef;
+    if (select !== void 0) {
+      pkg.select = select;
+      delete pkg.skills;
+      delete pkg.selection;
+    }
+  }
+  workspaceConfigSchema.parse(config);
+  declareMutationPath(path);
+  await writeJsonAtomic(path, config);
+}
 function upsertPackage(config, entry) {
   const parsed = workspaceConfigSchema.parse(config);
   const packages = parsed.packages.filter((candidate) => candidate.name !== entry.name);
@@ -2920,6 +3013,7 @@ var init_workspace = __esm({
     init_mutation();
     init_declarations();
     init_adapters();
+    init_selection();
     artifactSelectorListSchema = z10.array(z10.string().min(1));
     CURRENT_WORKSPACE_SCHEMA_VERSION = 4;
     workspaceSelectionImportSchema = z10.object({
@@ -3236,15 +3330,15 @@ async function snapshotRepository(repositoryRoot) {
 async function collectIntroducedPaths(repositoryRoot, expectedHead, before, declaredPaths) {
   const after = await snapshotRepository(repositoryRoot);
   const touchedPreexisting = /* @__PURE__ */ new Set();
-  for (const [path, hash] of before.changed) {
+  for (const [path, hash2] of before.changed) {
     if (declaredPaths.includes(path)) touchedPreexisting.add(path);
     else if (!after.changed.has(path)) {
       const head = await currentHead(repositoryRoot);
       const ancestor = await runProcess("git", ["-C", repositoryRoot, "merge-base", "--is-ancestor", expectedHead, head], {
         allowExitCodes: [0, 1]
       });
-      if (head === expectedHead || ancestor.exitCode !== 0 || await hashWorkingPath(repositoryRoot, path) !== hash || await hashHeadPath(repositoryRoot, head, path) !== hash) touchedPreexisting.add(path);
-    } else if (after.changed.get(path) !== hash) touchedPreexisting.add(path);
+      if (head === expectedHead || ancestor.exitCode !== 0 || await hashWorkingPath(repositoryRoot, path) !== hash2 || await hashHeadPath(repositoryRoot, head, path) !== hash2) touchedPreexisting.add(path);
+    } else if (after.changed.get(path) !== hash2) touchedPreexisting.add(path);
   }
   if (touchedPreexisting.size > 0) {
     throw new Error(`Mutation touched pre-existing dirty paths: ${[...touchedPreexisting].sort().join(", ")}.`);
@@ -3310,19 +3404,19 @@ async function hashWorkingPath(repositoryRoot, path) {
   throw new Error(`Unsupported repository path kind: ${path}`);
 }
 async function hashDirectory(root) {
-  const hash = createHash7("sha256");
+  const hash2 = createHash7("sha256");
   async function walk2(dir) {
     for (const entry of (await readdir4(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
       if (entry.name === ".git" || entry.name === "node_modules") continue;
       const absolute = resolve12(dir, entry.name);
       const relativePath = normalizeRepoPath(relative5(root, absolute));
       if (entry.isDirectory()) await walk2(absolute);
-      else if (entry.isSymbolicLink()) hash.update(relativePath).update("\0").update(await readlink(absolute)).update("\0");
-      else if (entry.isFile()) hash.update(relativePath).update("\0").update(await readFile11(absolute)).update("\0");
+      else if (entry.isSymbolicLink()) hash2.update(relativePath).update("\0").update(await readlink(absolute)).update("\0");
+      else if (entry.isFile()) hash2.update(relativePath).update("\0").update(await readFile11(absolute)).update("\0");
     }
   }
   await walk2(root);
-  return hash.digest("hex");
+  return hash2.digest("hex");
 }
 function splitNull(value) {
   return value.toString("utf8").split("\0").filter(Boolean);
@@ -3938,11 +4032,11 @@ function dirtyRepositoryPaths(repositoryRoot, baseline, paths) {
 function activeMutationMetadata() {
   return activeMutation?.metadata();
 }
-async function reserveActiveRuntimeJournal(link2) {
-  await activeMutation?.transitionRuntimeJournal(link2, "reserved");
+async function reserveActiveRuntimeJournal(link3) {
+  await activeMutation?.transitionRuntimeJournal(link3, "reserved");
 }
-async function activateActiveRuntimeJournal(link2) {
-  await activeMutation?.transitionRuntimeJournal(link2, "pending");
+async function activateActiveRuntimeJournal(link3) {
+  await activeMutation?.transitionRuntimeJournal(link3, "pending");
 }
 async function beginResolveMutationRuntimeJournal(operationId, path) {
   await transitionMutationRuntimeJournal(operationId, path, "resolving");
@@ -4208,14 +4302,14 @@ function receiptStatusForProvider(status) {
   if (status === "no-repository-delta") return "no-repository-delta";
   return "succeeded";
 }
-function upsertRuntimeJournal(entries, link2, status) {
-  const existing = entries.find((entry) => entry.path === link2.path);
-  if (existing && (existing.transport !== link2.transport || existing.transportDescription !== link2.transportDescription || existing.journalDigest !== link2.journalDigest)) {
-    throw new Error(`Runtime journal link collision for ${link2.path}.`);
+function upsertRuntimeJournal(entries, link3, status) {
+  const existing = entries.find((entry) => entry.path === link3.path);
+  if (existing && (existing.transport !== link3.transport || existing.transportDescription !== link3.transportDescription || existing.journalDigest !== link3.journalDigest)) {
+    throw new Error(`Runtime journal link collision for ${link3.path}.`);
   }
   return [
-    ...entries.filter((entry) => entry.path !== link2.path),
-    { ...link2, status }
+    ...entries.filter((entry) => entry.path !== link3.path),
+    { ...link3, status }
   ].sort((a, b) => a.path.localeCompare(b.path));
 }
 var GovernedMutation, activeMutation;
@@ -4416,11 +4510,12 @@ var init_coordinator = __esm({
           operationId: this.receipt.operationId,
           reason: this.receipt.reason,
           noCommit: this.receipt.noCommit,
-          revisionMode: this.receipt.revisionMode
+          revisionMode: this.receipt.revisionMode,
+          workspaceRoot: this.receipt.workspaceRoot
         };
       }
-      async transitionRuntimeJournal(link2, status) {
-        const runtimeJournals = upsertRuntimeJournal(this.receipt.runtimeJournals, link2, status);
+      async transitionRuntimeJournal(link3, status) {
+        const runtimeJournals = upsertRuntimeJournal(this.receipt.runtimeJournals, link3, status);
         this.receipt = await updateMutationReceipt(this.receipt, { runtimeJournals });
       }
       async transitionExistingRuntimeJournal(path, status) {
@@ -4488,20 +4583,88 @@ __export(transaction_exports, {
   applyLockPath: () => applyLockPath,
   assertApplyJournalRecoveryAllowed: () => assertApplyJournalRecoveryAllowed,
   assertGovernedRuntimeTransportSupported: () => assertGovernedRuntimeTransportSupported,
+  assertNoSymlinkPath: () => assertNoSymlinkPath,
   listAllApplyJournals: () => listAllApplyJournals,
   listApplyJournals: () => listApplyJournals,
   localPathExists: () => localPathExists,
+  metadataAuditPath: () => metadataAuditPath,
+  metadataRuntimePath: () => metadataRuntimePath,
   mutationMetadataForApplyJournal: () => mutationMetadataForApplyJournal,
+  ownershipRuntimeSnapshot: () => ownershipRuntimeSnapshot,
   readApplyJournal: () => readApplyJournal,
   readLinkedLocalApplyJournal: () => readLinkedLocalApplyJournal,
   recordBackup: () => recordBackup,
   removeApplyJournal: () => removeApplyJournal,
   rollbackCompletedOperations: () => rollbackCompletedOperations,
+  syncMetadataPath: () => syncMetadataPath,
   writeApplyJournal: () => writeApplyJournal
 });
 import { createHash as createHash9 } from "crypto";
-import { cp as cp2, mkdir as mkdir7, readFile as readFile13, rm as rm5, stat as stat4 } from "fs/promises";
-import { dirname as dirname9, join as join11, resolve as resolve15 } from "path";
+import { cp as cp2, lstat as lstat2, mkdir as mkdir7, open as open3, readFile as readFile13, readdir as readdir5, rm as rm5, stat as stat4 } from "fs/promises";
+import { dirname as dirname9, join as join11, relative as relative7, resolve as resolve15, sep as sep5 } from "path";
+async function assertNoSymlinkPath(path) {
+  const absolute = resolve15(path);
+  let current = absolute;
+  while (true) {
+    try {
+      if ((await lstat2(current)).isSymbolicLink()) throw new Error(`Symlink path is unsupported: ${current}`);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const parent = dirname9(current);
+    if (parent === current) break;
+    current = parent;
+  }
+}
+async function ownershipRuntimeSnapshot(path) {
+  await assertNoSymlinkPath(path);
+  const hash2 = createHash9("sha256");
+  async function visit(candidate) {
+    const info = await lstat2(candidate);
+    if (info.isSymbolicLink() || !info.isDirectory() && !info.isFile()) {
+      throw new Error(`Unsupported ownership runtime path: ${candidate}`);
+    }
+    hash2.update(JSON.stringify([relative7(path, candidate), info.isDirectory() ? "dir" : "file", info.mode & 4095]));
+    if (info.isDirectory()) {
+      for (const name of (await readdir5(candidate)).sort()) await visit(join11(candidate, name));
+    } else {
+      const content = await readFile13(candidate);
+      hash2.update(String(content.length)).update("\0").update(content);
+    }
+  }
+  await visit(path);
+  return hash2.digest("hex");
+}
+function metadataAuditPath(audit, path) {
+  mutationOperationIdSchema.parse(audit.operationId);
+  if (resolve15(audit.workspaceRoot) !== audit.workspaceRoot || path !== `.agentwheel/ownership-releases/${audit.operationId}.json`) {
+    throw new Error("Invalid ownership release audit path.");
+  }
+  return join11(audit.workspaceRoot, ...path.split("/"));
+}
+function metadataRuntimePath(root, path) {
+  const result = resolve15(root, path);
+  if (!path || relative7(resolve15(root), result).split(sep5).join("/") !== path || path === ".agentwheel" || path.startsWith(".agentwheel/") || result === resolve15(root) || !result.startsWith(`${resolve15(root)}${sep5}`)) {
+    throw new Error(`Unsafe ownership release path: ${path}`);
+  }
+  return result;
+}
+async function syncMetadataPath(path, directoryOnly = false) {
+  if (!directoryOnly) {
+    const file = await open3(path, "r");
+    try {
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+  }
+  const directory = await open3(directoryOnly ? path : dirname9(path), "r");
+  try {
+    await directory.sync();
+  } finally {
+    await directory.close();
+  }
+}
 function applyLockPath(targetRoot, adapter, scope = {}) {
   const installationType = scope.installationType ?? "local";
   return join11(metadataDir(targetRoot), `${stateKeyFor(adapter, { installationType })}.runtime-apply-lock`);
@@ -4543,30 +4706,31 @@ async function writeApplyJournal(journal, transport = localTransport) {
     installationType: journal.installationType,
     stateKey: journal.stateKey
   });
-  let link2;
+  let link3;
   if (journal.mutation) {
-    const digest2 = applyJournalLinkDigest(journal, transport);
-    if (journal.mutation.journalDigest && journal.mutation.journalDigest !== digest2) {
+    const digest3 = applyJournalLinkDigest(journal, transport);
+    if (journal.mutation.journalDigest && journal.mutation.journalDigest !== digest3) {
       throw new Error(`Runtime apply journal identity changed for ${path}.`);
     }
     if (journal.mutation.transport && (journal.mutation.transport.kind !== transport.kind || journal.mutation.transport.description !== transport.description)) {
       throw new Error(`Runtime apply journal transport changed for ${path}.`);
     }
-    journal.mutation.journalDigest = digest2;
+    journal.mutation.journalDigest = digest3;
     journal.mutation.transport = { kind: transport.kind, description: transport.description };
-    link2 = {
+    link3 = {
       path,
       transport: transport.kind,
       transportDescription: transport.description,
-      journalDigest: digest2
+      journalDigest: digest3
     };
-    await reserveActiveRuntimeJournal(link2);
+    await reserveActiveRuntimeJournal(link3);
   }
   await transport.writeJsonAtomic(path, {
     ...journal,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  if (link2) await activateActiveRuntimeJournal(link2);
+  if ((journal.metadataAudit || journal.metadataGuards) && transport.kind === "local") await syncMetadataPath(path);
+  if (link3) await activateActiveRuntimeJournal(link3);
 }
 async function readApplyJournal(targetRoot, adapter, transport = localTransport, scope = {}) {
   const path = applyJournalPath(targetRoot, adapter, scope);
@@ -4593,7 +4757,7 @@ async function listAllApplyJournals(targetRoot, adapter, transport = localTransp
     if (!fileName.endsWith(suffix)) continue;
     const path = join11(metadataDir(targetRoot), fileName);
     const journal = parseApplyJournal(JSON.parse(await transport.readFile(path)));
-    if (journal.adapter === adapter) found.push({ path, journal });
+    if (adapter === void 0 || journal.adapter === adapter) found.push({ path, journal });
   }
   return found.sort((a, b) => a.path.localeCompare(b.path));
 }
@@ -4632,6 +4796,7 @@ async function removeApplyJournal(targetRoot, adapter, transport = localTranspor
   if (existing?.mutation) await beginResolveMutationRuntimeJournal(existing.mutation.operationId, path);
   await transport.rm(applyJournalPath(targetRoot, adapter, scope));
   await transport.rm(applyBackupDir(targetRoot, adapter, scope));
+  if ((existing?.metadataAudit || existing?.metadataGuards) && transport.kind === "local") await syncMetadataPath(dirname9(path), true);
   if (existing?.mutation) await resolveMutationRuntimeJournal(existing.mutation.operationId, path);
 }
 async function abortApplyJournal(targetRoot, adapter, transport = localTransport, scope = {}) {
@@ -4644,6 +4809,9 @@ async function abortApplyJournal(targetRoot, adapter, transport = localTransport
     const archivePath = join11(metadataDir(targetRoot), "archive", `${stateKey}.apply-journal.failed-${journalTimestamp(/* @__PURE__ */ new Date())}.json`);
     const content = await transport.readFile(journalPath);
     const journal = parseApplyJournal(JSON.parse(content));
+    if (journal.metadataAudit || journal.metadataGuards) {
+      throw new Error("A guarded metadata transaction must be recovered and verified; abort cannot discard its partial state.");
+    }
     await transport.writeFileAtomic(archivePath, content.endsWith("\n") ? content : `${content}
 `);
     if (journal.mutation) await beginResolveMutationRuntimeJournal(journal.mutation.operationId, journalPath);
@@ -4695,7 +4863,9 @@ function applyJournalLinkDigest(journal, transport) {
     graphLockRemovePath: journal.graphLockRemovePath ?? null,
     stateRemoveKey: journal.stateRemoveKey ?? null,
     workspaceConfigPath: journal.workspaceConfigPath ?? null,
-    operations: journal.operations
+    operations: journal.operations,
+    ...journal.metadataAudit ? { metadataAudit: journal.metadataAudit, manifest: journal.manifest } : {},
+    ...journal.metadataGuards ? { metadataGuards: journal.metadataGuards, manifest: journal.manifest } : {}
   })).digest("hex");
 }
 function assertApplyJournalRecoveryAllowed(journal) {
@@ -5363,7 +5533,56 @@ var init_desired = __esm({
 import { createHash as createHash10 } from "crypto";
 import { mkdtemp as mkdtemp2, readFile as readFile17, realpath, rm as rm6, writeFile as writeFile11 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { basename as basename2, dirname as dirname13, join as join12, relative as relative7 } from "path";
+import { basename as basename2, dirname as dirname13, join as join12, relative as relative8 } from "path";
+function exactManagedInstructionBlockSnapshot(content, selector) {
+  const beginCount = [...content.matchAll(new RegExp(`<!-- BEGIN openpack:include ${escapeRegex(selector)}(?=\\s|-->)`, "gu"))].length;
+  const endCount = [...content.matchAll(new RegExp(`<!-- END openpack:include ${escapeRegex(selector)}(?=\\s|-->)`, "gu"))].length;
+  if (beginCount !== 1 || endCount !== 1) throw new Error("Duplicate or missing managed instruction markers; adoption is refused.");
+  const stack = [];
+  let selectedBegin;
+  let selectedEnd;
+  let begins = 0;
+  let ends = 0;
+  for (const token of content.matchAll(/<!-- (BEGIN|END) openpack:include ([^\r\n]*?) -->/gu)) {
+    const at = token.index;
+    if (token[1] === "BEGIN") {
+      const begin = /^(.*?) sha256:([a-f0-9]{64})$/u.exec(token[2]);
+      if (!begin) throw new Error("Malformed managed instruction begin marker; adoption is refused.");
+      const name = begin[1];
+      if (name === selector) {
+        if (++begins !== 1 || stack.length !== 0) throw new Error("Duplicate or overlapping managed instruction block; adoption is refused.");
+        let bodyStart = at + token[0].length;
+        if (content.slice(bodyStart, bodyStart + 2) === "\r\n") bodyStart += 2;
+        else if (content[bodyStart] === "\n") bodyStart++;
+        selectedBegin = { start: at, bodyStart, hash: begin[2] };
+      }
+      stack.push(name);
+    } else {
+      const name = token[2];
+      if (stack.pop() !== name) throw new Error("Overlapping or unmatched managed instruction markers; adoption is refused.");
+      if (name === selector) {
+        if (++ends !== 1 || !selectedBegin) throw new Error("Duplicate or missing managed instruction marker; adoption is refused.");
+        let end = at + token[0].length;
+        if (content.slice(end, end + 2) === "\r\n") end += 2;
+        else if (content[end] === "\n") end++;
+        selectedEnd = { bodyEnd: at, end };
+      }
+    }
+  }
+  if (stack.length || begins !== 1 || ends !== 1 || !selectedBegin || !selectedEnd) {
+    throw new Error(`Missing or incomplete managed instruction block for ${selector}; adoption is refused.`);
+  }
+  const hash2 = hashText(content.slice(selectedBegin.bodyStart, selectedEnd.bodyEnd));
+  if (hash2 !== selectedBegin.hash) throw new Error(`Managed instruction block drift detected for ${selector}; adoption is refused.`);
+  return {
+    selector,
+    hash: hash2,
+    markerHash: selectedBegin.hash,
+    prefixHash: hashText(content.slice(0, selectedBegin.start)),
+    suffixHash: hashText(content.slice(selectedEnd.end)),
+    blockBytesHash: hashText(content.slice(selectedBegin.start, selectedEnd.end))
+  };
+}
 async function desiredManagedInstructionBlockHash(sourcePath) {
   const source = await readFile17(sourcePath, "utf8");
   return hashText(managedBlockBody(source));
@@ -5375,13 +5594,13 @@ async function readManagedInstructionBlockState(destPath, selector, transport) {
   const content = await transport.readFile(destPath);
   const block = findManagedInstructionBlock(content, selector);
   if (!block) return { exists: true, hasBlock: false, drifted: false };
-  const hash = hashText(block.body);
+  const hash2 = hashText(block.body);
   return {
     exists: true,
     hasBlock: true,
-    hash,
+    hash: hash2,
     markerHash: block.markerHash,
-    drifted: hash !== block.markerHash
+    drifted: hash2 !== block.markerHash
   };
 }
 async function writeManagedInstructionBlock(sourcePath, destPath, selector, transport, options = {}) {
@@ -5420,12 +5639,12 @@ function managedInstructionSelector(selector, artifactType, artifactName) {
 }
 function renderManagedInstructionBlock(selector, source) {
   const body = managedBlockBody(source);
-  const hash = hashText(body);
+  const hash2 = hashText(body);
   return {
-    block: `<!-- BEGIN openpack:include ${selector} sha256:${hash} -->
+    block: `<!-- BEGIN openpack:include ${selector} sha256:${hash2} -->
 ${body}<!-- END openpack:include ${selector} -->
 `,
-    hash
+    hash: hash2
   };
 }
 function upsertManagedInstructionBlock(content, selector, block, options) {
@@ -5507,7 +5726,7 @@ function referencesAgentsMd(content, claudePath, agentsPath) {
     const cleaned = referenced.trim().replace(/^["']|["']$/g, "");
     if (!/AGENTS\.md$/i.test(cleaned)) continue;
     const candidate = cleaned.startsWith("/") ? cleaned : join12(claudeDir, cleaned);
-    if (relative7(dirname13(agentsPath), candidate).replaceAll("\\", "/") === "AGENTS.md") return true;
+    if (relative8(dirname13(agentsPath), candidate).replaceAll("\\", "/") === "AGENTS.md") return true;
     if (candidate === agentsPath) return true;
   }
   return false;
@@ -5564,8 +5783,8 @@ __export(apply_exports, {
   uninstall: () => uninstall
 });
 import { execFile as execFile4 } from "child_process";
-import { createHash as createHash11 } from "crypto";
-import { mkdtemp as mkdtemp3, readFile as readFile18, rm as rm7, writeFile as writeFile12 } from "fs/promises";
+import { createHash as createHash11, randomUUID as randomUUID3 } from "crypto";
+import { link as link2, mkdir as mkdir11, mkdtemp as mkdtemp3, open as open4, readFile as readFile18, rm as rm7, writeFile as writeFile12 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
 import { basename as basename3, dirname as dirname14, join as join13, resolve as resolve16 } from "path";
 import { promisify as promisify4 } from "util";
@@ -5838,20 +6057,35 @@ async function commitManifestMetadataJournal(journal, transport = localTransport
 async function commitJournalState(journal, transport, entries, now) {
   const manifest = withManifestRevision({
     ...journal.manifest,
-    generatedAt: now,
+    generatedAt: journal.metadataAudit || journal.metadataGuards ? journal.createdAt : now,
     entries: entries ? entries.sort((a, b) => a.path.localeCompare(b.path)) : journal.manifest.entries
   });
-  if (journal.mode === "uninstall" && manifest.entries.length === 0) {
+  if (journal.metadataGuards) await assertMetadataStateGuards(journal, manifest, journal.metadataGuards, transport);
+  if (journal.metadataAudit) {
+    await assertMetadataAuditGuards(journal, manifest, transport);
+    for (const file of journal.metadataAudit.auditFiles) {
+      const path = metadataAuditPath(journal.metadataAudit, file.path);
+      declareMutationPath(path);
+      await writeAuditFileExclusive(path, file.content);
+    }
+    await assertMetadataAuditGuards(journal, manifest, transport);
+  }
+  if (journal.mode === "uninstall" && manifest.entries.length === 0 && !journal.metadataAudit) {
     await removeStateFiles(journal.targetRoot, journal.adapter, transport, {
       installationType: journal.installationType,
       stateKey: journal.stateKey
     });
+    if (journal.metadataGuards) await syncMetadataPath(metadataDir(journal.targetRoot), true);
   } else {
     if (journal.sourceLock) await writeSourceLock(journal.targetRoot, journal.adapter, journal.sourceLock, transport, {
       installationType: journal.installationType,
       stateKey: journal.stateKey
     });
     await writeInstallManifest(manifest, transport);
+    if (journal.metadataAudit || journal.metadataGuards) await syncMetadataPath(installManifestPath(journal.targetRoot, journal.adapter, {
+      installationType: journal.installationType,
+      stateKey: journal.stateKey
+    }));
   }
   if (journal.graphLockPath && journal.graphLock) await writeGraphLock(journal.graphLockPath, journal.graphLock);
   if (journal.stateRemoveKey && journal.stateRemoveKey !== journal.stateKey) {
@@ -5869,6 +6103,8 @@ async function commitJournalState(journal, transport, entries, now) {
     await writeJsonAtomic(journal.workspaceConfigPath, journal.workspaceConfig);
   }
   const verifiedManifest = await assertCommittedJournalState(journal, manifest, transport);
+  if (journal.metadataAudit) await assertMetadataAuditGuards(journal, manifest, transport, true);
+  if (journal.metadataGuards) await assertMetadataStateGuards(journal, manifest, journal.metadataGuards, transport, true);
   await removeApplyJournal(journal.targetRoot, journal.adapter, transport, {
     installationType: journal.installationType,
     stateKey: journal.stateKey
@@ -5884,7 +6120,7 @@ async function commitJournalState(journal, transport, entries, now) {
 async function assertCommittedJournalState(journal, expectedManifest, transport) {
   const scope = { installationType: journal.installationType, stateKey: journal.stateKey };
   const actualManifest = await readInstallManifest(journal.targetRoot, journal.adapter, transport, scope);
-  if (journal.mode === "uninstall" && expectedManifest.entries.length === 0) {
+  if (journal.mode === "uninstall" && expectedManifest.entries.length === 0 && !journal.metadataAudit) {
     if (actualManifest) throw new Error("Uninstall postcheck found an install manifest that should have been removed.");
   } else if (!actualManifest) {
     throw new Error(
@@ -5924,6 +6160,88 @@ async function assertCommittedJournalState(journal, expectedManifest, transport)
   }
   return actualManifest;
 }
+async function assertMetadataAuditGuards(journal, after, transport, requireAfter = false) {
+  const audit = journal.metadataAudit;
+  const sha = /^[a-f0-9]{64}$/;
+  if (transport.kind !== "local" || audit.kind !== "ownership-release" || after.adapter !== journal.adapter || after.targetRoot !== journal.targetRoot || after.installationType !== journal.installationType || after.stateKey !== journal.stateKey || journal.mode !== "uninstall" || journal.operations.length || journal.completed.length || journal.sourceLock || journal.graphLock || journal.graphLockPath || journal.graphLockRemovePath || journal.stateRemoveKey || journal.workspaceConfigPath || journal.workspaceConfig || !sha.test(audit.planDigest) || !sha.test(journal.baseRevision ?? "") || audit.auditFiles.length !== 1 || audit.runtime.length !== 1 || !audit.inventory.length) {
+    throw new Error("Invalid metadata-audit transaction; no state was committed.");
+  }
+  await assertMetadataStateGuards(journal, after, audit, transport, requireAfter);
+  for (const file of audit.auditFiles) {
+    const path = metadataAuditPath(audit, file.path);
+    await assertNoSymlinkPath(path);
+    if (!sha.test(file.sha256) || createHash11("sha256").update(file.content).digest("hex") !== file.sha256) {
+      throw new Error("Metadata-audit content digest is invalid.");
+    }
+    try {
+      if (await readFile18(path, "utf8") !== file.content) throw new Error(`Metadata-audit file changed: ${path}`);
+    } catch (error) {
+      if (error.code !== "ENOENT" || requireAfter) throw error;
+    }
+  }
+}
+async function assertMetadataStateGuards(journal, after, guards, transport, requireAfter = false) {
+  const sha = /^[a-f0-9]{64}$/;
+  if (transport.kind !== "local" || journal.metadataAudit && journal.metadataGuards || after.adapter !== journal.adapter || after.targetRoot !== journal.targetRoot || after.installationType !== journal.installationType || after.stateKey !== journal.stateKey || journal.mode !== "uninstall" || journal.operations.length || journal.completed.length || journal.sourceLock || journal.graphLock || journal.graphLockPath || journal.graphLockRemovePath || journal.stateRemoveKey || journal.workspaceConfigPath || journal.workspaceConfig || journal.baseRevision !== null && !sha.test(journal.baseRevision) || !guards.inventory.length || !guards.runtime.length) {
+    throw new Error("Invalid guarded metadata transaction; no state was committed.");
+  }
+  await assertNoSymlinkPath(journal.targetRoot);
+  await assertNoSymlinkPath(metadataDir(journal.targetRoot));
+  const inventory = await listInstallManifests(journal.targetRoot, void 0, transport);
+  for (const item of inventory) await assertNoSymlinkPath(item.path);
+  const before = new Map(guards.inventory.map((item) => [item.stateKey, item.revision]));
+  if (before.size !== guards.inventory.length || [...before.values()].some((revision) => !sha.test(revision)) || (before.get(journal.stateKey) ?? null) !== journal.baseRevision) {
+    throw new Error("Invalid guarded metadata inventory baseline.");
+  }
+  const next = new Map(before);
+  if (after.entries.length === 0 && !journal.metadataAudit) next.delete(journal.stateKey);
+  else next.set(journal.stateKey, after.revision);
+  const actual = new Map(inventory.map((item) => [item.stateKey, item.manifest.revision]));
+  const equals = (expected) => actual.size === expected.size && [...expected].every(([key, revision]) => actual.get(key) === revision);
+  if (!equals(next) && (requireAfter || !equals(before))) {
+    throw new Error("Metadata inventory/manifest CAS failed; concurrent state was preserved.");
+  }
+  for (const guard of guards.runtime) {
+    const path = metadataRuntimePath(journal.targetRoot, guard.path);
+    if (!sha.test(guard.hash) || !sha.test(guard.snapshotDigest) || await ownershipRuntimeSnapshot(path) !== guard.snapshotDigest || await transport.hashPath(path) !== guard.hash) {
+      throw new Error(`Metadata runtime CAS failed at ${guard.path}; runtime was preserved.`);
+    }
+    if (guard.managedBlock) {
+      const current = exactManagedInstructionBlockSnapshot(await transport.readFile(path), guard.managedBlock.selector);
+      if (canonicalJson5(current) !== canonicalJson5(guard.managedBlock)) {
+        throw new Error(`Managed instruction snapshot CAS failed at ${guard.path}.`);
+      }
+    }
+  }
+}
+async function writeAuditFileExclusive(path, content) {
+  await assertNoSymlinkPath(path);
+  await mkdir11(dirname14(path), { recursive: true });
+  await syncMetadataPath(dirname14(dirname14(path)), true);
+  const temporary = `${path}.pending-${randomUUID3()}`;
+  try {
+    const handle = await open4(temporary, "wx", 384);
+    try {
+      await handle.writeFile(content, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    try {
+      await link2(temporary, path);
+    } catch (error) {
+      if (error.code !== "EEXIST" || await readFile18(path, "utf8") !== content) throw error;
+    }
+    const directory = await open4(dirname14(path), "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  } finally {
+    await rm7(temporary, { force: true });
+  }
+}
 function canonicalJson5(value) {
   if (Array.isArray(value)) return `[${value.map((item) => canonicalJson5(item === void 0 ? null : item)).join(",")}]`;
   if (value === null || typeof value !== "object") return JSON.stringify(value);
@@ -5973,13 +6291,13 @@ async function applyOperation(operation, context) {
     }
     if (operation.mode === managedInstructionBlockMode) {
       const selector = managedInstructionSelector(operation.logicalSelector, operation.artifactType, operation.artifactName);
-      const hash2 = await writeManagedInstructionBlock(operation.sourcePath, operation.destPath, selector, transport, managedBlockMutationOptions(operation));
-      if (hash2 !== operation.desiredHash) {
-        throw new Error(`Managed block hash verification failed for ${operation.relativeDestPath}: expected ${operation.desiredHash}, got ${hash2}`);
+      const hash3 = await writeManagedInstructionBlock(operation.sourcePath, operation.destPath, selector, transport, managedBlockMutationOptions(operation));
+      if (hash3 !== operation.desiredHash) {
+        throw new Error(`Managed block hash verification failed for ${operation.relativeDestPath}: expected ${operation.desiredHash}, got ${hash3}`);
       }
       return manifestEntryForOperation(operation, {
         now,
-        hash: hash2,
+        hash: hash3,
         sourceHash: operation.desiredHash,
         graphLockDigest: context.graphLockDigest
       });
@@ -5997,13 +6315,13 @@ async function applyOperation(operation, context) {
     } else {
       await transport.atomicCopy(operation.sourcePath, operation.destPath, operation.kind);
     }
-    const hash = await transport.hashPath(operation.destPath);
-    if (!operation.mergeStrategy && hash !== operation.desiredHash) {
-      throw new Error(`Hash verification failed for ${operation.relativeDestPath}: expected ${operation.desiredHash}, got ${hash}`);
+    const hash2 = await transport.hashPath(operation.destPath);
+    if (!operation.mergeStrategy && hash2 !== operation.desiredHash) {
+      throw new Error(`Hash verification failed for ${operation.relativeDestPath}: expected ${operation.desiredHash}, got ${hash2}`);
     }
     return manifestEntryForOperation(operation, {
       now,
-      hash,
+      hash: hash2,
       sourceHash: operation.desiredHash,
       graphLockDigest: context.graphLockDigest
     });
@@ -6599,6 +6917,7 @@ var init_apply = __esm({
     init_openclaw_json_merge();
     init_manifest2();
     init_path_safety();
+    init_paths();
     init_transaction();
     init_toml_merge();
     init_yaml_merge();
@@ -6647,11 +6966,11 @@ var init_identify = __esm({
 });
 
 // src/cli/index.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 import { existsSync } from "fs";
-import { mkdir as mkdir26, mkdtemp as mkdtemp6, realpath as realpath4, rm as rm17, writeFile as writeFile24 } from "fs/promises";
+import { mkdir as mkdir27, mkdtemp as mkdtemp6, readFile as readFile45, realpath as realpath4, rm as rm17, writeFile as writeFile24 } from "fs/promises";
 import { homedir as homedir18, tmpdir as tmpdir7 } from "os";
-import { basename as basename24, dirname as dirname37, isAbsolute as isAbsolute14, join as join59, relative as relative18, resolve as resolve43 } from "path";
+import { basename as basename24, dirname as dirname37, isAbsolute as isAbsolute14, join as join61, relative as relative19, resolve as resolve44 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { Command } from "commander";
 
@@ -6680,8 +6999,8 @@ async function loadProgrammaticAdapter(modulePath, options) {
   if (!stats.isFile()) {
     throw new Error(`Programmatic adapter module is not a file: ${resolvedPath}`);
   }
-  const hash = await hashPath(resolvedPath);
-  const importPath = extname(resolvedPath) === ".ts" ? await transpileTypeScriptAdapter(resolvedPath, hash) : resolvedPath;
+  const hash2 = await hashPath(resolvedPath);
+  const importPath = extname(resolvedPath) === ".ts" ? await transpileTypeScriptAdapter(resolvedPath, hash2) : resolvedPath;
   const imported = await import(`${pathToFileURL(importPath).href}?agentwheel=${Date.now()}`);
   const candidate = imported.adapter;
   if (!candidate || typeof candidate !== "object") {
@@ -6690,7 +7009,7 @@ async function loadProgrammaticAdapter(modulePath, options) {
   const parsed = adapterSchema.parse(candidate);
   const runtime = {
     modulePath: resolvedPath,
-    hash,
+    hash: hash2,
     capabilities: Array.isArray(candidate.capabilities) ? candidate.capabilities.filter((item) => typeof item === "string") : [],
     plan: typeof candidate.plan === "function" ? candidate.plan.bind(candidate) : void 0,
     apply: typeof candidate.apply === "function" ? candidate.apply.bind(candidate) : void 0,
@@ -6698,7 +7017,7 @@ async function loadProgrammaticAdapter(modulePath, options) {
   };
   return { ...parsed, programmatic: runtime };
 }
-async function transpileTypeScriptAdapter(modulePath, hash) {
+async function transpileTypeScriptAdapter(modulePath, hash2) {
   const source = await readFile3(modulePath, "utf8");
   const output = ts.transpileModule(source, {
     compilerOptions: {
@@ -6710,7 +7029,7 @@ async function transpileTypeScriptAdapter(modulePath, hash) {
     },
     fileName: modulePath
   });
-  const outPath = join2(tmpdir(), `agentwheel-adapter-${hash}.mjs`);
+  const outPath = join2(tmpdir(), `agentwheel-adapter-${hash2}.mjs`);
   await writeFile2(outPath, output.outputText, "utf8");
   return outPath;
 }
@@ -6739,11 +7058,11 @@ init_manifest2();
 // src/install/plan.ts
 init_adapter();
 init_manifest();
-import { basename as basename8, join as join24, relative as relative8 } from "path";
+import { basename as basename8, join as join24, relative as relative9 } from "path";
 
 // src/staging/codex-subagents.ts
 init_fs();
-import { mkdir as mkdir11, readFile as readFile19, writeFile as writeFile13 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile19, writeFile as writeFile13 } from "fs/promises";
 import { basename as basename4, dirname as dirname15, join as join14 } from "path";
 import { parse as parseYaml } from "yaml";
 var requiredCodexAgentFields = ["name", "description", "developer_instructions"];
@@ -6790,7 +7109,7 @@ async function renderCodexSubagent(artifact, stageRoot) {
   }
   const markdown = await readFile19(markdownPath, "utf8");
   const toml = markdownToCodexAgentToml(agentName, markdown);
-  await mkdir11(dirname15(renderedPath), { recursive: true });
+  await mkdir12(dirname15(renderedPath), { recursive: true });
   await writeFile13(renderedPath, toml, "utf8");
   return {
     ...artifact,
@@ -6872,7 +7191,7 @@ function escapeRegExp2(value) {
 
 // src/staging/copilot-artifacts.ts
 init_fs();
-import { mkdir as mkdir12, readFile as readFile20, writeFile as writeFile14 } from "fs/promises";
+import { mkdir as mkdir13, readFile as readFile20, writeFile as writeFile14 } from "fs/promises";
 import { basename as basename5, dirname as dirname16, join as join15 } from "path";
 async function renderCopilotArtifacts(artifacts, stageRoot, adapter) {
   if (adapter?.name !== "copilot") return artifacts;
@@ -6904,7 +7223,7 @@ async function renderCopilotSubagent(artifact, stageRoot) {
     throw new Error(`Copilot subagent ${artifact.relativePath} must be a .md file or directory containing AGENTS.md.`);
   }
   const markdown = await readFile20(markdownPath, "utf8");
-  await mkdir12(dirname16(renderedPath), { recursive: true });
+  await mkdir13(dirname16(renderedPath), { recursive: true });
   await writeFile14(renderedPath, ensureCopilotAgentDescription(agentName, markdown), "utf8");
   return {
     ...artifact,
@@ -6959,7 +7278,7 @@ function yamlString(value) {
 
 // src/staging/openclaw-subagents.ts
 init_fs();
-import { mkdir as mkdir13, readFile as readFile21, writeFile as writeFile15 } from "fs/promises";
+import { mkdir as mkdir14, readFile as readFile21, writeFile as writeFile15 } from "fs/promises";
 import { basename as basename6, dirname as dirname17, join as join16 } from "path";
 async function renderOpenClawSubagents(artifacts, stageRoot, adapter) {
   if (adapter?.name !== "openclaw") return artifacts;
@@ -6994,7 +7313,7 @@ async function renderOpenClawSubagent(artifact, stageRoot) {
 
 ${parsed.description ?? `OpenClaw subagent ${agentId}.`}`;
   const renderedPath = join16(stageRoot, ".agentwheel-rendered", "openclaw-subagents", agentId, "AGENTS.md");
-  await mkdir13(dirname17(renderedPath), { recursive: true });
+  await mkdir14(dirname17(renderedPath), { recursive: true });
   await writeFile15(renderedPath, `${body}
 `, "utf8");
   const renderedDir = dirname17(renderedPath);
@@ -7280,59 +7599,7 @@ init_transport();
 
 // src/validation/adapter-targets.ts
 init_adapter();
-
-// src/model/selection.ts
-init_artifact();
-function artifactSelectorKey(artifact) {
-  return `${artifact.type}/${artifact.name}`;
-}
-function artifactSelectorAliases(artifact) {
-  const primary = artifactSelectorKey(artifact);
-  if (artifact.type !== "subagents") return [primary];
-  const baseName = subagentBaseName(artifact.name);
-  if (baseName === artifact.name) return [primary];
-  return [primary, `subagents/${baseName}`];
-}
-function normalizeArtifactSelectors(select, legacySkills) {
-  const selected = [
-    ...select ?? [],
-    ...(legacySkills ?? []).map((name) => `skills/${name}`)
-  ].flatMap(splitSelectorList);
-  if (selected.length === 0) return void 0;
-  return [...new Set(selected.map(parseArtifactSelector))];
-}
-function filterArtifactsBySelection(artifacts, selectors, legacySkills, options = {}) {
-  const selected = normalizeArtifactSelectors(selectors, legacySkills);
-  if (!selected?.length) return artifacts;
-  const selectedSet = new Set(selected);
-  const available = new Set((options.validationArtifacts ?? artifacts).flatMap(artifactSelectorAliases));
-  const missing = selected.filter((selector) => !available.has(selector));
-  if (missing.length > 0) {
-    throw new Error(`Selected artifact not found in package: ${missing.join(", ")}`);
-  }
-  return artifacts.filter((artifact) => artifact.required || artifactSelectorAliases(artifact).some((selector) => selectedSet.has(selector)));
-}
-function splitSelectorList(value) {
-  return value.split(",").map((item) => item.trim()).filter(Boolean);
-}
-function parseArtifactSelector(value) {
-  const slash = value.indexOf("/");
-  if (slash <= 0 || slash === value.length - 1) {
-    throw new Error(`Invalid artifact selector: ${value}. Expected <type>/<name>.`);
-  }
-  const type = value.slice(0, slash);
-  const name = value.slice(slash + 1);
-  const parsedType = artifactTypeSchema.safeParse(type);
-  if (!parsedType.success) {
-    throw new Error(`Invalid artifact selector type: ${type}`);
-  }
-  return `${parsedType.data}/${name}`;
-}
-function subagentBaseName(name) {
-  return name.replace(/\.agent\.md$/i, "").replace(/\.toml$/i, "").replace(/\.md$/i, "");
-}
-
-// src/validation/adapter-targets.ts
+init_selection();
 function filterArtifactsByAdapterTargets(artifacts, adapter, installationType, options = {}) {
   const skipped = [];
   const installable = artifacts.filter((artifact) => {
@@ -7375,10 +7642,11 @@ function skipWarning(selector, adapter, installationType, artifactType, support)
 
 // src/validation/artifacts.ts
 init_adapter();
+init_selection();
+init_fs();
 import { readFile as readFile24 } from "fs/promises";
 import { basename as basename7, join as join23 } from "path";
 import { parseDocument as parseDocument2 } from "yaml";
-init_fs();
 var behavioralRuleFormats = ["markdown-rule", "claude-markdown-rule", "copilot-instruction-rule"];
 var pluginFormats = ["claude-plugin", "codex-plugin", "hermes-plugin", "copilot-plugin", "openclaw-plugin", "openclaw-clawhub-plugin"];
 async function filterArtifactsByInstallFormat(artifacts, adapter, installationType, options = {}) {
@@ -8497,7 +8765,7 @@ async function operationForArtifact(artifact, adapter, targetRoot, installationT
       kind: "file",
       sourcePath: artifact.stagedPath ?? artifact.sourcePath,
       destPath: destPath2,
-      relativeDestPath: relative8(targetRoot, destPath2).replaceAll("\\", "/"),
+      relativeDestPath: relative9(targetRoot, destPath2).replaceAll("\\", "/"),
       desiredHash: artifact.hash,
       reason: "destination missing",
       channel: artifact.channel ?? "managed",
@@ -8515,7 +8783,7 @@ async function operationForArtifact(artifact, adapter, targetRoot, installationT
     kind: artifact.kind,
     sourcePath: artifact.stagedPath ?? artifact.sourcePath,
     destPath,
-    relativeDestPath: relative8(targetRoot, destPath).replaceAll("\\", "/"),
+    relativeDestPath: relative9(targetRoot, destPath).replaceAll("\\", "/"),
     desiredHash: artifact.hash,
     reason: "destination missing",
     channel: artifact.channel ?? "managed",
@@ -9512,14 +9780,14 @@ async function writeMermaidAsset(response) {
     "content-type": "application/javascript; charset=utf-8",
     "cache-control": "public, max-age=3600"
   });
-  await new Promise((resolve44) => {
+  await new Promise((resolve45) => {
     const stream = createReadStream(assetPath);
     stream.on("error", () => {
       if (!response.headersSent) writeText(response, 404, "Mermaid asset unavailable.\n");
       else response.destroy();
-      resolve44();
+      resolve45();
     });
-    stream.on("end", resolve44);
+    stream.on("end", resolve45);
     stream.pipe(response);
   });
 }
@@ -9546,14 +9814,14 @@ function escapeHtml2(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
 function listen(server, port, bind) {
-  return new Promise((resolve44, reject) => {
+  return new Promise((resolve45, reject) => {
     const onError = (error) => {
       server.off("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve44();
+      resolve45();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -9561,7 +9829,7 @@ function listen(server, port, bind) {
   });
 }
 function waitForShutdown(server, beforeClose) {
-  return new Promise((resolve44) => {
+  return new Promise((resolve45) => {
     let closing = false;
     const shutdown = () => {
       if (closing) return;
@@ -9569,7 +9837,7 @@ function waitForShutdown(server, beforeClose) {
       process.off("SIGINT", shutdown);
       process.off("SIGTERM", shutdown);
       beforeClose();
-      server.close(() => resolve44());
+      server.close(() => resolve45());
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
@@ -9579,7 +9847,7 @@ function waitForShutdown(server, beforeClose) {
       process.off("SIGINT", shutdown);
       process.off("SIGTERM", shutdown);
       beforeClose();
-      resolve44();
+      resolve45();
     });
   });
 }
@@ -9597,7 +9865,7 @@ function errorMessage2(error) {
 }
 
 // src/source/clawhub.ts
-import { mkdir as mkdir14, rm as rm8, writeFile as writeFile16 } from "fs/promises";
+import { mkdir as mkdir15, rm as rm8, writeFile as writeFile16 } from "fs/promises";
 import { basename as basename10, dirname as dirname18, join as join28, resolve as resolve18 } from "path";
 
 // src/model/package.ts
@@ -9791,8 +10059,8 @@ init_fs();
 
 // src/source/local.ts
 import { createHash as createHash13 } from "crypto";
-import { readdir as readdir5, stat as stat5 } from "fs/promises";
-import { basename as basename9, join as join27, relative as relative9, resolve as resolve17 } from "path";
+import { readdir as readdir6, stat as stat5 } from "fs/promises";
+import { basename as basename9, join as join27, relative as relative10, resolve as resolve17 } from "path";
 init_fs();
 var LocalSourceDriver = class {
   name = "local";
@@ -9933,23 +10201,23 @@ var LocalSourceDriver = class {
 };
 async function hashLocalSource(root, manifest) {
   if (!manifest) return hashPath(root);
-  const hash = createHash13("sha256").update("local-openpack\0");
+  const hash2 = createHash13("sha256").update("local-openpack\0");
   const manifestPath = await findPackageManifestPath(root, { warnLegacy: false });
   if (manifestPath) {
-    hash.update("manifest\0");
-    hash.update(relative9(root, manifestPath).replaceAll("\\", "/")).update("\0");
-    hash.update(await hashPath(manifestPath)).update("\0");
+    hash2.update("manifest\0");
+    hash2.update(relative10(root, manifestPath).replaceAll("\\", "/")).update("\0");
+    hash2.update(await hashPath(manifestPath)).update("\0");
   }
   const provides = [...manifest.provides].sort((a, b) => `${a.type}\0${a.path}`.localeCompare(`${b.type}\0${b.path}`));
   for (const provide of provides) {
     const full = join27(root, provide.path);
     if (!await pathExists(full)) continue;
-    hash.update("provide\0");
-    hash.update(provide.type).update("\0");
-    hash.update(provide.path.replaceAll("\\", "/")).update("\0");
-    hash.update(await hashPath(full)).update("\0");
+    hash2.update("provide\0");
+    hash2.update(provide.type).update("\0");
+    hash2.update(provide.path.replaceAll("\\", "/")).update("\0");
+    hash2.update(await hashPath(full)).update("\0");
   }
-  return hash.digest("hex");
+  return hash2.digest("hex");
 }
 async function firstExisting(paths) {
   for (const path of paths) {
@@ -9958,7 +10226,7 @@ async function firstExisting(paths) {
   return void 0;
 }
 async function sortedDirEntries(path) {
-  return (await readdir5(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+  return (await readdir6(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
 }
 async function listFromManifest(root, packageName) {
   const manifest = await readPackageManifest(root);
@@ -10139,7 +10407,7 @@ async function fetchClawHubPackage(fetchImpl, packageName) {
   throw new Error(`ClawHub lookup failed for ${packageName}`);
 }
 async function delay(ms) {
-  await new Promise((resolve44) => setTimeout(resolve44, ms));
+  await new Promise((resolve45) => setTimeout(resolve45, ms));
 }
 function parseClawHubSource(source) {
   if (!source.startsWith(sourcePrefix)) {
@@ -10171,7 +10439,7 @@ async function writeGeneratedPackage(root, packageInfo) {
   };
   const pluginPath = join28(root, "plugins", pluginId, "clawhub.json");
   await rm8(root, { recursive: true, force: true });
-  await mkdir14(dirname18(pluginPath), { recursive: true });
+  await mkdir15(dirname18(pluginPath), { recursive: true });
   await writeFile16(join28(root, "openpack.json"), `${JSON.stringify({
     schemaVersion: CURRENT_OPENPACK_SCHEMA_VERSION,
     name: `clawhub/${name}`,
@@ -10202,9 +10470,9 @@ function cachePathFor(packageName, cacheRoot) {
 
 // src/source/git.ts
 import { execFile as execFile5 } from "child_process";
-import { mkdir as mkdir16, rename as rename6, rm as rm10, stat as stat7 } from "fs/promises";
+import { mkdir as mkdir17, rename as rename6, rm as rm10, stat as stat7 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { basename as basename11, dirname as dirname20, join as join31, resolve as resolve19, sep as sep5 } from "path";
+import { basename as basename11, dirname as dirname20, join as join31, resolve as resolve19, sep as sep6 } from "path";
 import { promisify as promisify5 } from "util";
 init_fs();
 
@@ -10285,8 +10553,8 @@ function isMissingFile(error) {
 
 // src/source/cache.ts
 init_fs();
-import { randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir15, readdir as readdir6, readFile as readFile27, rm as rm9, stat as stat6, writeFile as writeFile17 } from "fs/promises";
+import { randomUUID as randomUUID4 } from "crypto";
+import { mkdir as mkdir16, readdir as readdir7, readFile as readFile27, rm as rm9, stat as stat6, writeFile as writeFile17 } from "fs/promises";
 import { dirname as dirname19, join as join30 } from "path";
 var snapshotNamePattern = /^(.*)-([0-9a-f]{12})$/i;
 var leaseMarker = ".agentwheel-lease-";
@@ -10301,11 +10569,11 @@ async function pruneGitCache(cacheRoot, options = {}) {
 }
 async function withGitCacheMaintenanceLock(cacheRoot, timeoutMs, fn) {
   const lockPath = join30(cacheRoot, ".maintenance.lock");
-  await mkdir15(cacheRoot, { recursive: true });
+  await mkdir16(cacheRoot, { recursive: true });
   const started = Date.now();
   while (true) {
     try {
-      await mkdir15(lockPath);
+      await mkdir16(lockPath);
       await writeFile17(
         join30(lockPath, "owner.json"),
         JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString() }),
@@ -10318,7 +10586,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((resolve44) => setTimeout(resolve44, 50));
+      await new Promise((resolve45) => setTimeout(resolve45, 50));
     }
   }
   try {
@@ -10328,7 +10596,7 @@ async function withGitCacheMaintenanceLock(cacheRoot, timeoutMs, fn) {
   }
 }
 async function createGitSnapshotLease(snapshotPath) {
-  const leasePath = `${snapshotPath}${leaseMarker}${process.pid}-${randomUUID3()}`;
+  const leasePath = `${snapshotPath}${leaseMarker}${process.pid}-${randomUUID4()}`;
   await writeFile17(leasePath, JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString() }), {
     encoding: "utf8",
     flag: "wx"
@@ -10341,7 +10609,7 @@ async function releaseGitSnapshotLease(leasePath) {
 async function removeGeneratedEntries(root, preserveGit) {
   let entries;
   try {
-    entries = await readdir6(root, { withFileTypes: true });
+    entries = await readdir7(root, { withFileTypes: true });
   } catch {
     return;
   }
@@ -10356,7 +10624,7 @@ async function removeGeneratedEntries(root, preserveGit) {
 }
 async function pruneGitCacheUnlocked(cacheRoot, options) {
   const referencedCommits = await referencedGraphLockCommits(join30(dirname19(cacheRoot), "locks"));
-  const entries = await readdir6(cacheRoot, { withFileTypes: true });
+  const entries = await readdir7(cacheRoot, { withFileTypes: true });
   const groups = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -10403,7 +10671,7 @@ async function referencedGraphLockCommits(lockRoot) {
 async function walkGraphLocks(root, visit) {
   let entries;
   try {
-    entries = await readdir6(root, { withFileTypes: true });
+    entries = await readdir7(root, { withFileTypes: true });
   } catch (error) {
     if (isNotFound(error)) return;
     throw new Error(`Cannot inspect graph-lock directory ${root}; cache prune aborted: ${errorMessage3(error)}`);
@@ -10424,7 +10692,7 @@ async function walkGraphLocks(root, visit) {
 async function hasLiveSnapshotLease(snapshotPath, dryRun) {
   const directory = dirname19(snapshotPath);
   const prefix = `${snapshotPath.slice(directory.length + 1)}${leaseMarker}`;
-  const entries = await readdir6(directory, { withFileTypes: true });
+  const entries = await readdir7(directory, { withFileTypes: true });
   let live = false;
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.startsWith(prefix)) continue;
@@ -10523,10 +10791,10 @@ function normalizeGitSubpath(subpath, source) {
   }
   return normalized;
 }
-function resolveGitRelativeSubpath(declaringSubpath, relative19, source) {
-  const joined = posix4.normalize(posix4.join(declaringSubpath ?? ".", relative19));
+function resolveGitRelativeSubpath(declaringSubpath, relative20, source) {
+  const joined = posix4.normalize(posix4.join(declaringSubpath ?? ".", relative20));
   if (joined === ".." || joined.startsWith("../")) {
-    throw new Error(`Relative dependency '${relative19}' escapes the git repository it is declared in: ${source}`);
+    throw new Error(`Relative dependency '${relative20}' escapes the git repository it is declared in: ${source}`);
   }
   return normalizeGitSubpath(joined, source);
 }
@@ -10562,7 +10830,7 @@ var GitSourceDriver = class {
     return withFilesystemLock(`${resolved.resolvedPath}.lock`, resolved.cacheLockTimeoutMs ?? 3e4, async () => {
       const parsed = parseGitSource(resolved.source);
       const cacheRoot = dirname20(resolved.resolvedPath);
-      await mkdir16(cacheRoot, { recursive: true });
+      await mkdir17(cacheRoot, { recursive: true });
       await assertOwnedByCurrentUser(cacheRoot);
       if (await pathExists(resolved.resolvedPath)) await assertOwnedByCurrentUser(resolved.resolvedPath);
       if (!await pathExists(join31(resolved.resolvedPath, ".git"))) {
@@ -10662,11 +10930,11 @@ async function snapshotCommit(checkoutPath, commit) {
   const tempIndexPath = `${tempPath}.index`;
   await rm10(tempPath, { recursive: true, force: true });
   await rm10(tempIndexPath, { force: true });
-  await mkdir16(tempPath, { recursive: true });
+  await mkdir17(tempPath, { recursive: true });
   const env2 = { ...process.env, GIT_INDEX_FILE: tempIndexPath };
   try {
     await git(["-C", checkoutPath, "read-tree", commit], env2);
-    await git(["-C", checkoutPath, "checkout-index", "--all", `--prefix=${resolve19(tempPath)}${sep5}`], env2);
+    await git(["-C", checkoutPath, "checkout-index", "--all", `--prefix=${resolve19(tempPath)}${sep6}`], env2);
     await removeGeneratedEntries(tempPath, false);
   } catch (error) {
     await rm10(tempPath, { recursive: true, force: true });
@@ -10695,7 +10963,7 @@ async function assertOwnedByCurrentUser(path) {
 }
 
 // src/source/mcp-registry.ts
-import { mkdir as mkdir17, writeFile as writeFile18 } from "fs/promises";
+import { mkdir as mkdir18, writeFile as writeFile18 } from "fs/promises";
 import { basename as basename12, dirname as dirname21, join as join32, resolve as resolve20 } from "path";
 init_fs();
 var registryBaseUrl = "https://registry.modelcontextprotocol.io/v0.1";
@@ -10804,7 +11072,7 @@ function isSafeHttpUrl(value) {
 async function writeGeneratedPackage2(root, server) {
   const serverId = installNameFor3(server.serverName);
   const mcpPath = join32(root, "mcp", `${serverId}.json`);
-  await mkdir17(dirname21(mcpPath), { recursive: true });
+  await mkdir18(dirname21(mcpPath), { recursive: true });
   await writeFile18(join32(root, "openpack.json"), `${JSON.stringify({
     schemaVersion: CURRENT_OPENPACK_SCHEMA_VERSION,
     name: `mcp-registry/${server.serverName}`,
@@ -10834,9 +11102,9 @@ function cachePathFor3(serverName, cacheRoot) {
 // src/source/skillkit.ts
 init_cache_identity();
 init_fs();
-import { createHash as createHash14, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash14, randomUUID as randomUUID5 } from "crypto";
 import { execFile as execFile6 } from "child_process";
-import { cp as cp3, mkdir as mkdir18, readFile as readFile28, rename as rename7, rm as rm11 } from "fs/promises";
+import { cp as cp3, mkdir as mkdir19, readFile as readFile28, rename as rename7, rm as rm11 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 import { basename as basename14, dirname as dirname23, join as join34, resolve as resolve21 } from "path";
 import { promisify as promisify6 } from "util";
@@ -10844,7 +11112,7 @@ import * as defaultSkillKit from "@skillkit/core";
 
 // src/source/skill-artifacts.ts
 init_fs();
-import { readdir as readdir7, stat as stat8 } from "fs/promises";
+import { readdir as readdir8, stat as stat8 } from "fs/promises";
 import { basename as basename13, dirname as dirname22, extname as extname2, join as join33 } from "path";
 async function artifactsFromSkillPaths(paths, packageName) {
   const artifacts = [];
@@ -10912,7 +11180,7 @@ async function artifactFromSkillPath(item, packageName) {
 }
 async function walk(dir, paths) {
   if (!await pathExists(dir)) return;
-  const entries = await readdir7(dir, { withFileTypes: true });
+  const entries = await readdir8(dir, { withFileTypes: true });
   if (entries.some((entry) => entry.isFile() && entry.name === "SKILL.md")) {
     paths.push({ path: dir });
     return;
@@ -11015,8 +11283,8 @@ var SkillKitSourceDriver = class {
       if (immutablePath && await pathExists(immutablePath)) {
         return { path: immutablePath, commit: requestedCommit, cacheIdentity: requestedCommit };
       }
-      await mkdir18(dirname23(specCachePath), { recursive: true });
-      const candidatePath = `${specCachePath}.agentwheel-tmp-${process.pid}-${randomUUID4()}`;
+      await mkdir19(dirname23(specCachePath), { recursive: true });
+      const candidatePath = `${specCachePath}.agentwheel-tmp-${process.pid}-${randomUUID5()}`;
       const publishPath = `${candidatePath}.publish`;
       let result;
       try {
@@ -11171,7 +11439,7 @@ async function checkoutCommit(root, commit) {
 // src/source/vercel-skills.ts
 init_fs();
 import { stat as stat9 } from "fs/promises";
-import { basename as basename15, join as join35, relative as relative10, resolve as resolve22 } from "path";
+import { basename as basename15, join as join35, relative as relative11, resolve as resolve22 } from "path";
 var VercelSkillsSourceDriver = class {
   name = "vercel-skills";
   git = new GitSourceDriver();
@@ -11238,7 +11506,7 @@ async function resolveVercelSkillSubpath(root, subpath) {
   for (const candidate of candidates) {
     if (await pathExists(candidate)) return candidate;
   }
-  const tried = candidates.map((candidate) => relative10(root, candidate)).join(", ");
+  const tried = candidates.map((candidate) => relative11(root, candidate)).join(", ");
   throw new Error(`Vercel skills subpath not found: ${subpath} (tried ${tried})`);
 }
 function parseVercelSource(source) {
@@ -11307,8 +11575,8 @@ function getSourceDriver(name = "local") {
 init_identify();
 
 // src/staging/staging.ts
-import { chmod as chmod3, cp as cp5, mkdir as mkdir21, mkdtemp as mkdtemp4, readdir as readdir10, stat as stat12 } from "fs/promises";
-import { basename as basename19, dirname as dirname27, join as join39, relative as relative12, resolve as resolve25, sep as sep7 } from "path";
+import { chmod as chmod3, cp as cp5, mkdir as mkdir22, mkdtemp as mkdtemp4, readdir as readdir11, stat as stat12 } from "fs/promises";
+import { basename as basename19, dirname as dirname27, join as join39, relative as relative13, resolve as resolve25, sep as sep8 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 init_fs();
 
@@ -11316,8 +11584,8 @@ init_fs();
 init_artifact();
 init_fs();
 import { createHash as createHash15 } from "crypto";
-import { readdir as readdir8, readFile as readFile29, stat as stat10, writeFile as writeFile19 } from "fs/promises";
-import { basename as basename16, dirname as dirname24, extname as extname3, join as join36, relative as relative11, resolve as resolve24, sep as sep6 } from "path";
+import { readdir as readdir9, readFile as readFile29, stat as stat10, writeFile as writeFile19 } from "fs/promises";
+import { basename as basename16, dirname as dirname24, extname as extname3, join as join36, relative as relative12, resolve as resolve24, sep as sep7 } from "path";
 var includePattern = /<!--\s*openpack:include(\?)?\s+([^>]+?)\s*-->/g;
 var escapedIncludePattern = /<!--\s*openpack\\:include(\?)?\s+([^>]+?)\s*-->/g;
 var generatedPattern = /<!--\s*(?:BEGIN|END)\s+openpack:include\b/;
@@ -11527,7 +11795,7 @@ function extractOpenPackIncludeSelectors(content) {
 function resolvePackageSelector(packageRoot, selector) {
   const root = resolve24(packageRoot);
   const resolved = resolve24(root, selector);
-  if (resolved !== root && !resolved.startsWith(`${root}${sep6}`)) {
+  if (resolved !== root && !resolved.startsWith(`${root}${sep7}`)) {
     throw new Error(`OpenPack include escapes package root: ${selector}`);
   }
   return resolved;
@@ -11542,7 +11810,7 @@ async function markdownFilesForArtifact(artifact) {
 async function listMarkdownFiles(root) {
   const out = [];
   async function walk2(dir) {
-    for (const entry of (await readdir8(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+    for (const entry of (await readdir9(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
       const full = join36(dir, entry.name);
       if (entry.isDirectory()) {
         await walk2(full);
@@ -11578,7 +11846,7 @@ function applyReplacements(content, replacements) {
   return out + content.slice(cursor);
 }
 function relativeSelector(root, file) {
-  return relative11(root, file).replaceAll("\\", "/");
+  return relative12(root, file).replaceAll("\\", "/");
 }
 function ownerSelector(root, file, nodeId) {
   const selector = relativeSelector(root, file);
@@ -11608,7 +11876,7 @@ function artifactPathMap(artifacts) {
 
 // src/staging/customize.ts
 init_fs();
-import { cp as cp4, mkdir as mkdir19, readdir as readdir9, readFile as readFile30, writeFile as writeFile20 } from "fs/promises";
+import { cp as cp4, mkdir as mkdir20, readdir as readdir10, readFile as readFile30, writeFile as writeFile20 } from "fs/promises";
 import { dirname as dirname25, join as join37 } from "path";
 async function applyCustomizations(artifacts, options) {
   let next = [...artifacts];
@@ -11633,7 +11901,7 @@ async function applyInstructionOverlay(artifacts, options) {
   const managed = await readFile30(artifact.stagedPath ?? artifact.sourcePath, "utf8");
   const local = await readFile30(overlayPath, "utf8");
   const composedPath = join37(options.stageRoot, ".agentwheel-composed", "instructions", "AGENTS.md");
-  await mkdir19(dirname25(composedPath), { recursive: true });
+  await mkdir20(dirname25(composedPath), { recursive: true });
   await writeFile20(
     composedPath,
     [
@@ -11706,7 +11974,7 @@ async function applyReplacements2(artifacts, options, channel, artifactTypes) {
         const artifactKind = entry.isDirectory() ? "dir" : "file";
         const existing = byKey.get(artifactMapKey);
         const stagedPath = join37(options.stageRoot, ".agentwheel-composed", channel, type, entry.name);
-        await mkdir19(dirname25(stagedPath), { recursive: true });
+        await mkdir20(dirname25(stagedPath), { recursive: true });
         await cp4(full, stagedPath, { recursive: artifactKind === "dir", dereference: true });
         byKey.set(artifactMapKey, {
           ...existing,
@@ -11746,12 +12014,12 @@ function installableArtifactTypes() {
   return ["instructions", "rules", "skills", "commands", "subagents", "mcp", "hooks", "settings", "plugins"];
 }
 async function sortedDirEntries2(path) {
-  return (await readdir9(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+  return (await readdir10(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
 }
 
 // src/staging/claude-subagents.ts
 init_fs();
-import { mkdir as mkdir20, readFile as readFile31, writeFile as writeFile21 } from "fs/promises";
+import { mkdir as mkdir21, readFile as readFile31, writeFile as writeFile21 } from "fs/promises";
 import { basename as basename18, dirname as dirname26, join as join38 } from "path";
 async function renderClaudeSubagents(artifacts, stageRoot, adapter) {
   if (adapter?.name !== "claude") return artifacts;
@@ -11783,7 +12051,7 @@ async function renderClaudeSubagent(artifact, stageRoot) {
   }
   const content = await readFile31(markdownPath, "utf8");
   const renderedPath = join38(stageRoot, ".agentwheel-rendered", "claude-subagents", `${agentName}.md`);
-  await mkdir20(dirname26(renderedPath), { recursive: true });
+  await mkdir21(dirname26(renderedPath), { recursive: true });
   await writeFile21(renderedPath, content.endsWith("\n") ? content : `${content}
 `, "utf8");
   return {
@@ -11802,6 +12070,7 @@ function claudeAgentName(artifact) {
 }
 
 // src/staging/staging.ts
+init_selection();
 async function stageSource(driver, source, options = {}) {
   const raw = await stageSourceRaw(driver, source, options);
   return removeOnFailure(raw.root, () => renderStagedBundle(raw, options));
@@ -11825,7 +12094,7 @@ async function stageResolvedArtifactsRaw(resolved, artifacts, parentDir = tmpdir
   await removeOnFailure(root, async () => {
     for (const artifact of artifacts) {
       const stagedPath = join39(root, artifact.relativePath);
-      await mkdir21(dirname27(stagedPath), { recursive: true });
+      await mkdir22(dirname27(stagedPath), { recursive: true });
       await cp5(artifact.sourcePath, stagedPath, {
         recursive: artifact.kind === "dir",
         dereference: true,
@@ -11922,7 +12191,7 @@ async function copyAsset(asset, source, dest) {
   const sourceStats = await stat12(source);
   if (sourceStats.isFile()) {
     if (matchesAny(basename19(source), asset.include)) {
-      await mkdir21(dest, { recursive: true });
+      await mkdir22(dest, { recursive: true });
       await copyAssetFile(source, join39(dest, basename19(source)), asset);
     }
     return;
@@ -11931,26 +12200,26 @@ async function copyAsset(asset, source, dest) {
     throw new Error(`Asset include source is not a file or directory: ${source}`);
   }
   if (!asset.include?.length) {
-    await mkdir21(dirname27(dest), { recursive: true });
+    await mkdir22(dirname27(dest), { recursive: true });
     await cp5(source, dest, { recursive: true, dereference: true });
     if (asset.mode === "copy") await normalizeCopiedModes(dest);
     return;
   }
   for (const file of await listFiles2(source)) {
-    const rel = relative12(source, file).replaceAll("\\", "/");
+    const rel = relative13(source, file).replaceAll("\\", "/");
     if (!matchesAny(rel, asset.include) && !matchesAny(basename19(file), asset.include)) continue;
     await copyAssetFile(file, join39(dest, rel), asset);
   }
 }
 async function copyAssetFile(source, dest, asset) {
-  await mkdir21(dirname27(dest), { recursive: true });
+  await mkdir22(dirname27(dest), { recursive: true });
   await cp5(source, dest, { dereference: true });
   if (asset.mode === "copy") await chmod3(dest, 420);
 }
 function resolvePackagePath(packageRoot, path) {
   const resolved = resolve25(packageRoot, path);
   const root = resolve25(packageRoot);
-  if (resolved !== root && !resolved.startsWith(`${root}${sep7}`)) {
+  if (resolved !== root && !resolved.startsWith(`${root}${sep8}`)) {
     throw new Error(`Asset include escapes package root: ${path}`);
   }
   return resolved;
@@ -11958,7 +12227,7 @@ function resolvePackagePath(packageRoot, path) {
 async function listFiles2(root) {
   const out = [];
   async function walk2(dir) {
-    for (const entry of (await readdir10(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+    for (const entry of (await readdir11(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
       const full = join39(dir, entry.name);
       if (entry.isDirectory()) {
         await walk2(full);
@@ -11977,7 +12246,7 @@ async function normalizeCopiedModes(path) {
     return;
   }
   if (!stats.isDirectory()) return;
-  for (const entry of await readdir10(path, { withFileTypes: true })) {
+  for (const entry of await readdir11(path, { withFileTypes: true })) {
     await normalizeCopiedModes(join39(path, entry.name));
   }
 }
@@ -11998,22 +12267,24 @@ init_adapters();
 init_adapter();
 init_artifact();
 init_workspace();
-import { appendFile, cp as cp6, lstat as lstat2, mkdir as mkdir22, readdir as readdir12, rm as rm13 } from "fs/promises";
-import { dirname as dirname29, join as join42, relative as relative13 } from "path";
+import { appendFile, cp as cp6, lstat as lstat3, mkdir as mkdir23, readdir as readdir13, rm as rm13 } from "fs/promises";
+import { dirname as dirname29, join as join42, relative as relative14 } from "path";
 
 // src/resolve/graph.ts
 import { createHash as createHash17 } from "crypto";
-import { readdir as readdir11, readFile as readFile34, stat as stat14 } from "fs/promises";
+import { readdir as readdir12, readFile as readFile34, stat as stat14 } from "fs/promises";
 import { basename as basename20, extname as extname4, join as join41 } from "path";
 init_artifact();
 init_fs();
+init_selection();
 
 // src/model/workspace-composition.ts
 init_workspace();
+init_selection();
+init_fs();
 import { createHash as createHash16 } from "crypto";
 import { readFile as readFile32 } from "fs/promises";
 import { z as z12 } from "zod";
-init_fs();
 var selectionSourceConfigSchema = z12.object({
   schemaVersion: z12.literal(2),
   exports: workspaceExportsSchema
@@ -12172,6 +12443,7 @@ var registryCacheSchema = z13.object({
 });
 
 // src/registry/client.ts
+init_selection();
 init_workspace();
 init_fs();
 var DEFAULT_REGISTRY_SOURCE = "github:NestDevLab/agentwheel-registry";
@@ -13075,7 +13347,7 @@ async function markdownFilesForArtifact2(artifact) {
 async function listMarkdownFiles2(root) {
   const out = [];
   async function walk2(dir) {
-    for (const entry of (await readdir11(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+    for (const entry of (await readdir12(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
       const full = join41(dir, entry.name);
       if (entry.isDirectory()) {
         await walk2(full);
@@ -13257,8 +13529,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((resolve44) => {
-    release = resolve44;
+  const current = previous.then(() => new Promise((resolve45) => {
+    release = resolve45;
   }));
   cacheLocks.set(path, current);
   await previous;
@@ -13339,8 +13611,8 @@ function detectDirectCollisions(nodes) {
   }
 }
 function graphNodeId(name, version, normalizedSource, resolvedCommit, sourceHash) {
-  const digest2 = createHash17("sha256").update(normalizedSource).update("\0").update(resolvedCommit ?? sourceHash).digest("hex").slice(0, 12);
-  return `${name}@${version}+${digest2}`;
+  const digest3 = createHash17("sha256").update(normalizedSource).update("\0").update(resolvedCommit ?? sourceHash).digest("hex").slice(0, 12);
+  return `${name}@${version}+${digest3}`;
 }
 function sortedUnique4(values) {
   return [...new Set(values)].sort((a, b) => a.localeCompare(b));
@@ -13382,7 +13654,7 @@ init_declarations();
 async function remember(workspaceRoot, runtime, text) {
   const overlayPath = join42(workspaceRoot, ".agentwheel", "overlays", runtime, "instructions.local.md");
   declareMutationPath(overlayPath);
-  await mkdir22(dirname29(overlayPath), { recursive: true });
+  await mkdir23(dirname29(overlayPath), { recursive: true });
   await appendFile(overlayPath, `${text.trim()}
 `, "utf8");
   return { overlayPath };
@@ -13410,12 +13682,12 @@ async function ejectArtifact(workspaceRoot, item) {
     for (const path of await listFilesIfPresent(ejectedPath)) declareMutationPath(path);
     if (artifact.kind === "dir") {
       for (const sourceFile of await listFiles3(sourcePath)) {
-        declareMutationPath(join42(ejectedPath, relative13(sourcePath, sourceFile)));
+        declareMutationPath(join42(ejectedPath, relative14(sourcePath, sourceFile)));
       }
     } else {
       declareMutationPath(ejectedPath);
     }
-    await mkdir22(dirname29(ejectedPath), { recursive: true });
+    await mkdir23(dirname29(ejectedPath), { recursive: true });
     await rm13(ejectedPath, { recursive: true, force: true });
     await cp6(sourcePath, ejectedPath, { recursive: artifact.kind === "dir", dereference: true });
     return {
@@ -13431,11 +13703,11 @@ async function ejectArtifact(workspaceRoot, item) {
   }
 }
 async function listFiles3(root) {
-  const stats = await lstat2(root);
+  const stats = await lstat3(root);
   if (stats.isFile()) return [root];
   const files = [];
   async function walk2(dir) {
-    for (const entry of await readdir12(dir, { withFileTypes: true })) {
+    for (const entry of await readdir13(dir, { withFileTypes: true })) {
       const path = join42(dir, entry.name);
       if (entry.isDirectory()) await walk2(path);
       else files.push(path);
@@ -13533,7 +13805,7 @@ init_adapter();
 init_adapter();
 init_graph_lock();
 import { createHash as createHash19 } from "crypto";
-import { mkdir as mkdir24, readdir as readdir13 } from "fs/promises";
+import { mkdir as mkdir25, readdir as readdir14 } from "fs/promises";
 import { basename as basename21, dirname as dirname31, join as join45, posix as posix6, resolve as resolve31 } from "path";
 init_paths();
 init_merge_removal();
@@ -13674,8 +13946,8 @@ function formatNamespace(decision) {
 function formatOverride(decision) {
   return `${decision.graphNodeId}:${decision.type}/${decision.name} replaces ${decision.overriddenGraphNodeId}:${decision.type}/${decision.name} via ${decision.rootId} (${decision.selector})`;
 }
-function short(hash) {
-  return hash.slice(0, 12);
+function short(hash2) {
+  return hash2.slice(0, 12);
 }
 function selectionImportKey(root) {
   const selection = root.selectionImport;
@@ -13699,6 +13971,7 @@ function formatSelectionImport(root) {
 }
 
 // src/resolve/render.ts
+init_selection();
 import { createHash as createHash18 } from "crypto";
 import { readFile as readFile35, mkdtemp as mkdtemp5 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
@@ -14215,7 +14488,7 @@ init_fs();
 
 // src/lifecycle/trust.ts
 init_fs();
-import { mkdir as mkdir23, readFile as readFile36 } from "fs/promises";
+import { mkdir as mkdir24, readFile as readFile36 } from "fs/promises";
 import { homedir as homedir12 } from "os";
 import { dirname as dirname30, join as join44 } from "path";
 import { z as z14 } from "zod";
@@ -14294,7 +14567,7 @@ async function readTrustStore(path) {
   return trustStoreSchema.parse(JSON.parse(await readFile36(path, "utf8")));
 }
 async function writeTrustStore(path, store) {
-  await mkdir23(dirname30(path), { recursive: true });
+  await mkdir24(dirname30(path), { recursive: true });
   await writeJsonAtomic(path, trustStoreSchema.parse(store));
 }
 function defaultTrustStorePath() {
@@ -14303,6 +14576,7 @@ function defaultTrustStorePath() {
 
 // src/lifecycle/source-plan.ts
 init_workspace();
+init_selection();
 
 // src/model/workspace-owner.ts
 import { Buffer as Buffer2 } from "buffer";
@@ -14422,9 +14696,9 @@ async function createExactMcpRetirementPlan(desiredArtifacts, adapter, targetRoo
 init_fs();
 init_declarations();
 init_workspace();
-import { lstat as lstat3, readFile as readFile37, realpath as realpath2 } from "fs/promises";
+import { lstat as lstat4, readFile as readFile37, realpath as realpath2 } from "fs/promises";
 import { homedir as homedir13 } from "os";
-import { isAbsolute as isAbsolute10, relative as relative14, resolve as resolve29 } from "path";
+import { isAbsolute as isAbsolute10, relative as relative15, resolve as resolve29 } from "path";
 async function resolveWorkspaceScope(request = {}) {
   const selected = [request.user === true, request.local === true, request.fleet !== void 0].filter(Boolean).length;
   if (selected > 1) {
@@ -14562,7 +14836,7 @@ function assertFleetContract(id, registration, config) {
 async function assertCanonicalDirectory(input, label) {
   const canonical = await canonicalizeDirectory(input, label);
   const normalized = resolve29(input);
-  const stats = await lstat3(input);
+  const stats = await lstat4(input);
   if (stats.isSymbolicLink() || canonical !== normalized || input !== normalized) {
     throw new Error(`${label} must be canonical and symlink-unambiguous: ${input} resolves to ${canonical}.`);
   }
@@ -14576,7 +14850,7 @@ async function canonicalizeDirectory(input, label) {
   } catch {
     throw new Error(`${label} does not exist: ${input}`);
   }
-  const stats = await lstat3(canonical);
+  const stats = await lstat4(canonical);
   if (!stats.isDirectory()) throw new Error(`${label} is not a directory: ${input}`);
   return canonical;
 }
@@ -14596,7 +14870,7 @@ function sortedUnique6(values) {
   return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
 }
 function containsPath(parent, candidate) {
-  const path = relative14(parent, candidate);
+  const path = relative15(parent, candidate);
   return path === "" || !path.startsWith("..") && !isAbsolute10(path);
 }
 
@@ -15117,7 +15391,7 @@ async function discoverLegacyStateCandidates(options) {
   const directory = dirname31(options.graphLockPath);
   let names;
   try {
-    names = await readdir13(directory);
+    names = await readdir14(directory);
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -15553,7 +15827,7 @@ import { basename as basename22, dirname as dirname32, join as join47, resolve a
 // src/transport/run-as-identity.ts
 import { execFileSync } from "child_process";
 import { lstatSync, realpathSync as realpathSync2 } from "fs";
-import { isAbsolute as isAbsolute11, join as join46, parse as parse5, resolve as resolve32, sep as sep8 } from "path";
+import { isAbsolute as isAbsolute11, join as join46, parse as parse5, resolve as resolve32, sep as sep9 } from "path";
 function resolveRunAsIdentity(user, root, getent = (name) => execFileSync("/usr/bin/getent", ["passwd", name], { encoding: "utf8" })) {
   if (!/^[a-z_][a-z0-9_-]*[$]?$/i.test(user) || user === "root") {
     throw new Error(`Invalid local run-as account '${user}'.`);
@@ -15575,19 +15849,19 @@ function resolveRunAsIdentity(user, root, getent = (name) => execFileSync("/usr/
   if (!Number.isSafeInteger(uid) || uid <= 0 || !Number.isSafeInteger(gid) || gid < 0 || !isAbsolute11(home) || resolve32(home) !== home) {
     throw new Error(`Invalid UID, GID or home for local run-as account '${user}'.`);
   }
-  assertNoSymlinkPath(home);
+  assertNoSymlinkPath2(home);
   if (realpathSync2(home) !== home || !lstatSync(home).isDirectory()) {
     throw new Error(`Local run-as home ${home} must be a real directory.`);
   }
-  assertNoSymlinkPath(root);
+  assertNoSymlinkPath2(root);
   if (realpathSync2(root) !== root || !lstatSync(root).isDirectory() || lstatSync(root).uid !== uid) {
     throw new Error(`Local run-as root ${root} must be a real directory owned by UID ${uid}.`);
   }
   return { user, uid, gid, home, root };
 }
-function assertNoSymlinkPath(path) {
+function assertNoSymlinkPath2(path) {
   let current = parse5(path).root;
-  for (const part of path.slice(current.length).split(sep8).filter(Boolean)) {
+  for (const part of path.slice(current.length).split(sep9).filter(Boolean)) {
     current = join46(current, part);
     if (lstatSync(current).isSymbolicLink()) throw new Error(`Local run-as root contains a symlink: ${current}`);
   }
@@ -15773,6 +16047,7 @@ function runtimeScanRoot(request) {
 // src/lifecycle/profile.ts
 init_identify();
 init_transport();
+init_selection();
 init_declarations();
 async function syncProfile(options) {
   const config = await readMergedWorkspaceConfig(options.workspaceRoot);
@@ -15930,6 +16205,7 @@ function combinedSuggestionAliases(packageAliases, optionAliases) {
 }
 
 // src/registry/publish.ts
+init_selection();
 var DEFAULT_REGISTRY_SUBMISSION_URL = "https://github.com/NestDevLab/agentwheel-registry/issues/new";
 var registryEntryTypes = ["package", "skill", "plugin", "mcp", "adapter"];
 var explicitSourcePrefixes = ["github:", "git:", "skillkit:", "vercel:", "mcp-registry:", "clawhub:"];
@@ -16093,8 +16369,11 @@ function shellQuoteArg(value) {
   return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
 
+// src/cli/index.ts
+init_selection();
+
 // src/cli/update-check.ts
-import { mkdir as mkdir25, readFile as readFile38, writeFile as writeFile22 } from "fs/promises";
+import { mkdir as mkdir26, readFile as readFile38, writeFile as writeFile22 } from "fs/promises";
 import { homedir as homedir14 } from "os";
 import { dirname as dirname33, join as join48 } from "path";
 var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -16149,7 +16428,7 @@ async function readCache(path) {
   }
 }
 async function writeCache(path, cache) {
-  await mkdir25(dirname33(path), { recursive: true });
+  await mkdir26(dirname33(path), { recursive: true });
   await writeFile22(path, `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
@@ -16593,6 +16872,7 @@ init_manifest2();
 init_apply();
 init_paths();
 init_transaction();
+init_selection();
 import { createHash as createHash20 } from "crypto";
 import { resolve as resolve37 } from "path";
 init_declarations();
@@ -16872,14 +17152,222 @@ function canonicalJson6(value) {
   return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson6(record[key])}`).join(",")}}`;
 }
 
+// src/lifecycle/ownership-release.ts
+init_apply();
+init_manifest2();
+init_paths();
+init_transaction();
+import { createHash as createHash21, randomUUID as randomUUID6 } from "crypto";
+import { lstat as lstat5 } from "fs/promises";
+import { join as join52, resolve as resolve38 } from "path";
+init_coordinator();
+init_declarations();
+init_protocol();
+init_repository();
+init_process();
+init_transport();
+async function planReleaseOwnership(request) {
+  return observe2(request);
+}
+async function applyReleaseOwnership(request) {
+  for (const [name, value] of Object.entries({
+    planDigest: request.planDigest,
+    expectedSourceRevision: request.expectedSourceRevision,
+    expectedInventoryRevision: request.expectedInventoryRevision
+  })) {
+    if (!value || !/^[a-f0-9]{64}$/.test(value)) throw new Error(`Reviewed SHA-256 ${name} is required to release a claim.`);
+  }
+  const workspaceRoot = resolve38(request.workspaceRoot);
+  const existing = activeMutationMetadata();
+  if (existing && (resolve38(existing.workspaceRoot) !== workspaceRoot || existing.reason !== request.reason.replace(/\r\n?/gu, "\n").trim() || request.operationId && request.operationId !== existing.operationId)) {
+    throw new Error("Ownership release does not match the active governed workspace, reason or operation.");
+  }
+  const operationId = mutationOperationIdSchema.parse(existing?.operationId ?? request.operationId ?? randomUUID6());
+  const auditPath = join52(workspaceRoot, ".agentwheel", "ownership-releases", `${operationId}.json`);
+  const mutation = existing ? void 0 : await GovernedMutation.begin({
+    workspaceRoot,
+    commandName: "agentwheel ownership release-claim",
+    reason: request.reason,
+    operationId,
+    noCommit: request.noCommit,
+    globalRoot: request.globalRoot,
+    anticipatedPaths: [auditPath]
+  });
+  try {
+    if ((existing ?? mutation?.metadata())?.revisionMode === "commit-after-verify") {
+      const repository = await discoverGitRepository(workspaceRoot);
+      if (!repository) throw new Error("Ownership release requires a declarative Git audit path.");
+      const ignored = await runProcess("git", ["-C", repository.root, "check-ignore", "--no-index", "--", auditPath], { allowExitCodes: [0, 1] });
+      if (ignored.exitCode === 0) {
+        throw new Error("Ownership release audit path is Git-ignored; explicitly declare it in repository policy before releasing a claim.");
+      }
+    }
+    const result = await applyLocked(request, operationId, auditPath);
+    await mutation?.complete();
+    return result;
+  } catch (error) {
+    await mutation?.fail(error);
+    throw error;
+  }
+}
+async function applyLocked(request, operationId, auditPath) {
+  const transport = request.transport ?? localTransport;
+  if (transport.kind !== "local") throw new Error("Ownership release supports local targets only.");
+  await assertNoSymlinkPath(join52(resolve38(request.targetRoot), ".agentwheel"));
+  await assertNoSymlinkPath(auditPath);
+  const lock = await acquireApplyLock(resolve38(request.targetRoot), request.adapter, transport, {}, {
+    installationType: request.installationType,
+    stateKey: request.stateKey
+  });
+  try {
+    if ((await listAllApplyJournals(request.targetRoot, void 0, transport)).length) {
+      throw new Error("Ownership release refuses pending runtime journals; recover them first.");
+    }
+    const plan = await observe2(request);
+    if (plan.planDigest !== request.planDigest || plan.source.revision !== request.expectedSourceRevision || plan.manifestInventoryRevision !== request.expectedInventoryRevision) {
+      throw new Error("Stale ownership release plan, manifest or inventory; replan required.");
+    }
+    if (await transport.pathExists(auditPath)) throw new Error(`Ownership release audit already exists: ${auditPath}`);
+    declareMutationPath(auditPath);
+    declareMutationPath(plan.source.manifestPath);
+    const manifest = await readInstallManifest(plan.targetRoot, plan.adapter, transport, {
+      installationType: plan.installationType,
+      stateKey: plan.source.stateKey
+    });
+    if (!manifest || manifest.version !== 2 || manifest.revision !== plan.source.revision) {
+      throw new Error("Source manifest changed after selection; replan required.");
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const content = `${JSON.stringify({
+      schemaVersion: 1,
+      event: "ownership-release-intent",
+      operationId,
+      reason: plan.reason,
+      reviewedPlanDigest: plan.planDigest,
+      plan,
+      // This immutable dossier records intent. The linked journal verifies completion separately.
+      completion: "Verify install state and the governed mutation receipt; intent alone does not prove completion."
+    }, null, 2)}
+`;
+    const metadata = mutationMetadataForApplyJournal();
+    const journal = {
+      version: metadata ? 2 : 1,
+      ...metadata ? { mutation: metadata } : {},
+      mode: "uninstall",
+      adapter: plan.adapter,
+      installationType: plan.installationType,
+      stateKey: plan.source.stateKey,
+      targetRoot: plan.targetRoot,
+      baseRevision: manifest.revision,
+      createdAt: now,
+      updatedAt: now,
+      operations: [],
+      completed: [],
+      manifest: { ...manifest, entries: manifest.entries.filter((entry) => digest2(entry) !== plan.source.entryDigest) },
+      metadataAudit: {
+        kind: "ownership-release",
+        workspaceRoot: plan.workspaceRoot,
+        operationId,
+        planDigest: plan.planDigest,
+        inventory: plan.inventory,
+        runtime: [{ path: plan.path, hash: plan.runtimeHash, snapshotDigest: plan.runtimeSnapshotDigest }],
+        auditFiles: [{ path: `.agentwheel/ownership-releases/${operationId}.json`, content, sha256: hash(content) }]
+      }
+    };
+    await writeApplyJournal(journal, transport);
+    await commitManifestMetadataJournal(journal, transport);
+    return { ...plan, applied: true, operationId, auditPath, retainedEntries: journal.manifest.entries.length };
+  } finally {
+    await lock.release();
+  }
+}
+async function observe2(request) {
+  const transport = request.transport ?? localTransport;
+  if (transport.kind !== "local") throw new Error("Ownership release supports local targets only.");
+  const targetRoot = resolve38(request.targetRoot);
+  const workspaceRoot = resolve38(request.workspaceRoot);
+  const reason = mutationReasonSchema.parse(request.reason.trim());
+  if (!request.stateKey || stateKeyFor(request.adapter, { stateKey: request.stateKey }) !== request.stateKey || !request.installationType.trim() || !request.selector.includes("/")) {
+    throw new Error("Ownership release requires an exact state key, installation type and type/name selector.");
+  }
+  const runtimePath = metadataRuntimePath(targetRoot, request.path);
+  await assertNoSymlinkPath(workspaceRoot);
+  await assertNoSymlinkPath(join52(targetRoot, ".agentwheel"));
+  const manifests = await listInstallManifests(targetRoot, void 0, transport);
+  for (const item of manifests) await assertNoSymlinkPath(item.path);
+  const source = manifests.find((item) => item.stateKey === request.stateKey);
+  const manifest = source?.manifest;
+  if (!manifest || manifest.version !== 2 || manifest.adapter !== request.adapter || manifest.targetRoot !== targetRoot || manifest.installationType !== request.installationType || stateKeyFor(manifest.adapter, { stateKey: manifest.stateKey, installationType: manifest.installationType }) !== request.stateKey) {
+    throw new Error("Source manifest does not prove the requested target, adapter, installation type and state key.");
+  }
+  const matches = manifest.entries.filter((entry2) => entry2.path === request.path && `${entry2.artifactType}/${entry2.artifactName}` === request.selector);
+  if (matches.length !== 1) throw new Error(`Expected exactly one ownership claim at ${request.path} for ${request.selector}.`);
+  const entry = matches[0];
+  const owner = workspaceOwnerForRoot(request.fromWorkspaceRoot, request.fromFleetId);
+  if (entry.workspaceOwner !== owner) throw new Error(`Workspace owner does not match the selected claim at ${entry.path}.`);
+  if (entry.mergeStrategy || entry.mode || entry.semanticPlugin || entry.semanticCommand || entry.executed || entry.channel === "ejected") {
+    throw new Error("Ownership release only supports plain file/directory claims; shared or semantic contributions are protected.");
+  }
+  for (const item of manifests) {
+    for (const other of item.manifest.entries) {
+      if (item === source && other === entry) continue;
+      const otherPath = metadataRuntimePath(targetRoot, other.path);
+      if (otherPath === runtimePath || otherPath.startsWith(`${runtimePath}/`) || runtimePath.startsWith(`${otherPath}/`)) {
+        throw new Error(`Ambiguous or overlapping ownership claim at ${entry.path} in ${item.stateKey}.`);
+      }
+    }
+  }
+  const snapshotDigest = await ownershipRuntimeSnapshot(runtimePath);
+  const runtimeKind = (await lstat5(runtimePath)).isDirectory() ? "dir" : "file";
+  if (runtimeKind !== entry.kind) throw new Error("Selected runtime kind does not match the manifest claim.");
+  const runtimeHash = await transport.hashPath(runtimePath);
+  const inventory = manifests.map((item) => ({ stateKey: item.stateKey, revision: item.manifest.revision }));
+  const plan = {
+    adapter: request.adapter,
+    installationType: request.installationType,
+    targetRoot,
+    workspaceRoot,
+    owner,
+    selector: request.selector,
+    path: entry.path,
+    source: {
+      stateKey: request.stateKey,
+      manifestPath: installManifestPath(targetRoot, request.adapter, { installationType: request.installationType, stateKey: request.stateKey }),
+      revision: manifest.revision,
+      entryDigest: digest2(entry),
+      entry
+    },
+    recordedHash: entry.hash,
+    runtimeHash,
+    runtimeSnapshotDigest: snapshotDigest,
+    manifestInventoryRevision: await computeInstallManifestInventoryRevision(targetRoot, void 0, transport),
+    inventory,
+    reason
+  };
+  return { ...plan, planDigest: digest2(plan) };
+}
+function hash(content) {
+  return createHash21("sha256").update(content).digest("hex");
+}
+function digest2(value) {
+  return hash(canonicalJson7(value));
+}
+function canonicalJson7(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson7).join(",")}]`;
+  if (!value || typeof value !== "object") return JSON.stringify(value);
+  const record = value;
+  return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson7(record[key])}`).join(",")}}`;
+}
+
 // src/lifecycle/ownership-adopt-legacy.ts
 init_apply();
 init_manifest2();
 init_paths();
 init_transaction();
-import { createHash as createHash22 } from "crypto";
+init_instructions_block();
+import { createHash as createHash23 } from "crypto";
 import { realpath as realpath3 } from "fs/promises";
-import { isAbsolute as isAbsolute12, relative as relative16, resolve as resolve39 } from "path";
+import { isAbsolute as isAbsolute12, join as join54, relative as relative17, resolve as resolve40 } from "path";
 init_manifest();
 init_declarations();
 init_transport();
@@ -16892,18 +17380,18 @@ init_instructions_block();
 init_merge_removal();
 init_graph_lock();
 init_manifest();
-import { createHash as createHash21 } from "crypto";
-import { lstat as lstat4, readdir as readdir14 } from "fs/promises";
-import { basename as basename23, dirname as dirname35, join as join52, posix as posix7, relative as relative15, resolve as resolve38 } from "path";
+import { createHash as createHash22 } from "crypto";
+import { lstat as lstat6, readdir as readdir15 } from "fs/promises";
+import { basename as basename23, dirname as dirname35, join as join53, posix as posix7, relative as relative16, resolve as resolve39 } from "path";
 async function inventoryHistoricalLocks(fleetRoot) {
-  const root = join52(fleetRoot, ".agentwheel", "locks");
+  const root = join53(fleetRoot, ".agentwheel", "locks");
   const found = [];
   async function visit(dir) {
-    for (const entry of await readdir14(dir, { withFileTypes: true }).catch((error) => {
+    for (const entry of await readdir15(dir, { withFileTypes: true }).catch((error) => {
       if (error.code === "ENOENT") return [];
       throw error;
     })) {
-      const path = join52(dir, entry.name);
+      const path = join53(dir, entry.name);
       if (entry.isDirectory()) await visit(path);
       else if (entry.isFile() && entry.name.endsWith(".graph-lock.json")) found.push(await historicalLock(path));
     }
@@ -16912,15 +17400,15 @@ async function inventoryHistoricalLocks(fleetRoot) {
   return found.sort((a, b) => a.path.localeCompare(b.path));
 }
 async function findLegacyNamedLocks(workspaceRoot, adapter, fingerprint) {
-  const root = join52(workspaceRoot, ".agentwheel", "locks");
+  const root = join53(workspaceRoot, ".agentwheel", "locks");
   const found = [];
-  for (const target of await readdir14(root, { withFileTypes: true }).catch((error) => {
+  for (const target of await readdir15(root, { withFileTypes: true }).catch((error) => {
     if (error.code === "ENOENT") return [];
     throw error;
   })) {
     if (!target.isDirectory()) continue;
-    const path = join52(root, target.name, adapter, `${fingerprint}.graph-lock.json`);
-    const stats = await lstat4(path).catch((error) => {
+    const path = join53(root, target.name, adapter, `${fingerprint}.graph-lock.json`);
+    const stats = await lstat6(path).catch((error) => {
       if (error.code === "ENOENT") return void 0;
       throw error;
     });
@@ -16959,7 +17447,7 @@ async function planLegacyRecovery(input) {
   const nodeHashes = new Map(graphPlan.bundle.graphLock.canonical.nodes.map((node) => [node.id, node.sourceHash]));
   for (const op of graphPlan.plan.operations) {
     if (!op.desiredHash || op.action === "remove" || op.action === "keep") continue;
-    const path = relative15(installRoot, op.destPath);
+    const path = relative16(installRoot, op.destPath);
     if (path.startsWith("..") || path === "") throw new Error(`Planner destination escapes target: ${op.destPath}`);
     paths.add(path);
     const items = desired.get(path) ?? [];
@@ -16980,8 +17468,8 @@ async function planLegacyRecovery(input) {
     const currentNodeIds = [...new Set(current.map((item) => item.graphNodeId).filter((value) => Boolean(value)))].sort();
     const currentSelectors = [...new Set(current.map((item) => item.logicalSelector).filter((value) => Boolean(value)))].sort();
     const currentOwners = [...new Set(current.flatMap((item) => item.owners ?? []))].sort();
-    const livePath = resolve38(installRoot, path);
-    if (relative15(installRoot, livePath).startsWith("..")) throw new Error(`Manifest path escapes target: ${path}`);
+    const livePath = resolve39(installRoot, path);
+    if (relative16(installRoot, livePath).startsWith("..")) throw new Error(`Manifest path escapes target: ${path}`);
     const liveHash = await transport.pathExists(livePath) ? await transport.hashPath(livePath) : null;
     const reasons = [];
     const currentResults = await Promise.all(current.map((op) => verifyCurrentOperation(op, liveHash, transport)));
@@ -17046,14 +17534,14 @@ async function planLegacyRecovery(input) {
   };
 }
 function claimFor(item, entry, locks, binding) {
-  const digest2 = "graphLockDigest" in entry ? entry.graphLockDigest : void 0;
+  const digest3 = "graphLockDigest" in entry ? entry.graphLockDigest : void 0;
   const nodeId = "graphNodeId" in entry ? entry.graphNodeId : void 0;
   const selector = "logicalSelector" in entry ? entry.logicalSelector : void 0;
-  const matches = locks.filter((candidate) => candidate.digest === digest2);
+  const matches = locks.filter((candidate) => candidate.digest === digest3);
   const evidence = [];
   const owner = "workspaceOwner" in entry ? entry.workspaceOwner : legacyUnownedWorkspaceOwner;
-  const sameRoot = binding.transportKind === "ssh" ? posix7.normalize(item.manifest.targetRoot) === posix7.normalize(binding.installRoot) : resolve38(item.manifest.targetRoot) === resolve38(binding.installRoot);
-  const inTargetDir = matches.filter((candidate) => resolve38(dirname35(candidate.path)) === resolve38(binding.targetLockDir));
+  const sameRoot = binding.transportKind === "ssh" ? posix7.normalize(item.manifest.targetRoot) === posix7.normalize(binding.installRoot) : resolve39(item.manifest.targetRoot) === resolve39(binding.installRoot);
+  const inTargetDir = matches.filter((candidate) => resolve39(dirname35(candidate.path)) === resolve39(binding.targetLockDir));
   const boundLocks = inTargetDir.filter((candidate) => lockBindsState(candidate, item, binding));
   if (owner !== binding.expectedOwner) evidence.push("workspace owner differs from selected Fleet target");
   if (item.manifest.version !== 2 || item.manifest.installationType !== binding.installationType) evidence.push("installation type differs or manifest is legacy v1");
@@ -17061,7 +17549,7 @@ function claimFor(item, entry, locks, binding) {
   if (item.manifest.version === 2 && (item.manifest.stateKey !== item.stateKey || item.manifest.adapter !== binding.adapter)) {
     evidence.push("manifest state key or adapter differs from filename");
   }
-  if (!digest2) evidence.push("historical graph-lock digest missing");
+  if (!digest3) evidence.push("historical graph-lock digest missing");
   else if (matches.length === 0) evidence.push("historical graph-lock digest has no matching lock");
   if (matches.length && !inTargetDir.length) evidence.push("claim belongs to another Fleet target graph");
   if (inTargetDir.length && !boundLocks.length) evidence.push("graph-lock fingerprint, filename, or state key does not bind claim");
@@ -17082,7 +17570,7 @@ function claimFor(item, entry, locks, binding) {
     owner,
     hash: entry.hash,
     sourceHash: entry.sourceHash,
-    graphLockDigest: digest2,
+    graphLockDigest: digest3,
     graphNodeId: nodeId,
     logicalSelector: selector,
     owners: "owners" in entry ? entry.owners : [entry.packageName ?? "legacy"],
@@ -17095,7 +17583,7 @@ function lockBindsState(candidate, manifest, binding) {
   if (!name.endsWith(".graph-lock.json")) return false;
   const fingerprint = name.slice(0, -".graph-lock.json".length);
   if (!/^[a-f0-9]{64}$/u.test(fingerprint)) return false;
-  const stable = resolve38(candidate.path) === resolve38(binding.stableLockPath);
+  const stable = resolve39(candidate.path) === resolve39(binding.stableLockPath);
   if (stable) {
     return manifest.stateKey === binding.stableStateKey && candidate.lock.canonical.targetFingerprint === binding.currentFingerprint;
   }
@@ -17163,7 +17651,7 @@ function assertCompleteGraphPlan(plan) {
   }
 }
 function sha2566(value) {
-  return createHash21("sha256").update(value).digest("hex");
+  return createHash22("sha256").update(value).digest("hex");
 }
 
 // src/lifecycle/ownership-adopt-legacy.ts
@@ -17174,24 +17662,31 @@ function desiredCoverageFromPlan(plan) {
     artifactType: operation.artifactType,
     artifactName: operation.artifactName,
     kind: operation.kind,
+    ...operation.mode ? { mode: operation.mode } : {},
+    ...operation.mode && operation.logicalSelector ? { logicalSelector: operation.logicalSelector } : {},
     ...operation.packageName ? { packageName: operation.packageName } : {}
   })).sort((left, right) => left.path.localeCompare(right.path));
 }
 async function planAdoptLegacyOwnership(request) {
-  return observe2(request, request.transport ?? localTransport);
+  return observe3(request, request.transport ?? localTransport);
 }
 async function applyAdoptLegacyOwnership(request) {
   assertApplyPreconditions2(request);
   const transport = request.transport ?? localTransport;
-  const targetRoot = resolve39(request.targetRoot);
+  const targetRoot = resolve40(request.targetRoot);
   const installationType = request.installationType.trim();
+  if (transport.kind !== "local") throw new Error("Legacy ownership adoption requires a local filesystem transport.");
+  const beforeLock = await readInstallManifest(targetRoot, request.adapter, transport, { installationType, stateKey: request.sourceStateKey });
+  if (beforeLock?.entries.some((entry) => entry.mode === "managed-block")) {
+    await assertNoSymlinkPath(join54(targetRoot, ".agentwheel"));
+  }
   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);
+    const current = await observe3(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");
@@ -17211,6 +17706,7 @@ async function applyAdoptLegacyOwnership(request) {
       throw new Error("Source manifest selection changed while locked; replan required.");
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    let guards = current.metadataGuards;
     if (adopted.length > 0) {
       declareMutationPath(current.destination.manifestPath);
       const base = destination ?? {
@@ -17224,13 +17720,22 @@ async function applyAdoptLegacyOwnership(request) {
         legacy: false,
         entries: []
       };
-      await commitMetadata({
+      const next = withManifestRevision({
         ...base,
+        generatedAt: now,
         entries: [...base.entries, ...adopted].sort((left, right) => left.path.localeCompare(right.path))
-      }, destination?.revision ?? null, now, transport);
+      });
+      await commitMetadata(next, destination?.revision ?? null, now, transport, guards);
+      if (guards) guards = {
+        ...guards,
+        inventory: [
+          ...guards.inventory.filter((item) => item.stateKey !== current.destination.stateKey),
+          { stateKey: current.destination.stateKey, revision: next.revision }
+        ].sort((left, right) => left.stateKey.localeCompare(right.stateKey))
+      };
     }
     declareMutationPath(current.source.manifestPath);
-    await commitMetadata({ ...source, entries: retained }, source.revision, now, transport);
+    await commitMetadata({ ...source, entries: retained }, source.revision, now, transport, guards);
     return {
       ...current,
       applied: true,
@@ -17243,7 +17748,7 @@ async function applyAdoptLegacyOwnership(request) {
     await lock.release();
   }
 }
-async function commitMetadata(manifest, baseRevision, now, transport) {
+async function commitMetadata(manifest, baseRevision, now, transport, metadataGuards) {
   const mutation = mutationMetadataForApplyJournal();
   const journal = {
     version: mutation ? 2 : 1,
@@ -17258,12 +17763,13 @@ async function commitMetadata(manifest, baseRevision, now, transport) {
     updatedAt: now,
     operations: [],
     completed: [],
-    manifest
+    manifest,
+    ...metadataGuards ? { metadataGuards } : {}
   };
   await writeApplyJournal(journal, transport);
   await commitManifestMetadataJournal(journal, transport);
 }
-async function observe2(request, transport) {
+async function observe3(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.");
   }
@@ -17294,11 +17800,21 @@ async function observe2(request, transport) {
     desiredByPath
   );
   const selectedPaths = new Set(selectedEntries.map((entry) => entry.path));
+  const hasManagedBlock = selectedEntries.some((entry) => entry.mode === "managed-block");
+  if (hasManagedBlock && request.carryDrift) throw new Error("--carry-drift is forbidden for managed instruction block adoption.");
   const selected = [];
   for (const entry of selectedEntries) {
     const runtimePath = containedArtifactPath(targetRoot, entry.path);
+    const managedBlock = entry.mode === "managed-block" ? exactManagedInstructionBlockSnapshot(
+      await transport.readFile(runtimePath),
+      managedInstructionSelector(entry.logicalSelector, entry.artifactType, entry.artifactName)
+    ) : void 0;
+    if (managedBlock && managedBlock.hash !== entry.hash) {
+      throw new Error(`Managed instruction block hash differs from its recorded manifest hash at ${entry.path}; adoption is refused.`);
+    }
+    const runtimeSnapshotDigest = hasManagedBlock ? await ownershipRuntimeSnapshot(runtimePath) : void 0;
     const runtimeHash = await transport.pathExists(runtimePath) ? await transport.hashPath(runtimePath) : null;
-    const drift = runtimeHash !== entry.hash;
+    const drift = managedBlock ? false : 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.`
@@ -17321,9 +17837,28 @@ async function observe2(request, transport) {
       ...destinationEntryDigest ? { destinationEntryDigest } : {},
       recordedHash: entry.hash,
       runtimeHash,
-      drift
+      drift,
+      ...runtimeSnapshotDigest ? { runtimeSnapshotDigest } : {},
+      ...managedBlock ? { managedBlock } : {}
     });
   }
+  const guardedInventory = hasManagedBlock ? await listInstallManifests(targetRoot, void 0, transport) : void 0;
+  if (guardedInventory) {
+    for (const item of guardedInventory) {
+      await assertNoSymlinkPath(item.path);
+      for (const other of item.manifest.entries) {
+        const otherPath = containedArtifactPath(targetRoot, other.path);
+        for (const entry of selectedEntries) {
+          const path = containedArtifactPath(targetRoot, entry.path);
+          const overlap = otherPath === path || otherPath.startsWith(`${path}/`) || path.startsWith(`${otherPath}/`);
+          if (!overlap) continue;
+          if (item.stateKey === input.sourceStateKey && otherPath === path && "workspaceOwner" in other && entryDigest(other) === entryDigest(entry)) continue;
+          if (item.stateKey === input.destinationStateKey && otherPath === path && "workspaceOwner" in other && coversSourceEntry(other, entry, input.destinationOwner)) continue;
+          throw new Error(`Overlapping or duplicate ownership claim at ${entry.path} in ${item.stateKey}; managed-block adoption is refused.`);
+        }
+      }
+    }
+  }
   const remainingDuplicates = [];
   const selectedByPath = new Map(selectedEntries.map((entry) => [entry.path, entry]));
   for (const item of await listInstallManifests(targetRoot, adapter, transport)) {
@@ -17360,20 +17895,35 @@ async function observe2(request, transport) {
       owner: input.destinationOwner,
       workspaceRoot: input.workspaceRoot
     },
-    manifestInventoryRevision: await computeInstallManifestInventoryRevision(targetRoot, adapter, transport),
+    manifestInventoryRevision: await computeInstallManifestInventoryRevision(targetRoot, hasManagedBlock ? void 0 : 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))
+    desiredCoverage: request.desiredCoverage.filter((item) => selectedPaths.has(item.path)).map(({ path, artifactType, artifactName, kind, mode, logicalSelector }) => ({
+      path,
+      artifactType,
+      artifactName,
+      kind,
+      ...mode ? { mode, logicalSelector: managedInstructionSelector(logicalSelector, artifactType, artifactName) } : {}
+    })).sort((left, right) => left.path.localeCompare(right.path) || left.artifactType.localeCompare(right.artifactType) || left.artifactName.localeCompare(right.artifactName)),
+    ...guardedInventory ? { metadataGuards: {
+      inventory: guardedInventory.map((item) => ({ stateKey: item.stateKey, revision: item.manifest.revision })),
+      runtime: selected.map((entry) => ({
+        path: entry.path,
+        hash: entry.runtimeHash,
+        snapshotDigest: entry.runtimeSnapshotDigest,
+        ...entry.managedBlock ? { managedBlock: entry.managedBlock } : {}
+      }))
+    } } : {}
   };
-  return { ...withoutDigest, planDigest: createHash22("sha256").update(canonicalJson6(withoutDigest)).digest("hex") };
+  return { ...withoutDigest, planDigest: createHash23("sha256").update(canonicalJson6(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 = resolve39(request.targetRoot);
+  const targetRoot = resolve40(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");
@@ -17385,22 +17935,22 @@ async function normalizeRequest2(request) {
   const scope = await resolveWorkspaceOwnershipScope(request.workspaceRoot, { globalRoot: request.globalRoot });
   const destinationOwner = workspaceOwnerForRoot(scope.root, scope.fleetId);
   const workspaceRoot = await realpath3(request.workspaceRoot);
-  const sourceRoot = resolve39(request.fromWorkspaceRoot);
+  const sourceRoot = resolve40(request.fromWorkspaceRoot);
   const sourceOwner = workspaceOwnerForRoot(sourceRoot);
   let sourceClass;
-  if (sourceRoot === workspaceRoot || sourceRoot === resolve39(request.workspaceRoot)) {
+  if (sourceRoot === workspaceRoot || sourceRoot === resolve40(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 realpath3(sourceRoot).then((path) => [path], () => [])];
-    const workspaceForms = [workspaceRoot, resolve39(request.workspaceRoot), scope.root];
+    const workspaceForms = [workspaceRoot, resolve40(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 = [resolve39(fleet.root), ...await realpath3(fleet.root).then((path) => [path], () => [])];
+      const fleetForms = [resolve40(fleet.root), ...await realpath3(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.`);
       }
@@ -17436,7 +17986,7 @@ async function selectLegacySource(input, stateKey, fingerprint, source, desiredB
     );
   }
   for (const entry of source.entries) {
-    if (entry.workspaceOwner === input.sourceOwner) assertPlainEntry(entry, input.targetRoot);
+    if (entry.workspaceOwner === input.sourceOwner) assertSupportedLegacyEntry(entry, input.targetRoot);
   }
   const entries = [];
   const retained = [];
@@ -17514,20 +18064,21 @@ async function readDestination(identity, stateKey, transport) {
   }
   return requireManifest(identity, stateKey, transport, "destination");
 }
-function assertPlainEntry(entry, targetRoot) {
-  if (entry.mode || entry.mergeStrategy || entry.semanticPlugin || entry.semanticCommand || entry.executed) {
+function assertSupportedLegacyEntry(entry, targetRoot) {
+  const supportedBlock = entry.mode === "managed-block" && entry.kind === "file" && entry.artifactType === "instructions";
+  if (entry.mode && !supportedBlock || 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);
+  return item.artifactType === entry.artifactType && item.artifactName === entry.artifactName && item.kind === entry.kind && (!item.packageName || !entry.packageName || item.packageName === entry.packageName) && (entry.mode !== "managed-block" || item.mode === "managed-block" && managedInstructionSelector(item.logicalSelector, item.artifactType, item.artifactName) === managedInstructionSelector(entry.logicalSelector, entry.artifactType, entry.artifactName));
 }
 function coversSourceEntry(destination, source, owner) {
-  return destination.workspaceOwner === owner && !destination.mode && !destination.mergeStrategy && !destination.semanticPlugin && sameRecordedArtifact(destination, source);
+  return destination.workspaceOwner === owner && destination.mode === source.mode && !destination.mergeStrategy && !destination.semanticPlugin && sameRecordedArtifact(destination, source) && (source.mode !== "managed-block" || entryDigest({ ...destination, workspaceOwner: source.workspaceOwner }) === entryDigest(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;
+  return left.artifactType === right.artifactType && left.artifactName === right.artifactName && left.kind === right.kind && left.hash === right.hash && left.sourceHash === right.sourceHash && left.mode === right.mode && (left.mode !== "managed-block" || managedInstructionSelector(left.logicalSelector, left.artifactType, left.artifactName) === managedInstructionSelector(right.logicalSelector, right.artifactType, right.artifactName));
 }
 async function assertNoPendingJournals(targetRoot, adapter, transport) {
   const pending = await listAllApplyJournals(targetRoot, adapter, transport);
@@ -17549,14 +18100,14 @@ function assertApplyPreconditions2(request) {
   }
 }
 function containsPath2(parent, candidate) {
-  const path = relative16(parent, candidate);
+  const path = relative17(parent, candidate);
   return path === "" || !path.startsWith("..") && !isAbsolute12(path);
 }
 
 // src/version/policy.ts
 import { execFile as execFile7 } from "child_process";
 import { readFile as readFile40 } from "fs/promises";
-import { join as join53, resolve as resolve40 } from "path";
+import { join as join55, resolve as resolve41 } from "path";
 import { promisify as promisify7 } from "util";
 import { parse as parseJsonc } from "jsonc-parser";
 import { z as z15 } from "zod";
@@ -17653,7 +18204,7 @@ async function discoverVersionsFromSource(pkg, workspaceRoot) {
     if (tagged.length > 0) return tagged;
   }
   if (driverName === "local") {
-    const root = resolve40(workspaceRoot, pkg.source);
+    const root = resolve41(workspaceRoot, pkg.source);
     const manifest2 = await readPackageManifest(root);
     const current = manifest2 ? [{ version: manifest2.version, ref: pkg.requestedRef ?? root }] : [];
     try {
@@ -17668,7 +18219,7 @@ async function discoverVersionsFromSource(pkg, workspaceRoot) {
   }
   const driver = getSourceDriver(driverName);
   const resolved = await driver.resolve(pkg.source, {
-    cacheRoot: join53(workspaceRoot, ".agentwheel", "cache"),
+    cacheRoot: join55(workspaceRoot, ".agentwheel", "cache"),
     mode: "tracking",
     ref: pkg.requestedRef
   });
@@ -17762,7 +18313,7 @@ function gitUrlFromSource(source) {
   throw new Error(`Version discovery does not support Git source: ${source}`);
 }
 function versionCachePath(workspaceRoot) {
-  return join53(workspaceRoot, ".agentwheel", "cache", "version-index.json");
+  return join55(workspaceRoot, ".agentwheel", "cache", "version-index.json");
 }
 async function readVersionCache(path) {
   if (!await pathExists(path)) return { schemaVersion: 1, sources: {} };
@@ -17779,7 +18330,7 @@ init_semver();
 // src/profile/members.ts
 import { execFile as execFile8 } from "child_process";
 import { readFile as readFile41 } from "fs/promises";
-import { join as join54, resolve as resolve41 } from "path";
+import { join as join56, resolve as resolve42 } from "path";
 import { promisify as promisify8 } from "util";
 import { z as z17 } from "zod";
 
@@ -17955,7 +18506,7 @@ async function invokeMemberStatus(member, parentWorkspace, chain, options, cliEn
   let stderr = "";
   try {
     if (member.transport === "local") {
-      const workspace = resolve41(parentWorkspace, member.workspace);
+      const workspace = resolve42(parentWorkspace, member.workspace);
       const result = await execFileAsync8(process.execPath, [cliEntry, ...args], {
         cwd: workspace,
         env: env2,
@@ -18001,7 +18552,7 @@ async function runMemberAgentwheel(member, parentWorkspace, args, chain) {
         process.execPath,
         [process.argv[1], ...memberCommandArgs(member, args)],
         {
-          cwd: resolve41(parentWorkspace, member.workspace),
+          cwd: resolve42(parentWorkspace, member.workspace),
           env: env2,
           maxBuffer: 20 * 1024 * 1024
         }
@@ -18081,7 +18632,7 @@ function memberFailure(member, health, error) {
   };
 }
 function memberCachePath(workspaceRoot, profileName, memberId) {
-  return join54(workspaceRoot, ".agentwheel", "cache", "member-status", profileName, `${memberId}.json`);
+  return join56(workspaceRoot, ".agentwheel", "cache", "member-status", profileName, `${memberId}.json`);
 }
 async function readMemberCache(path) {
   if (!await pathExists(path)) return void 0;
@@ -18107,7 +18658,7 @@ function assertNoCompositeCycle(workspaceRoot, profileName, chain) {
   }
 }
 function compositeKey(workspaceRoot, profileName) {
-  return `${resolve41(workspaceRoot)}#${profileName}`;
+  return `${resolve42(workspaceRoot)}#${profileName}`;
 }
 
 // src/status/repository.ts
@@ -18154,10 +18705,10 @@ function valueAfter(lines, prefix) {
 }
 
 // src/catalogue/client.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash24 } from "crypto";
 import { readFile as readFile42, rm as rm15 } from "fs/promises";
 import { homedir as homedir15 } from "os";
-import { join as join55 } from "path";
+import { join as join57 } from "path";
 
 // src/model/catalogue.ts
 import { z as z18 } from "zod";
@@ -18430,18 +18981,18 @@ var CatalogueClient = class {
     }
     return {
       value: schema.parse(value),
-      digest: createHash23("sha256").update(bytes).digest("hex")
+      digest: createHash24("sha256").update(bytes).digest("hex")
     };
   }
 };
 function defaultCatalogueCachePath() {
-  return join55(homedir15(), ".agentwheel", "catalogue-cache.json");
+  return join57(homedir15(), ".agentwheel", "catalogue-cache.json");
 }
 function sameSources2(a, b) {
   return a.length === b.length && a.every((source, index) => source === b[index]);
 }
 function catalogueContentHash(enriched, vercel) {
-  return createHash23("sha256").update(JSON.stringify({ enriched, vercel })).digest("hex");
+  return createHash24("sha256").update(JSON.stringify({ enriched, vercel })).digest("hex");
 }
 
 // src/search/index.ts
@@ -18803,9 +19354,9 @@ function includesToken(normalizedText, token) {
 }
 
 // src/semantic/index.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 import { homedir as homedir16 } from "os";
-import { join as join56 } from "path";
+import { join as join58 } from "path";
 import { env, pipeline } from "@huggingface/transformers";
 var DEFAULT_SEMANTIC_INDEX_URL = "https://raw.githubusercontent.com/NestDevLab/agentwheel-registry/main/catalogue-semantic-index/gte-v1/";
 var CONTRACT = {
@@ -18893,13 +19444,13 @@ 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 = createHash24("sha256").update(bytes).digest("hex");
-    if (digest2 !== descriptor.sha256) throw new Error(`Semantic index checksum does not match: ${descriptor.path}`);
+    const digest3 = createHash25("sha256").update(bytes).digest("hex");
+    if (digest3 !== descriptor.sha256) throw new Error(`Semantic index checksum does not match: ${descriptor.path}`);
     return bytes;
   }
 };
 async function embedQuery(query) {
-  env.cacheDir = join56(homedir16(), ".agentwheel", "semantic-models");
+  env.cacheDir = join58(homedir16(), ".agentwheel", "semantic-models");
   const extractor = await pipeline("feature-extraction", CONTRACT.model.id, {
     revision: CONTRACT.model.revision,
     dtype: CONTRACT.model.dtype,
@@ -18983,9 +19534,10 @@ function ensureTrailingSlash(value) {
 }
 
 // src/trial/skill.ts
-import { createHash as createHash25 } from "crypto";
+init_selection();
+import { createHash as createHash26 } from "crypto";
 import { readFile as readFile43, stat as stat16 } from "fs/promises";
-import { join as join57 } from "path";
+import { join as join59 } from "path";
 import { parse as parseYaml2 } from "yaml";
 var MAX_TRIAL_SKILL_BYTES = 512 * 1024;
 async function createSkillTrial(driver, resolved, selectors) {
@@ -18997,7 +19549,7 @@ async function createSkillTrial(driver, resolved, selectors) {
     throw new Error("Skill trial requires exactly one selected skill. Use --skill <name> or --select skills/<name>.");
   }
   const artifact = skills[0];
-  const path = artifact.kind === "dir" ? join57(artifact.sourcePath, "SKILL.md") : artifact.sourcePath;
+  const path = artifact.kind === "dir" ? join59(artifact.sourcePath, "SKILL.md") : artifact.sourcePath;
   const info = await stat16(path);
   if (info.size > MAX_TRIAL_SKILL_BYTES) {
     throw new Error(`Skill trial exceeds the ${MAX_TRIAL_SKILL_BYTES / 1024} KiB content limit.`);
@@ -19013,7 +19565,7 @@ async function createSkillTrial(driver, resolved, selectors) {
     skill: {
       name: artifact.name,
       relativePath: artifact.relativePath,
-      sha256: createHash25("sha256").update(content).digest("hex"),
+      sha256: createHash26("sha256").update(content).digest("hex"),
       frontmatter,
       content
     }
@@ -19032,10 +19584,10 @@ function readSkillFrontmatter(content, artifact) {
 }
 
 // src/lifecycle/fleet-normalize.ts
-import { createHash as createHash26 } from "crypto";
-import { readFile as readFile44, readdir as readdir15, rm as rm16 } from "fs/promises";
+import { createHash as createHash27 } from "crypto";
+import { readFile as readFile44, readdir as readdir16, rm as rm16 } from "fs/promises";
 import { homedir as homedir17 } from "os";
-import { dirname as dirname36, isAbsolute as isAbsolute13, join as join58, relative as relative17, resolve as resolve42 } from "path";
+import { dirname as dirname36, isAbsolute as isAbsolute13, join as join60, relative as relative18, resolve as resolve43 } from "path";
 init_manifest2();
 init_paths();
 init_merge_removal();
@@ -19071,14 +19623,14 @@ async function planFleetNormalization(request) {
       if (legacySelfNormalization && normalizedRequest.orphanedOwnerRoots?.length && normalizedRequest.packages?.includes(name)) {
         packages.push({
           name,
-          declarationDigest: sha2567(canonicalJson7({ name, evidence: "orphaned-installed-state" }))
+          declarationDigest: sha2567(canonicalJson8({ name, evidence: "orphaned-installed-state" }))
         });
         continue;
       }
       throw new Error(`Package '${name}' must be an existing duplicate in both source and destination fleets.`);
     }
-    const sourceDeclaration = canonicalJson7(sourcePackage);
-    const destinationDeclaration = canonicalJson7(destinationPackage);
+    const sourceDeclaration = canonicalJson8(sourcePackage);
+    const destinationDeclaration = canonicalJson8(destinationPackage);
     if (sourceDeclaration !== destinationDeclaration) {
       throw new Error(
         `Package '${name}' has divergent declarations. Source, driver, adapter, adapter configuration, installation type, version policy, runtime restrictions, selections, aliases, overrides, and suggestions must match before normalization.`
@@ -19115,7 +19667,7 @@ async function planFleetNormalization(request) {
     packages,
     installedState
   };
-  return { ...planWithoutDigest, planDigest: sha2567(canonicalJson7(planWithoutDigest)) };
+  return { ...planWithoutDigest, planDigest: sha2567(canonicalJson8(planWithoutDigest)) };
 }
 async function applyFleetNormalization(request, hooks = {}) {
   if (!request.apply) throw new Error("Fleet normalization is dry-run by default; pass --apply with --plan-digest <digest>.");
@@ -19253,8 +19805,8 @@ async function assertNormalizationPostconditions(journal) {
   }
   for (const graphLock of journal.graphLocks) {
     const raw = await readOptionalRecord(graphLock.path);
-    const digest2 = raw ? sha2567(canonicalJson7(await readGraphLock(graphLock.path))) : null;
-    if (digest2 !== graphLock.afterDigest) {
+    const digest3 = raw ? sha2567(canonicalJson8(await readGraphLock(graphLock.path))) : null;
+    if (digest3 !== graphLock.afterDigest) {
       throw new Error(`Fleet normalization graph-lock postcheck failed: ${graphLock.path}`);
     }
   }
@@ -19325,17 +19877,17 @@ function normalizeRequest3(request) {
     ...profile ? { profile } : {},
     ...agent ? { agent } : {},
     ...orphanedOwnerRoots ? { orphanedOwnerRoots } : {},
-    ...request.globalRoot ? { globalRoot: resolve42(request.globalRoot) } : {}
+    ...request.globalRoot ? { globalRoot: resolve43(request.globalRoot) } : {}
   };
 }
 function normalizeOrphanedOwnerRoot(value) {
   const root = value.trim();
   if (!root || !isAbsolute13(root)) throw new Error(`Invalid orphaned owner root '${value}'; expected an absolute workspace path.`);
-  return resolve42(root);
+  return resolve43(root);
 }
 async function normalizationRoots(request) {
   const destination = await showRegisteredFleet(request.destinationFleet, { globalRoot: request.globalRoot });
-  const source = request.from === "user" ? resolve42(request.globalRoot ?? homedir17()) : (await showRegisteredFleet(request.from.slice("fleet:".length), { globalRoot: request.globalRoot })).root;
+  const source = request.from === "user" ? resolve43(request.globalRoot ?? homedir17()) : (await showRegisteredFleet(request.from.slice("fleet:".length), { globalRoot: request.globalRoot })).root;
   return { source, destination: destination.root };
 }
 async function withOrderedLocks(roots, fn) {
@@ -19343,7 +19895,7 @@ async function withOrderedLocks(roots, fn) {
     if (index === roots.length) return fn();
     const root = roots[index];
     return withFilesystemLock(
-      join58(root, ".agentwheel", "fleet-normalize.lock"),
+      join60(root, ".agentwheel", "fleet-normalize.lock"),
       5e3,
       () => run(index + 1),
       "fleet normalization"
@@ -19442,10 +19994,10 @@ async function inspectInstalledState(source, destination, packageNames) {
     const destinationGraphAfter = destinationGraph?.lock ?? destinationGraphFromSource(sourceGraph.lock, destinationState.targetFingerprint);
     graphTransfers.push({
       sourceGraphLockPath: sourceGraph.path,
-      sourceGraphLockDigest: sha2567(canonicalJson7(sourceGraph.lock)),
+      sourceGraphLockDigest: sha2567(canonicalJson8(sourceGraph.lock)),
       destinationGraphLockPath: destinationState.graphLockPath,
-      destinationGraphLockDigest: destinationGraph ? sha2567(canonicalJson7(destinationGraph.lock)) : null,
-      destinationGraphLockAfterDigest: sha2567(canonicalJson7(destinationGraphAfter)),
+      destinationGraphLockDigest: destinationGraph ? sha2567(canonicalJson8(destinationGraph.lock)) : null,
+      destinationGraphLockAfterDigest: sha2567(canonicalJson8(destinationGraphAfter)),
       targetKey: sourceGraph.targetKey,
       adapter: destinationState.adapter,
       targetFingerprint: destinationState.targetFingerprint
@@ -19550,7 +20102,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 (resolve42(destinationState.graphLockPath) === resolve42(graph.path)) {
+    if (resolve43(destinationState.graphLockPath) === resolve43(graph.path)) {
       const destinationManifest = (await collectManifestPaths([destinationState.manifestPath]))[0];
       if (destinationManifest?.manifest.entries.some((entry) => entry.workspaceOwner === fleetOwner && entryMatchesPackages(entry, selected))) {
         assertCorrelatedGraphManifest(
@@ -19565,7 +20117,7 @@ async function inspectLegacySelfInstalledState(fleet, packageNames, profileName,
       }
     }
     const legacyState = await legacyTargetStateForGraph(fleet, graph, allowOrphanedRetiredPackages);
-    if (resolve42(legacyState.graphLockPath) !== resolve42(graph.path)) {
+    if (resolve43(legacyState.graphLockPath) !== resolve43(graph.path)) {
       throw new Error(`Legacy graph lock target identity is stale or noncanonical: ${graph.path}`);
     }
     const legacyManifest = (await collectManifestPaths([legacyState.manifestPath]))[0];
@@ -19673,7 +20225,7 @@ async function inspectLegacySelfInstalledState(fleet, packageNames, profileName,
       )
     });
     if (!selectedArtifacts) {
-      const fullDigest = sha2567(canonicalJson7(graph.lock));
+      const fullDigest = sha2567(canonicalJson8(graph.lock));
       const existingDestinationGraph = graphCandidates.find((candidate) => candidate.path === destinationState.graphLockPath);
       if (existingDestinationGraph) assertGraphIsSubset(graph, existingDestinationGraph);
       const destinationGraph = destinationGraphFromSource(graph.lock, destinationState.targetFingerprint);
@@ -19681,8 +20233,8 @@ async function inspectLegacySelfInstalledState(fleet, packageNames, profileName,
         sourceGraphLockPath: graph.path,
         sourceGraphLockDigest: fullDigest,
         destinationGraphLockPath: destinationState.graphLockPath,
-        destinationGraphLockDigest: existingDestinationGraph ? sha2567(canonicalJson7(existingDestinationGraph.lock)) : null,
-        destinationGraphLockAfterDigest: sha2567(canonicalJson7(destinationGraph)),
+        destinationGraphLockDigest: existingDestinationGraph ? sha2567(canonicalJson8(existingDestinationGraph.lock)) : null,
+        destinationGraphLockAfterDigest: sha2567(canonicalJson8(destinationGraph)),
         targetKey: graph.targetKey,
         adapter: graph.adapter,
         targetFingerprint: destinationState.targetFingerprint
@@ -19740,7 +20292,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(resolve42(process.env.AGENTWHEEL_TEST_HOME || process.env.HOME || homedir17()));
+    roots.add(resolve43(process.env.AGENTWHEEL_TEST_HOME || process.env.HOME || homedir17()));
   }
   for (const [name, agent] of Object.entries(scope.config.agents)) {
     if (agent.transport === "ssh" || agent.transport === "local-run-as") throw new Error(`Installed-state normalization cannot inspect ${agent.transport} agent '${name}' locally.`);
@@ -19758,17 +20310,17 @@ async function runtimeRoots(scope) {
 async function collectManifests(roots) {
   const found = /* @__PURE__ */ new Map();
   for (const root of roots) {
-    const dir = join58(root, ".agentwheel");
+    const dir = join60(root, ".agentwheel");
     let names;
     try {
-      names = await readdir15(dir);
+      names = await readdir16(dir);
     } catch (error) {
       if (isMissing5(error)) continue;
       throw error;
     }
     for (const name of names.sort((a, b) => a.localeCompare(b))) {
       if (!name.endsWith(".install-manifest.json")) continue;
-      const path = join58(dir, name);
+      const path = join60(dir, name);
       const raw = JSON.parse(await readFile44(path, "utf8"));
       const parsed = installManifestSchema.parse(raw);
       if (parsed.version !== 2) {
@@ -19777,14 +20329,14 @@ async function collectManifests(roots) {
         }
         continue;
       }
-      if (resolve42(parsed.targetRoot) !== resolve42(root)) {
+      if (resolve43(parsed.targetRoot) !== resolve43(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 (resolve42(expectedPath) !== resolve42(path)) {
+      if (resolve43(expectedPath) !== resolve43(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 } });
@@ -19805,7 +20357,7 @@ async function collectManifestPaths(paths) {
       installationType: parsed.installationType,
       stateKey: parsed.stateKey
     });
-    if (resolve42(expectedPath) !== resolve42(path)) {
+    if (resolve43(expectedPath) !== resolve43(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 } });
@@ -19824,14 +20376,14 @@ function assertNoForeignSamePathOwnership(manifests, renderedPaths, allowedOwner
   }
 }
 async function relevantGraphLocks(workspaceRoot, selected, targetKeys, include) {
-  const root = join58(workspaceRoot, ".agentwheel", "locks");
+  const root = join60(workspaceRoot, ".agentwheel", "locks");
   if (!await pathExists(root)) return [];
   const results = [];
   for (const path of await listFiles(root)) {
     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 = relative17(root, path).split(/[\\/]/);
+    const parts = relative18(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;
@@ -19848,7 +20400,7 @@ async function relevantGraphLocks(workspaceRoot, selected, targetKeys, include)
     const projection = relevantGraphProjection(lock, selected);
     results.push({
       ...candidate,
-      digest: sha2567(canonicalJson7(projection)),
+      digest: sha2567(canonicalJson8(projection)),
       artifactIdentities: lock.canonical.artifacts.filter((artifact) => artifact.owners.some((owner) => ownerMatchesGraphPackage(lock, owner, selected))).map(graphArtifactIdentity).sort()
     });
   }
@@ -19873,7 +20425,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 (resolve42(stableState.graphLockPath) !== resolve42(graph.path)) return false;
+  if (resolve43(stableState.graphLockPath) !== resolve43(graph.path)) return false;
   const stableManifest = (await collectManifestPaths([stableState.manifestPath]))[0];
   return stableManifest?.manifest.entries.some((entry) => entryMatchesGraphPackages(entry, graph.lock, selected)) ?? false;
 }
@@ -19894,7 +20446,7 @@ async function legacyManifestPathForConfiguredTarget(scope, graph) {
     baseDir: scope.root
   });
   const targetRoot = resolveConfigPath(agent.root, scope.root);
-  const installRoot = resolve42(installRootForAdapterInstallationType(adapter, targetRoot, agent.installationType, { kind: "local" }));
+  const installRoot = resolve43(installRootForAdapterInstallationType(adapter, targetRoot, agent.installationType, { kind: "local" }));
   const stateKey = stateKeyFor(adapter.name, {
     installationType: agent.installationType,
     stateKey: agent.stateKey,
@@ -19962,7 +20514,7 @@ async function targetStateForGraph(scope, graph, identityFleetId = scope.fleetId
     ssh: void 0,
     ...agent?.stateKey ? { stateKey: agent.stateKey } : {}
   };
-  const installRoot = resolve42(installRootForAdapterInstallationType(adapter, targetRoot, installationType, { kind: "local" }));
+  const installRoot = resolve43(installRootForAdapterInstallationType(adapter, targetRoot, installationType, { kind: "local" }));
   const targetIdentity = resolveTargetStateIdentity({
     targetFingerprintParts: fingerprintParts,
     workspaceRoot: scope.root,
@@ -19994,16 +20546,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 (resolve42(graph.path) === resolve42(stable.graphLockPath)) {
+  if (resolve43(graph.path) === resolve43(stable.graphLockPath)) {
     state = stable;
   } else {
     const released = await releasedTargetStateForGraph(scope, graph, identityFleetId);
-    if (resolve42(graph.path) !== resolve42(released.graphLockPath)) {
+    if (resolve43(graph.path) !== resolve43(released.graphLockPath)) {
       throw new Error(`Graph lock target identity is stale or noncanonical: ${graph.path}`);
     }
     state = released;
   }
-  const manifest = manifests.find((candidate) => resolve42(candidate.path) === resolve42(state.manifestPath));
+  const manifest = manifests.find((candidate) => resolve43(candidate.path) === resolve43(state.manifestPath));
   if (!manifest) {
     throw new Error(`Graph lock is not covered by its canonical install manifest: ${state.manifestPath}`);
   }
@@ -20027,7 +20579,7 @@ async function releasedTargetStateForGraph(scope, graph, identityFleetId = scope
     ...current,
     stateKey,
     targetFingerprint,
-    graphLockPath: join58(dirname36(graph.path), `${targetFingerprint}.graph-lock.json`),
+    graphLockPath: join60(dirname36(graph.path), `${targetFingerprint}.graph-lock.json`),
     manifestPath: installManifestPath(current.installRoot, current.adapter, {
       installationType: current.installationType,
       stateKey
@@ -20035,7 +20587,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 || resolve42(manifest.manifest.targetRoot) !== resolve42(state.installRoot)) {
+  if (manifest.manifest.adapter !== state.adapter || manifest.manifest.installationType !== state.installationType || manifest.manifest.stateKey !== state.stateKey || resolve43(manifest.manifest.targetRoot) !== resolve43(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));
@@ -20043,7 +20595,7 @@ function assertCorrelatedGraphManifest(graph, state, manifest, owners, selected)
     throw new Error(`Graph lock is not covered by selected install-manifest contributions: ${graph.path}`);
   }
   const graphArtifacts = new Set(graph.artifactIdentities);
-  const graphLockDigest = sha2567(canonicalJson7(graph.lock));
+  const graphLockDigest = sha2567(canonicalJson8(graph.lock));
   for (const entry of entries) {
     if (!owners.has(entry.workspaceOwner)) {
       throw new Error(`Graph lock manifest owner mismatch at ${manifest.path}: ${entry.workspaceOwner}.`);
@@ -20060,9 +20612,9 @@ async function legacyTargetStateForGraph(scope, graph, allowMissingNamedAgentPac
   return releasedTargetStateForGraph(scope, graph, null, allowMissingNamedAgentPackages);
 }
 function assertGraphIsSubset(source, destination) {
-  const sourceRoots = new Map(source.lock.canonical.roots.map((root) => [root.rootId, canonicalJson7(root)]));
+  const sourceRoots = new Map(source.lock.canonical.roots.map((root) => [root.rootId, canonicalJson8(root)]));
   for (const root of destination.lock.canonical.roots) {
-    if (sourceRoots.get(root.rootId) !== canonicalJson7(root)) {
+    if (sourceRoots.get(root.rootId) !== canonicalJson8(root)) {
       throw new Error(
         `Partially normalized destination graph diverges at root '${root.rootId}': ${destination.path}`
       );
@@ -20092,7 +20644,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 || resolve42(manifest2.targetRoot) !== state.installRoot) {
+    if (manifest2.adapter !== state.adapter || manifest2.installationType !== state.installationType || manifest2.stateKey !== state.stateKey || resolve43(manifest2.targetRoot) !== state.installRoot) {
       throw new Error(`Destination manifest identity diverges from the derived target: ${existing.path}`);
     }
   }
@@ -20152,7 +20704,7 @@ async function assertEquivalentRuntimeState(entry, sourcePath, destinationPath)
       const content = await readFile44(path, "utf8");
       if (hasMergeRemovalContent(entry.mergeRemoval)) {
         assertExactMergeContribution(entry.mergeRemoval, entry.mergeStrategy, content);
-      } else if (resolve42(sourcePath) === resolve42(destinationPath) && entry.mergeStrategy !== "codex-toml-mcp") {
+      } else if (resolve43(sourcePath) === resolve43(destinationPath) && entry.mergeStrategy !== "codex-toml-mcp") {
         assertExactMergeContribution({}, entry.mergeStrategy, content);
       } else {
         throw new Error(`Installed-state normalization cannot prove incomplete merge ownership at ${path}.`);
@@ -20163,8 +20715,8 @@ async function assertEquivalentRuntimeState(entry, sourcePath, destinationPath)
   await assertEquivalentRuntimeBytes(sourcePath, destinationPath, entry.hash);
 }
 function renderedEntryPathForRoot(root, entryPath) {
-  const normalizedRoot = resolve42(root);
-  const candidate = resolve42(normalizedRoot, entryPath);
+  const normalizedRoot = resolve43(root);
+  const candidate = resolve43(normalizedRoot, entryPath);
   if (candidate !== normalizedRoot && !candidate.startsWith(`${normalizedRoot}/`)) {
     throw new Error(`Install manifest entry escapes its target root: ${entryPath}`);
   }
@@ -20255,8 +20807,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 = resolve42(manifest.targetRoot);
-  const candidate = resolve42(root, entry.path);
+  const root = resolve43(manifest.targetRoot);
+  const candidate = resolve43(root, entry.path);
   if (candidate !== root && !candidate.startsWith(`${root}/`)) {
     throw new Error(`Install manifest entry escapes its target root: ${entry.path}`);
   }
@@ -20275,7 +20827,7 @@ function assertSimpleVerifiableEntry(entry, path) {
   if (entry.kind !== "file" && entry.kind !== "dir") throw new Error(`Unsupported installed entry kind at ${path}.`);
 }
 function entryIdentity(entry) {
-  return canonicalJson7({
+  return canonicalJson8({
     path: entry.path,
     artifactType: entry.artifactType,
     artifactName: entry.artifactName,
@@ -20293,7 +20845,7 @@ function entryIdentity(entry) {
   });
 }
 function graphArtifactIdentity(artifact) {
-  return canonicalJson7({
+  return canonicalJson8({
     graphNodeId: artifact.graphNodeId,
     type: artifact.type,
     name: artifact.name,
@@ -20307,7 +20859,7 @@ function graphArtifactIdentity(artifact) {
   });
 }
 function graphEntryIdentity(entry) {
-  return canonicalJson7({
+  return canonicalJson8({
     graphNodeId: entry.graphNodeId,
     type: entry.artifactType,
     name: entry.artifactName,
@@ -20411,7 +20963,7 @@ async function buildJournalGraphLockStates(plan) {
   for (const transfer of plan.installedState.graphTransfers) {
     const sourceBefore = JSON.parse(await readFile44(transfer.sourceGraphLockPath, "utf8"));
     const sourceLock = await readGraphLock(transfer.sourceGraphLockPath);
-    const sourceDigest = sha2567(canonicalJson7(sourceLock));
+    const sourceDigest = sha2567(canonicalJson8(sourceLock));
     if (sourceDigest !== transfer.sourceGraphLockDigest) {
       throw new Error(`Source graph lock changed after planning: ${transfer.sourceGraphLockPath}`);
     }
@@ -20429,9 +20981,9 @@ async function buildJournalGraphLockStates(plan) {
       continue;
     }
     const destinationBefore = await readOptionalRecord(transfer.destinationGraphLockPath);
-    const destinationBeforeDigest = destinationBefore ? sha2567(canonicalJson7(await readGraphLock(transfer.destinationGraphLockPath))) : null;
+    const destinationBeforeDigest = destinationBefore ? sha2567(canonicalJson8(await readGraphLock(transfer.destinationGraphLockPath))) : null;
     const destinationAfter = destinationBefore ? await readGraphLock(transfer.destinationGraphLockPath) : destinationGraphFromSource(sourceLock, transfer.targetFingerprint);
-    const destinationAfterDigest = sha2567(canonicalJson7(destinationAfter));
+    const destinationAfterDigest = sha2567(canonicalJson8(destinationAfter));
     if (destinationBeforeDigest !== transfer.destinationGraphLockDigest || destinationAfterDigest !== transfer.destinationGraphLockAfterDigest) {
       throw new Error(`Destination graph lock changed after planning: ${transfer.destinationGraphLockPath}`);
     }
@@ -20541,8 +21093,8 @@ async function assertJournalRecoverable(journal) {
   }
   for (const graphLock of journal.graphLocks) {
     const raw = await readOptionalRecord(graphLock.path);
-    const digest2 = raw ? sha2567(canonicalJson7(await readGraphLock(graphLock.path))) : null;
-    if (digest2 !== graphLock.beforeDigest && digest2 !== graphLock.afterDigest) {
+    const digest3 = raw ? sha2567(canonicalJson8(await readGraphLock(graphLock.path))) : null;
+    if (digest3 !== graphLock.beforeDigest && digest3 !== graphLock.afterDigest) {
       throw new Error(`Cannot recover fleet normalization because graph lock changed outside the transaction: ${graphLock.path}`);
     }
   }
@@ -20594,12 +21146,12 @@ function packageMap(config) {
   return result;
 }
 function configRevision(config) {
-  return sha2567(canonicalJson7(config));
+  return sha2567(canonicalJson8(config));
 }
 function normalizationJournalPath(sourceRoot, destinationFleet) {
-  return join58(sourceRoot, ".agentwheel", `fleet-normalize-${destinationFleet}.journal.json`);
+  return join60(sourceRoot, ".agentwheel", `fleet-normalize-${destinationFleet}.journal.json`);
 }
-function canonicalJson7(value) {
+function canonicalJson8(value) {
   return JSON.stringify(sortValue(value));
 }
 function sortValue(value) {
@@ -20610,7 +21162,7 @@ function sortValue(value) {
   return value;
 }
 function sha2567(value) {
-  return createHash26("sha256").update(value).digest("hex");
+  return createHash27("sha256").update(value).digest("hex");
 }
 function assertDigest(value) {
   if (!/^[a-f0-9]{64}$/.test(value)) throw new Error(`Invalid plan digest: ${value}`);
@@ -20633,6 +21185,7 @@ var commandGovernance = {
   "fleet normalize": "governed-apply-or-recover",
   "cache prune": "governed-apply",
   add: "governed-always",
+  pin: "governed-always",
   list: "incidental-cache",
   search: "incidental-cache",
   try: "incidental-cache",
@@ -20655,6 +21208,7 @@ var commandGovernance = {
   "ownership handoff": "governed-unless-dry-run",
   "ownership recovery-plan": "incidental-cache",
   "ownership retire-stale": "governed-apply",
+  "ownership release-claim": "governed-apply",
   "ownership adopt-legacy": "governed-apply",
   "mcp retire": "governed-apply",
   eject: "governed-always",
@@ -20688,6 +21242,7 @@ function requiresCleanMutationPreflight(path) {
     "init",
     "fleet register",
     "add",
+    "pin",
     "package migrate",
     "remember",
     "journal abort"
@@ -20761,25 +21316,34 @@ fleetCommand.command("normalize").description("plan or apply duplicate desired-s
 });
 cacheCommand.command("prune").description("remove old Git source snapshots while preserving locked commits").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 workspace root").option("--keep <count>", "newest snapshots to retain per source", parsePositiveInteger, 3).option("--apply", "delete the selected snapshots; without this flag only preview", false).action(async (options) => {
   const targetRoot = await workspaceContextRootFromOptions(normalizeRuntimeScopeOptions(options));
-  const cacheRoot = join59(targetRoot, ".agentwheel", "cache");
+  const cacheRoot = join61(targetRoot, ".agentwheel", "cache");
   const result = await pruneGitCache(cacheRoot, { keepSnapshots: options.keep, dryRun: !options.apply });
   const verb = options.apply ? "Removed" : "Would remove";
   for (const path of result.removedPaths) console.log(`${verb} ${path}`);
   console.log(`${options.apply ? "Pruned" : "Preview"}: ${result.removedPaths.length} snapshots; retained ${result.retainedPaths.length}.`);
 });
-program.command("add").description("add a package to .agentwheel/config.json without touching runtimes").argument("<source>", "package source").option("--driver <driver>", "source driver (local, git, skillkit, vercel-skills, mcp-registry, or clawhub)").option("--adapter <adapter>", "built-in adapter", "openclaw").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>", "workspace root").option("--mode <mode>", "pinned or tracking", "pinned").option("--version <range>", "root package version policy (exact, ~, ^, or *)").option("--name <name>", "package alias").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots on future installs", false).option("--suggestion <alias>", "include one suggested companion alias on future installs (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "allow this package to replace a colliding artifact (repeatable)", collectOverrideOption, []).action(async (source, options) => {
+program.command("add").description("add a package to .agentwheel/config.json without touching runtimes").argument("<source>", "package source").option("--driver <driver>", "source driver (local, git, skillkit, vercel-skills, mcp-registry, or clawhub)").option("--adapter <adapter>", "built-in adapter", "openclaw").option("--runtimes <adapters>", "restrict package runtimes (repeatable or comma-separated)", collectSelectOption, []).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>", "workspace root").option("--mode <mode>", "pinned or tracking", "pinned").option("--version <range>", "root package version policy (exact, ~, ^, or *)").option("--name <name>", "package alias").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots on future installs", false).option("--suggestion <alias>", "include one suggested companion alias on future installs (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "allow this package to replace a colliding artifact (repeatable)", collectOverrideOption, []).action(async (source, options) => {
   const normalizedOptions = normalizeRuntimeScopeOptions(options);
   const targetRoot = await workspaceRootFromOptions(normalizedOptions);
   const entry = await packageEntryFromSource(source, targetRoot, normalizedOptions);
   await writeWorkspaceConfig(targetRoot, upsertPackage(await readWorkspaceConfig(targetRoot), entry));
   console.log(`Added ${entry.name}. Preview: agentwheel plan - Apply: agentwheel install`);
 });
+program.command("pin").description("pin configured package aliases without resolving sources or touching runtimes").argument("[alias]", "exact configured package alias").argument("[commit]", "exact 40-hex commit SHA").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 workspace root").option("--pins-file <path>", "JSON array of {alias, commit, select?} pins in one mutation").option("--select <type/name>", "replace the complete selection (repeatable or comma-separated)", collectSelectOption).action(async (alias, commit, options) => {
+  const workspaceRoot = await workspaceRootFromOptions(normalizeRuntimeScopeOptions(options));
+  if (options.pinsFile ? alias !== void 0 || commit !== void 0 || options.select !== void 0 : !alias || !commit) {
+    throw new Error("Choose pin <alias> <commit> [--select ...] or pin --pins-file <path>, exclusively.");
+  }
+  const pins = options.pinsFile ? JSON.parse(await readFile45(resolve44(options.pinsFile), "utf8")) : [{ alias, commit, ...options.select === void 0 ? {} : { select: options.select } }];
+  await pinConfiguredPackages(workspaceRoot, pins);
+  console.log("Pinned configured package revisions. Preview: agentwheel plan - Apply: agentwheel install");
+});
 program.command("list").description("list artifacts exposed by a package source").argument("<source>", "package source").option("--driver <driver>", "source driver").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 workspace root").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).action(async (source, options) => {
   const targetRoot = await workspaceContextRootFromOptions(normalizeRuntimeScopeOptions(options));
   const resolvedInput = await resolvePackageSource(source, targetRoot);
   const selectedArtifacts = selectedArtifactsFromOptionsOrRegistry(options, resolvedInput.registryEntry);
   const driver = getSourceDriver(options.driver ?? inferSourceDriverName(resolvedInput.source));
-  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join59(targetRoot, ".agentwheel", "cache") }))));
+  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join61(targetRoot, ".agentwheel", "cache") }))));
   try {
     const artifacts = filterArtifactsBySelection(await driver.list(resolved), selectedArtifacts);
     for (const artifact of artifacts) {
@@ -20848,7 +21412,7 @@ program.command("try").description("read and validate one skill for the current
   const resolvedInput = await resolvePackageSource(source, targetRoot);
   const driver = getSourceDriver(options.driver ?? inferSourceDriverName(resolvedInput.source));
   const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, {
-    cacheRoot: join59(targetRoot, ".agentwheel", "cache")
+    cacheRoot: join61(targetRoot, ".agentwheel", "cache")
   }))));
   try {
     const trial = await createSkillTrial(driver, resolved, selectedArtifactsFromOptionsOrRegistry(options, resolvedInput.registryEntry));
@@ -20870,7 +21434,7 @@ program.command("scan").description("scan a package source for validation findin
   const targetRoot = await workspaceContextRootFromOptions(normalizeRuntimeScopeOptions(options));
   const resolvedInput = await resolvePackageSource(source, targetRoot);
   const driver = getSourceDriver(options.driver ?? inferSourceDriverName(resolvedInput.source));
-  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join59(targetRoot, ".agentwheel", "cache") }))));
+  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join61(targetRoot, ".agentwheel", "cache") }))));
   try {
     const result = await driver.scan(resolved);
     if (result.findings.length === 0) {
@@ -20885,10 +21449,10 @@ program.command("scan").description("scan a package source for validation findin
     await releaseGitSnapshotLease(resolved.cacheLeasePath);
   }
 });
-program.command("plan").description("preview what install would reconcile without writing").argument("[name-or-source]", "configured package name/source or package source to preview").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").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("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--profile <name>", "workspace runtime profile").option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "for source previews, allow the source to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--dry-run", "accepted for symmetry; plan never writes", false).option("--format <fmt>", "output format: human|json|mermaid|html", "human").option("--json", "print the resolved plan as JSON", false).option("--force-drift", "replace drifted managed artifacts during install planning", false).option("--force-foreign-state", "plan even when another workspace owns install state at the same paths", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--recover-legacy-state", "build a stable state while preserving invalid legacy candidates", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "exclude unrelated configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--refresh", "refresh available package versions even when the version-index TTL is fresh", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).action(async (source, options) => {
+program.command("plan").description("preview what install would reconcile without writing").argument("[name-or-source]", "configured package name/source or package source to preview").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").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("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--profile <name>", "workspace runtime profile").option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "for source previews, allow the source to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--dry-run", "accepted for symmetry; plan never writes", false).option("--adopt", "adopt unmanaged destinations; managed drift and foreign ownership remain protected", false).option("--format <fmt>", "output format: human|json|mermaid|html", "human").option("--json", "print the resolved plan as JSON", false).option("--force-drift", "replace drifted managed artifacts during install planning", false).option("--force-foreign-state", "plan even when another workspace owns install state at the same paths", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--recover-legacy-state", "build a stable state while preserving invalid legacy candidates", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "exclude unrelated configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--refresh", "refresh available package versions even when the version-index TTL is fresh", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).action(async (source, options) => {
   await runInstallCommand(source, { ...options, dryRun: true }, { apply: false });
 });
-program.command("install").description("install configured packages into runtime targets").argument("[name-or-source]", "configured package name/source or package source to add and install").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").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("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "when adding a source, allow it to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--profile <name>", "workspace runtime profile").option("--dry-run", "show plan without writing", false).option("--format <fmt>", "output format: human|json|mermaid|html", "human").option("--json", "print the resolved plan as JSON", false).option("--force-drift", "replace drifted managed artifacts", false).option("--force-foreign-state", "plan even when another workspace owns install state at the same paths", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--recover-legacy-state", "build a stable state while preserving invalid legacy candidates", false).option("--execute-plugins", "execute semantic plugin installs", false).option("--reload-runtimes", "run configured runtime reload commands after executed semantic plugin changes", false).option("--restart-runtimes", "alias for --reload-runtimes", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "exclude unrelated configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--refresh", "refresh available package versions even when the version-index TTL is fresh", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).addHelpText("after", "\nScoped install never removes files owned only by other configured packages; run a full install to reconcile those removals.\n").action(async (source, options) => {
+program.command("install").description("install configured packages into runtime targets").argument("[name-or-source]", "configured package name/source or package source to add and install").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").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("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "when adding a source, allow it to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--profile <name>", "workspace runtime profile").option("--dry-run", "show plan without writing", false).option("--adopt", "adopt unmanaged destinations; managed drift and foreign ownership remain protected", false).option("--format <fmt>", "output format: human|json|mermaid|html", "human").option("--json", "print the resolved plan as JSON", false).option("--force-drift", "replace drifted managed artifacts", false).option("--force-foreign-state", "plan even when another workspace owns install state at the same paths", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--recover-legacy-state", "build a stable state while preserving invalid legacy candidates", false).option("--execute-plugins", "execute semantic plugin installs", false).option("--reload-runtimes", "run configured runtime reload commands after executed semantic plugin changes", false).option("--restart-runtimes", "alias for --reload-runtimes", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "exclude unrelated configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--refresh", "refresh available package versions even when the version-index TTL is fresh", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).addHelpText("after", "\nScoped install never removes files owned only by other configured packages; run a full install to reconcile those removals.\n").action(async (source, options) => {
   await runInstallCommand(source, options, { apply: !options.dryRun });
 });
 program.command("serve").description("serve a read-only live dashboard for the resolved install plan").argument("[name-or-source]", "configured package name/source or package source to preview").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").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("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--profile <name>", "workspace runtime profile").option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "for source previews, allow the source to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--force-drift", "replace drifted managed artifacts during install planning", false).option("--force-foreign-state", "plan even when another workspace owns install state at the same paths", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "exclude unrelated configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--refresh", "refresh available package versions even when the version-index TTL is fresh", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).option("--bind <addr>", "interface to bind", "127.0.0.1").option("--port <n>", "TCP port (0 selects an ephemeral port)", "8765").option("--interval <seconds>", "background re-render cadence in seconds", "60").option("--once", "render once and skip the background re-render loop", false).action(async (source, options) => {
@@ -21051,6 +21615,48 @@ 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("release-claim").description("release one exact plain ownership claim while preserving runtime bytes and package declarations").argument("<selector>", "exact artifact selector in type/name form").requiredOption("--path <relative-path>", "exact owned runtime path from the install manifest").requiredOption("--state-key <key>", "exact source install-manifest state key").requiredOption("--from-workspace-root <path>", "exact current workspace owner root").option("--from-fleet-id <id>", "qualify the recorded owner with its Fleet id").option("--fleet <id>", "governing registered Fleet workspace").option("--user", "use the user workspace", false).option("--local", "use the nearest local workspace", false).option("--adapter <adapter>", "built-in adapter").option("--adapter-config <path>", "adapter JSON/JSONC file").option("-i, --installation-type <type>", "exact installation type").option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "configured agent resolving to one local target").option("--profile <name>", "profile resolving to one local 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-inventory-revision <sha256>", "reviewed manifest inventory revision; required with --apply").option("--apply", "apply the exact reviewed metadata-only release", false).option("--json", "print the complete plan or result as JSON", false).action(async (selector, _options, command) => {
+  const options = command.optsWithGlobals();
+  if (!options.reason) throw new Error("Ownership release requires --reason <why> for planning and applying.");
+  const normalized = normalizeRuntimeScopeOptions(options);
+  const targets = await resolveCliTargets(normalized);
+  if (targets.length !== 1) throw new Error("Ownership release requires exactly one target.");
+  const target = targets[0];
+  const adapterOptions = adapterOptionsForTarget(target, normalized);
+  const adapter = await resolveAdapterForTarget(target, adapterOptions);
+  const installationType = normalized.installationType ?? target.installationType ?? resolveInstallationTypeForAdapter(adapter);
+  const state = installStateForTarget(target, adapter, adapterOptions, installationType);
+  const request = {
+    workspaceRoot: await workspaceRootFromOptions(normalized),
+    fromWorkspaceRoot: normalizeCliPath(options.fromWorkspaceRoot),
+    fromFleetId: options.fromFleetId,
+    targetRoot: state.installRoot,
+    adapter: adapter.name,
+    installationType,
+    stateKey: options.stateKey,
+    selector,
+    path: options.path,
+    reason: options.reason,
+    planDigest: options.planDigest,
+    expectedSourceRevision: options.expectedSourceRevision,
+    expectedInventoryRevision: options.expectedInventoryRevision,
+    operationId: options.operationId,
+    noCommit: options.commit === false,
+    transport: transportForTarget(target)
+  };
+  const result = options.apply ? await applyReleaseOwnership(request) : await planReleaseOwnership(request);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`${options.apply ? "Released ownership claim" : "Ownership release plan"}: ${result.selector} at ${result.path}`);
+  console.log(`Owner: ${result.owner}`);
+  console.log(`Source: ${result.source.stateKey} revision ${result.source.revision}`);
+  console.log(`Recorded hash: ${result.recordedHash}; actual runtime hash: ${result.runtimeHash}`);
+  console.log(`Inventory revision: ${result.manifestInventoryRevision}`);
+  console.log(`Plan digest: ${result.planDigest}`);
+  if (!options.apply) console.log("Apply with this same scope and reason plus --apply --plan-digest, --expected-source-revision and --expected-inventory-revision from this plan.");
+});
 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.");
@@ -21078,7 +21684,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 (resolve43(fleet.root) !== resolve43(toWorkspaceRoot)) {
+    if (resolve44(fleet.root) !== resolve44(toWorkspaceRoot)) {
       throw new Error(`Destination fleet '${options.toFleet}' is registered at ${fleet.root}, not ${toWorkspaceRoot}.`);
     }
   }
@@ -21119,8 +21725,8 @@ 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 = join59(await realpath4(dirname37(requestedReport)), basename24(requestedReport));
-  const reportInsideTarget = relative18(resolve43(target.targetRoot), reportPath);
+  const reportPath = join61(await realpath4(dirname37(requestedReport)), basename24(requestedReport));
+  const reportInsideTarget = relative19(resolve44(target.targetRoot), reportPath);
   if (reportInsideTarget === "" || !reportInsideTarget.startsWith("..") && !isAbsolute14(reportInsideTarget)) {
     throw new Error("Recovery report must be outside the runtime target root.");
   }
@@ -21151,7 +21757,7 @@ ownershipCommand.command("retire-stale").description("retire stale source-manife
   const normalizedOptions = normalizeRuntimeScopeOptions(options);
   const fleet = await showRegisteredFleet(options.fleet);
   const toWorkspaceRoot = normalizeCliPath(options.toWorkspaceRoot);
-  if (resolve43(fleet.root) !== resolve43(toWorkspaceRoot)) {
+  if (resolve44(fleet.root) !== resolve44(toWorkspaceRoot)) {
     throw new Error(`Destination Fleet '${options.fleet}' is registered at ${fleet.root}, not ${toWorkspaceRoot}.`);
   }
   const targets = await resolveCliTargets(normalizedOptions);
@@ -21159,7 +21765,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 || resolve43(target.workspaceRoot) !== resolve43(fleet.root)) {
+  if (target.fleetId !== options.fleet || resolve44(target.workspaceRoot) !== resolve44(fleet.root)) {
     throw new Error(`Resolved target does not belong to destination Fleet '${options.fleet}'.`);
   }
   const adapterOptions = adapterOptionsForTarget(target, normalizedOptions);
@@ -21231,7 +21837,7 @@ 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) => {
+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 drifted plain entries while keeping the recorded hash; forbidden for managed blocks", 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.");
   }
@@ -21281,7 +21887,7 @@ ownershipCommand.command("adopt-legacy").description("move proven legacy-keyed o
   ];
   for (const { flag, requested, resolved, none } of requestedAdapterSettings) {
     if (requested === void 0) continue;
-    if (resolved !== void 0 && resolve43(target.workspaceRoot, requested) === resolve43(target.workspaceRoot, resolved)) continue;
+    if (resolved !== void 0 && resolve44(target.workspaceRoot, requested) === resolve44(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);
@@ -21451,7 +22057,7 @@ journalCommand.command("list").description("show pending apply journals for reso
     if (!journal) continue;
     pending += 1;
     console.log(`PENDING ${state.adapter.name}/${state.installationType} at ${state.installRoot}`);
-    console.log(`  journal: ${join59(state.installRoot, ".agentwheel", `${state.state.stateKey}.apply-journal.json`)}`);
+    console.log(`  journal: ${join61(state.installRoot, ".agentwheel", `${state.state.stateKey}.apply-journal.json`)}`);
     console.log(`  stateKey: ${state.state.stateKey}`);
     console.log(`  createdAt: ${journal.createdAt}`);
     console.log(`  updatedAt: ${journal.updatedAt}`);
@@ -21515,7 +22121,11 @@ program.command("doctor").description("check agentwheel runtime setup and compan
   await printDoctor(targets[0], normalizedOptions);
 });
 async function runInstallCommand(nameOrSource, options, behavior) {
-  const normalizedOptions = normalizeRuntimeScopeOptions(options, { defaultUser: shouldDefaultUserInstall(nameOrSource, options) });
+  const normalizedOptions = normalizeRuntimeScopeOptions({
+    ...options,
+    forceConflict: options.forceConflict || options.adopt,
+    replaceConflict: options.replaceConflict || options.adopt
+  }, { defaultUser: shouldDefaultUserInstall(nameOrSource, options) });
   const outputFormat = effectivePlanOutputFormat(normalizedOptions);
   const composite = await resolveSelectedCompositeProfile(normalizedOptions);
   if (composite) {
@@ -21797,14 +22407,14 @@ async function packageEntryFromSource(source, targetRoot, options) {
     );
   }
   const bundle = options.deferGraphRendering ? await stageSourceRaw(driver, resolvedSource, {
-    cacheRoot: join59(targetRoot, ".agentwheel", "cache"),
+    cacheRoot: join61(targetRoot, ".agentwheel", "cache"),
     mode: options.mode,
     ref: initialVersion?.ref,
     frozenLock: lockMode
   }) : await stageSource(driver, resolvedSource, {
     workspaceRoot: targetRoot,
     adapter,
-    cacheRoot: join59(targetRoot, ".agentwheel", "cache"),
+    cacheRoot: join61(targetRoot, ".agentwheel", "cache"),
     mode: options.mode,
     ref: initialVersion?.ref,
     frozenLock: lockMode,
@@ -21822,6 +22432,7 @@ async function packageEntryFromSource(source, targetRoot, options) {
       source: resolvedSource,
       driver: driverName,
       adapter: adapter.name,
+      runtimes: options.runtimes?.length ? options.runtimes : void 0,
       installationType,
       adapterConfig: options.adapterConfig,
       adapterModule: options.adapterModule,
@@ -22412,7 +23023,7 @@ function scopeUpdatePlanToDependencies(result, selectors, previousLock, manifest
     selectedPreviousNodeIds,
     selectedRootIds
   );
-  const graphLockDigest = createHash27("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
+  const graphLockDigest = createHash28("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
   return {
     ...result,
     bundle: { ...result.bundle, graphLock },
@@ -22538,7 +23149,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 = createHash27("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
+  const graphLockDigest = createHash28("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
   return {
     ...scoped,
     bundle: { ...scoped.bundle, graphLock },
@@ -22549,7 +23160,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 = createHash27("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
+  const graphLockDigest = createHash28("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
   return {
     ...scoped,
     bundle: { ...scoped.bundle, graphLock },
@@ -22844,7 +23455,7 @@ function scopeUpdatePlanToRoot(result, rootId, previousLock, manifest) {
     selectedPreviousNodeIds,
     /* @__PURE__ */ new Set([rootId])
   );
-  const graphLockDigest = createHash27("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
+  const graphLockDigest = createHash28("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
   return {
     ...scoped,
     bundle: { ...scoped.bundle, graphLock },
@@ -22916,7 +23527,7 @@ function keepManifestEntryOperation(entry, targetRoot, scopeDescription, operati
     artifactType: entry.artifactType,
     artifactName: entry.artifactName,
     kind: entry.kind,
-    destPath: operation?.destPath ?? join59(targetRoot, entry.path),
+    destPath: operation?.destPath ?? join61(targetRoot, entry.path),
     relativeDestPath: entry.path,
     desiredHash: entry.sourceHash,
     currentHash: operation?.currentHash ?? entry.hash,
@@ -23117,7 +23728,7 @@ function installRootContextForTarget(target) {
   return { kind: target.transport, homeRoot: target.runAs?.home };
 }
 async function withFreshReadOnlyGraphPlan(target, adapter, adapterOptions, installationType, packages, use) {
-  const stage = await mkdtemp6(join59(tmpdir7(), "agentwheel-recovery-"));
+  const stage = await mkdtemp6(join61(tmpdir7(), "agentwheel-recovery-"));
   const priorTmpdir = process.env.TMPDIR;
   try {
     process.env.TMPDIR = stage;
@@ -23149,8 +23760,8 @@ async function withFreshReadOnlyGraphPlan(target, adapter, adapterOptions, insta
       yes: true,
       freshGraphOnly: true,
       deferForeignStateCheck: true,
-      cacheRoot: join59(stage, "source-cache"),
-      registryCachePath: join59(stage, "registry.json")
+      cacheRoot: join61(stage, "source-cache"),
+      registryCachePath: join61(stage, "registry.json")
     });
     return await use(graphPlan);
   } finally {
@@ -23237,7 +23848,7 @@ async function resolveCliTargetState(target, options) {
     migration: prior.migration,
     targetStateFilePreconditions: {
       graphLockPath: stableGraphLockPath,
-      graphLockRevision: stableLock ? createHash27("sha256").update(canonicalGraphLockJson(stableLock)).digest("hex") : null,
+      graphLockRevision: stableLock ? createHash28("sha256").update(canonicalGraphLockJson(stableLock)).digest("hex") : null,
       sourceLockRevision: computeSourceLockRevision(stableSourceLock)
     }
   };
@@ -23260,7 +23871,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 ? createHash27("sha256").update(JSON.stringify(foreignObservations.map((observation) => [
+  const observedManifestRevision = foreignObservations.length > 0 ? createHash28("sha256").update(JSON.stringify(foreignObservations.map((observation) => [
     observation.fileName,
     observation.manifestRevision
   ]).sort())).digest("hex") : null;
@@ -23507,7 +24118,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 = resolve43(workspaceRoot, member.workspace);
+    const memberRoot = resolve44(workspaceRoot, member.workspace);
     const memberPolicy = await mutationPolicyForWorkspace(memberRoot);
     if (memberPolicy?.revisioning.mode === "commit-after-verify") {
       throw new Error(
@@ -23744,12 +24355,12 @@ async function printDoctor(target, options) {
   const requestedSkills = doctorSkillRequests(target, options);
   const skills = [];
   for (const request of requestedSkills) {
-    const skillPath = join59(state.installRoot, targetMapping.dest, request.name);
+    const skillPath = join61(state.installRoot, targetMapping.dest, request.name);
     const exists2 = await pathExists(skillPath);
     const manifestEntry = manifest?.entries.find((entry) => {
       if (entry.artifactType !== "skills") return false;
       const legacyInstallName = "installName" in entry && typeof entry.installName === "string" ? entry.installName : void 0;
-      return entry.artifactName === request.name || legacyInstallName === request.name || entry.path === join59(targetMapping.dest, request.name);
+      return entry.artifactName === request.name || legacyInstallName === request.name || entry.path === join61(targetMapping.dest, request.name);
     });
     const status = manifestEntry ? "managed" : exists2 ? "present-unmanaged" : "missing";
     skills.push({
@@ -23829,7 +24440,7 @@ function doctorSkillLabel(name) {
   return `${name} skill`;
 }
 function isSyncwheelWorkspace(targetRoot) {
-  return existsSync(join59(targetRoot, ".syncwheel", "manifest.json"));
+  return existsSync(join61(targetRoot, ".syncwheel", "manifest.json"));
 }
 function skillInstallCommand(adapter, installationType, options, skill, behavior = {}) {
   const args = [
@@ -23858,7 +24469,7 @@ function shellQuoteArg2(value) {
   if (/^[A-Za-z0-9_./:@=-]+$/.test(value)) return value;
   return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
-function collectSelectOption(value, previous) {
+function collectSelectOption(value, previous = []) {
   return [...previous, ...splitSelectorList(value)];
 }
 function parsePositiveInteger(value) {
@@ -23992,14 +24603,14 @@ function looksLikeSourceSpecifier(value) {
 }
 function normalizeCliPath(value) {
   if (value === "~") return homedir18();
-  if (value.startsWith("~/")) return resolve43(homedir18(), value.slice(2));
-  return resolve43(value);
+  if (value.startsWith("~/")) return resolve44(homedir18(), value.slice(2));
+  return resolve44(value);
 }
 function shellQuoteArgument(value) {
   return /^[a-z0-9_./:@%+=,-]+$/i.test(value) ? value : `'${value.replace(/'/g, `'"'"'`)}'`;
 }
 function isHomePath(path) {
-  return resolve43(path) === resolve43(homedir18());
+  return resolve44(path) === resolve44(homedir18());
 }
 function adapterListFromOption(adapter) {
   if (!adapter) return [];
@@ -24054,11 +24665,11 @@ function filterUninstallPlanBySelection(plan, selected) {
   };
 }
 async function initPackage(root) {
-  await mkdir26(join59(root, "instructions"), { recursive: true });
-  await mkdir26(join59(root, "rules"), { recursive: true });
-  await mkdir26(join59(root, "skills"), { recursive: true });
-  const manifestPath = join59(root, "openpack.json");
-  const instructionsPath = join59(root, "instructions", "AGENTS.md");
+  await mkdir27(join61(root, "instructions"), { recursive: true });
+  await mkdir27(join61(root, "rules"), { recursive: true });
+  await mkdir27(join61(root, "skills"), { recursive: true });
+  const manifestPath = join61(root, "openpack.json");
+  const instructionsPath = join61(root, "instructions", "AGENTS.md");
   const manifest = {
     schemaVersion: CURRENT_OPENPACK_SCHEMA_VERSION,
     name: "example/agentwheel-package",
@@ -24120,7 +24731,7 @@ function withFleetExample(config) {
   };
 }
 async function findAgentwheelPackageRoot(start) {
-  let current = resolve43(start);
+  let current = resolve44(start);
   while (true) {
     if (await findPackageManifestPath(current, { warnLegacy: false })) return current;
     const parent = dirname37(current);
@@ -24248,14 +24859,14 @@ async function governedCommandContext(command, options) {
     const kind = String(command.args[0] ?? "workspace");
     return {
       workspaceRoot: workspaceRoot2,
-      anticipatedPaths: kind === "package" ? [join59(targetRoot, "openpack.json"), join59(targetRoot, "instructions", "AGENTS.md")] : [workspaceConfigPath(targetRoot)]
+      anticipatedPaths: kind === "package" ? [join61(targetRoot, "openpack.json"), join61(targetRoot, "instructions", "AGENTS.md")] : [workspaceConfigPath(targetRoot)]
     };
   }
   if (path === "package migrate") {
     const packageRoot = normalizeTargetRoot(String(command.args[0] ?? "."));
     return {
       workspaceRoot: await findExistingWorkspaceRoot(packageRoot) ?? packageRoot,
-      anticipatedPaths: ["agentwheel.json", "agentwheel.jsonc", "openpack.json", "openpack.jsonc"].map((name) => join59(packageRoot, name))
+      anticipatedPaths: ["agentwheel.json", "agentwheel.jsonc", "openpack.json", "openpack.jsonc"].map((name) => join61(packageRoot, name))
     };
   }
   const source = typeof command.args[0] === "string" ? command.args[0] : void 0;
@@ -24265,9 +24876,9 @@ async function governedCommandContext(command, options) {
   const contextOnly = path === "cache prune";
   const workspaceRoot = contextOnly ? await workspaceContextRootFromOptions(normalized) : await workspaceRootFromOptions(normalized);
   const anticipatedPaths = [];
-  if (path === "add") anticipatedPaths.push(workspaceConfigPath(workspaceRoot));
+  if (path === "add" || path === "pin") anticipatedPaths.push(workspaceConfigPath(workspaceRoot));
   if (path === "remember" && options.runtime) {
-    anticipatedPaths.push(join59(workspaceRoot, ".agentwheel", "overlays", options.runtime, "instructions.local.md"));
+    anticipatedPaths.push(join61(workspaceRoot, ".agentwheel", "overlays", options.runtime, "instructions.local.md"));
   }
   if (path === "uninstall" && source) anticipatedPaths.push(workspaceConfigPath(workspaceRoot));
   return {