agentwheel 0.22.2 → 0.22.4

package/dist/index.js

@@ -16558,7 +16558,8 @@ var init_local = __esm({
       atomicCopy,
       rm: (path) => rm3(path, { recursive: true, force: true }),
       async execFile(command, args, options = {}) {
-        await execFileAsync(command, args, { cwd: options.cwd });
+        const { stdout } = await execFileAsync(command, args, { cwd: options.cwd });
+        return stdout;
       }
     };
   }
@@ -16627,7 +16628,7 @@ function createSshTransport(config2) {
     execFile(command, commandArgs, options = {}) {
       const quoted = [command, ...commandArgs].map(quoteSh).join(" ");
       const remoteCommand = options.cwd ? `cd ${quoteSh(options.cwd)} && ${quoted}` : quoted;
-      return run(remoteCommand).then(() => void 0);
+      return run(remoteCommand);
     }
   };
 }
@@ -17180,6 +17181,189 @@ var init_transport = __esm({
   }
 });
 
+// src/resolve/semver.ts
+function parseSemver(value) {
+  const match = semverPattern.exec(value.trim());
+  if (!match) return void 0;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4]
+  };
+}
+function satisfiesVersionRange(version2, range) {
+  if (!range || range.trim() === "" || range.trim() === "*") return true;
+  const parsedVersion = parseSemver(version2);
+  const trimmed = range.trim();
+  if (!parsedVersion) {
+    return trimmed === "*" || trimmed === version2;
+  }
+  const comparators = parseRange(trimmed);
+  if (!comparators) return trimmed === version2;
+  return comparators.every((comparator) => compareWith(parsedVersion, comparator));
+}
+function semverMajorOrVersion(version2) {
+  const parsed = parseSemver(version2);
+  return parsed ? String(parsed.major) : version2;
+}
+function compareSemverStrings(a, b) {
+  const parsedA = parseSemver(a);
+  const parsedB = parseSemver(b);
+  if (!parsedA || !parsedB) return a.localeCompare(b);
+  return compareSemver(parsedA, parsedB);
+}
+function isSupportedVersionRange(range) {
+  const trimmed = range.trim();
+  return trimmed === "*" || parseRange(trimmed) !== void 0;
+}
+function parseRange(range) {
+  if (range === "*") return [];
+  if (range.startsWith("^")) {
+    const base = parseSemver(range.slice(1));
+    if (!base) return void 0;
+    return [
+      { op: ">=", version: base },
+      { op: "<", version: caretUpperBound(base) }
+    ];
+  }
+  if (range.startsWith("~")) {
+    const base = parseSemver(range.slice(1));
+    if (!base) return void 0;
+    return [
+      { op: ">=", version: base },
+      { op: "<", version: { major: base.major, minor: base.minor + 1, patch: 0 } }
+    ];
+  }
+  const parts = range.split(/\s+/).filter(Boolean);
+  const comparators = [];
+  for (const part of parts) {
+    const match = /^(>=|<=|>|<|=)?(.+)$/.exec(part);
+    if (!match) return void 0;
+    const version2 = parseSemver(match[2] ?? "");
+    if (!version2) return void 0;
+    comparators.push({ op: match[1] ?? "=", version: version2 });
+  }
+  return comparators;
+}
+function caretUpperBound(version2) {
+  if (version2.major > 0) return { major: version2.major + 1, minor: 0, patch: 0 };
+  if (version2.minor > 0) return { major: 0, minor: version2.minor + 1, patch: 0 };
+  return { major: 0, minor: 0, patch: version2.patch + 1 };
+}
+function compareWith(version2, comparator) {
+  const order = compareSemver(version2, comparator.version);
+  switch (comparator.op) {
+    case "=":
+      return order === 0;
+    case ">":
+      return order > 0;
+    case ">=":
+      return order >= 0;
+    case "<":
+      return order < 0;
+    case "<=":
+      return order <= 0;
+  }
+}
+function compareSemver(a, b) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key]) return a[key] > b[key] ? 1 : -1;
+  }
+  if (a.prerelease === b.prerelease) return 0;
+  if (!a.prerelease) return 1;
+  if (!b.prerelease) return -1;
+  return a.prerelease.localeCompare(b.prerelease);
+}
+var semverPattern;
+var init_semver = __esm({
+  "src/resolve/semver.ts"() {
+    "use strict";
+    semverPattern = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+  }
+});
+
+// src/targets/plugins/openclaw.ts
+import { readFile as readFile8 } from "fs/promises";
+import { join as join10 } from "path";
+function openClawPluginInstallCommand(request) {
+  return ["openclaw", "plugins", "install", "--force", ...request.acceptCapabilities ? ["--accept-capabilities"] : [], request.path];
+}
+function createOpenClawCapabilityDetector(run) {
+  let cached2;
+  return () => cached2 ??= detectOpenClawCapabilitySupport(run);
+}
+async function detectOpenClawCapabilitySupport(run) {
+  try {
+    const help = await run(["plugins", "install", "--help"]);
+    if (help?.trim()) return /(?:^|\s)--accept-capabilities(?=[\s=,]|$)/m.test(help);
+  } catch {
+  }
+  try {
+    const output = await run(["--version"]);
+    const version2 = output?.match(/(?:^|\s)v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)(?=\s|$)/)?.[1];
+    return version2 !== void 0 && parseSemver(version2) !== void 0 && satisfiesVersionRange(version2, ">=2026.8.1");
+  } catch {
+    return false;
+  }
+}
+function openClawPluginUninstallCommand(pluginName) {
+  return ["openclaw", "plugins", "uninstall", pluginName, "--force"];
+}
+async function openClawPluginSpec(request) {
+  if (request.format === "openclaw-clawhub-plugin") {
+    const metadata = await openClawClawHubPluginMetadata(request.path, request.fallbackPluginName);
+    return {
+      runtime: "openclaw",
+      pluginName: metadata.pluginName,
+      installCommands: [openClawPluginInstallCommand({ path: metadata.installSpec, dryRun: true })],
+      uninstallCommands: [openClawPluginUninstallCommand(metadata.pluginName)]
+    };
+  }
+  const pluginName = await openClawPluginName(request.path, request.fallbackPluginName);
+  return {
+    runtime: "openclaw",
+    pluginName,
+    installCommands: [openClawPluginInstallCommand({ path: request.path, dryRun: true })],
+    uninstallCommands: [openClawPluginUninstallCommand(pluginName)]
+  };
+}
+async function openClawPluginName(root, fallback) {
+  for (const manifestName of ["plugin.json", "openclaw.plugin.json"]) {
+    const manifestPath = join10(root, manifestName);
+    if (!await pathExists(manifestPath)) continue;
+    const parsed = JSON.parse(await readFile8(manifestPath, "utf8"));
+    if (typeof parsed.name === "string" && parsed.name.trim().length > 0) return parsed.name.trim();
+  }
+  return fallback;
+}
+async function openClawClawHubPluginMetadata(root, fallback) {
+  const metadataPath = join10(root, "clawhub.json");
+  if (!await pathExists(metadataPath)) {
+    throw new Error("OpenClaw ClawHub plugins must contain clawhub.json");
+  }
+  const parsed = JSON.parse(await readFile8(metadataPath, "utf8"));
+  const installSpec = stringField(parsed.installSpec);
+  if (!installSpec?.startsWith("clawhub:")) {
+    throw new Error("OpenClaw ClawHub plugin metadata must declare installSpec starting with clawhub:");
+  }
+  const pluginName = stringField(parsed.runtimeId) ?? installNameFor(stringField(parsed.name) ?? fallback);
+  return { installSpec, pluginName };
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function installNameFor(value) {
+  return value.split("/").at(-1).replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "clawhub-plugin";
+}
+var init_openclaw2 = __esm({
+  "src/targets/plugins/openclaw.ts"() {
+    "use strict";
+    init_fs();
+    init_semver();
+  }
+});
+
 // src/transport/run-as-policy.ts
 function assertRunAsPlanSupported(plan, transport) {
   if (transport.kind !== "local-run-as") return;
@@ -17194,12 +17378,12 @@ var init_run_as_policy = __esm({
 });
 
 // src/install/json-merge.ts
-import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
+import { readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
 import { dirname as dirname7 } from "path";
 import { mkdir as mkdir5 } from "fs/promises";
 async function mergeJsonFile(sourcePath, destPath) {
-  const source = JSON.parse(await readFile8(sourcePath, "utf8"));
-  const current = await pathExists(destPath) ? JSON.parse(await readFile8(destPath, "utf8")) : {};
+  const source = JSON.parse(await readFile9(sourcePath, "utf8"));
+  const current = await pathExists(destPath) ? JSON.parse(await readFile9(destPath, "utf8")) : {};
   const merged = deepMerge(current, source);
   await mkdir5(dirname7(destPath), { recursive: true });
   await writeFile5(destPath, `${JSON.stringify(merged, null, 2)}
@@ -17240,11 +17424,11 @@ var init_json_merge = __esm({
 });
 
 // src/install/openclaw-json-merge.ts
-import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile10, writeFile as writeFile6 } from "fs/promises";
 import { dirname as dirname8 } from "path";
 async function mergeOpenClawJsonFile(sourcePath, destPath) {
   const source = await renderOpenClawJsonMergeSource(sourcePath);
-  const current = await pathExists(destPath) ? JSON.parse(await readFile9(destPath, "utf8")) : {};
+  const current = await pathExists(destPath) ? JSON.parse(await readFile10(destPath, "utf8")) : {};
   const merged = mergeOpenClawJson(current, source);
   await mkdir6(dirname8(destPath), { recursive: true });
   await writeFile6(destPath, `${JSON.stringify(merged, null, 2)}
@@ -17252,7 +17436,7 @@ async function mergeOpenClawJsonFile(sourcePath, destPath) {
 }
 async function renderOpenClawJsonMergeSource(sourcePath) {
   return expandEnvPlaceholders(
-    normalizeOpenClawConfig(JSON.parse(await readFile9(sourcePath, "utf8"))),
+    normalizeOpenClawConfig(JSON.parse(await readFile10(sourcePath, "utf8"))),
     sourcePath
   );
 }
@@ -17517,9 +17701,9 @@ var init_manifest = __esm({
 });
 
 // src/install/paths.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function metadataDir(targetRoot) {
-  return join10(targetRoot, ".agentwheel");
+  return join11(targetRoot, ".agentwheel");
 }
 function stateKeyFor(adapter, scope = {}) {
   assertPathSafeAdapterName(adapter);
@@ -17539,10 +17723,10 @@ function assertPathSafeAdapterName(adapter) {
   }
 }
 function installManifestPath(targetRoot, adapter, scope = {}) {
-  return join10(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.install-manifest.json`);
+  return join11(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.install-manifest.json`);
 }
 function sourceLockPath(targetRoot, adapter, scope = {}) {
-  return join10(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.source-lock.json`);
+  return join11(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.source-lock.json`);
 }
 function sanitizeStateKey(value) {
   return value.replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "default";
@@ -17556,7 +17740,7 @@ var init_paths = __esm({
 
 // src/install/manifest.ts
 import { createHash as createHash7 } from "crypto";
-import { join as join11, resolve as resolve10 } from "path";
+import { join as join12, resolve as resolve10 } from "path";
 async function readInstallManifest(targetRoot, adapter, transport = localTransport, scope = {}) {
   const path = installManifestPath(targetRoot, adapter, scope);
   if (!await transport.pathExists(path)) return void 0;
@@ -17574,7 +17758,7 @@ async function listInstallManifests(targetRoot, adapter, transport = localTransp
   for (const fileName of await transport.listDir(dir)) {
     if (!fileName.endsWith(suffix)) continue;
     const stateKey = fileName.slice(0, -suffix.length);
-    const path = join11(dir, fileName);
+    const path = join12(dir, fileName);
     try {
       const raw = JSON.parse(await transport.readFile(path));
       const parsed = installManifestSchema.parse(raw);
@@ -17759,108 +17943,6 @@ if private and (s.st_uid!=os.geteuid() or not stat.S_ISREG(s.st_mode) or s.st_nl
   }
 });
 
-// src/resolve/semver.ts
-function parseSemver(value) {
-  const match = semverPattern.exec(value.trim());
-  if (!match) return void 0;
-  return {
-    major: Number(match[1]),
-    minor: Number(match[2]),
-    patch: Number(match[3]),
-    prerelease: match[4]
-  };
-}
-function satisfiesVersionRange(version2, range) {
-  if (!range || range.trim() === "" || range.trim() === "*") return true;
-  const parsedVersion = parseSemver(version2);
-  const trimmed = range.trim();
-  if (!parsedVersion) {
-    return trimmed === "*" || trimmed === version2;
-  }
-  const comparators = parseRange(trimmed);
-  if (!comparators) return trimmed === version2;
-  return comparators.every((comparator) => compareWith(parsedVersion, comparator));
-}
-function semverMajorOrVersion(version2) {
-  const parsed = parseSemver(version2);
-  return parsed ? String(parsed.major) : version2;
-}
-function compareSemverStrings(a, b) {
-  const parsedA = parseSemver(a);
-  const parsedB = parseSemver(b);
-  if (!parsedA || !parsedB) return a.localeCompare(b);
-  return compareSemver(parsedA, parsedB);
-}
-function isSupportedVersionRange(range) {
-  const trimmed = range.trim();
-  return trimmed === "*" || parseRange(trimmed) !== void 0;
-}
-function parseRange(range) {
-  if (range === "*") return [];
-  if (range.startsWith("^")) {
-    const base = parseSemver(range.slice(1));
-    if (!base) return void 0;
-    return [
-      { op: ">=", version: base },
-      { op: "<", version: caretUpperBound(base) }
-    ];
-  }
-  if (range.startsWith("~")) {
-    const base = parseSemver(range.slice(1));
-    if (!base) return void 0;
-    return [
-      { op: ">=", version: base },
-      { op: "<", version: { major: base.major, minor: base.minor + 1, patch: 0 } }
-    ];
-  }
-  const parts = range.split(/\s+/).filter(Boolean);
-  const comparators = [];
-  for (const part of parts) {
-    const match = /^(>=|<=|>|<|=)?(.+)$/.exec(part);
-    if (!match) return void 0;
-    const version2 = parseSemver(match[2] ?? "");
-    if (!version2) return void 0;
-    comparators.push({ op: match[1] ?? "=", version: version2 });
-  }
-  return comparators;
-}
-function caretUpperBound(version2) {
-  if (version2.major > 0) return { major: version2.major + 1, minor: 0, patch: 0 };
-  if (version2.minor > 0) return { major: 0, minor: version2.minor + 1, patch: 0 };
-  return { major: 0, minor: 0, patch: version2.patch + 1 };
-}
-function compareWith(version2, comparator) {
-  const order = compareSemver(version2, comparator.version);
-  switch (comparator.op) {
-    case "=":
-      return order === 0;
-    case ">":
-      return order > 0;
-    case ">=":
-      return order >= 0;
-    case "<":
-      return order < 0;
-    case "<=":
-      return order <= 0;
-  }
-}
-function compareSemver(a, b) {
-  for (const key of ["major", "minor", "patch"]) {
-    if (a[key] !== b[key]) return a[key] > b[key] ? 1 : -1;
-  }
-  if (a.prerelease === b.prerelease) return 0;
-  if (!a.prerelease) return 1;
-  if (!b.prerelease) return -1;
-  return a.prerelease.localeCompare(b.prerelease);
-}
-var semverPattern;
-var init_semver = __esm({
-  "src/resolve/semver.ts"() {
-    "use strict";
-    semverPattern = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
-  }
-});
-
 // src/model/selection.ts
 function artifactSelectorKey(artifact) {
   return `${artifact.type}/${artifact.name}`;
@@ -17918,9 +18000,9 @@ var init_selection = __esm({
 });
 
 // src/model/workspace.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname9, join as join12, resolve as resolve13 } from "path";
+import { dirname as dirname9, join as join13, resolve as resolve13 } from "path";
 function packagesForTarget(packages, target, targetForPackage2) {
   return packages.filter((pkg) => !pkg.runtimes || pkg.runtimes.includes((targetForPackage2?.(pkg) ?? target).adapter));
 }
@@ -17928,12 +18010,12 @@ function supportsFleetConfig(config2) {
   return config2.schemaVersion === 3 || config2.schemaVersion === 4;
 }
 function workspaceConfigPath(workspaceRoot) {
-  return join12(workspaceRoot, ".agentwheel", "config.json");
+  return join13(workspaceRoot, ".agentwheel", "config.json");
 }
 async function readWorkspaceConfig(workspaceRoot) {
   const path = workspaceConfigPath(workspaceRoot);
   if (!await pathExists(path)) return emptyWorkspaceConfig();
-  return workspaceConfigSchema.parse(JSON.parse(await readFile10(path, "utf8")));
+  return workspaceConfigSchema.parse(JSON.parse(await readFile11(path, "utf8")));
 }
 async function writeWorkspaceConfig(workspaceRoot, config2) {
   const path = workspaceConfigPath(workspaceRoot);
@@ -17947,7 +18029,7 @@ async function pinConfiguredPackages(workspaceRoot, input, options = {}) {
       throw new Error("Package declarations require unique aliases.");
     }
     const path2 = workspaceConfigPath(workspaceRoot);
-    const config3 = JSON.parse(await readFile10(path2, "utf8"));
+    const config3 = JSON.parse(await readFile11(path2, "utf8"));
     workspaceConfigSchema.parse(config3);
     config3.packages = input;
     workspaceConfigSchema.parse(config3);
@@ -17970,7 +18052,7 @@ async function pinConfiguredPackages(workspaceRoot, input, options = {}) {
     throw new Error("Pin requires unique configured aliases.");
   }
   const path = workspaceConfigPath(workspaceRoot);
-  const config2 = JSON.parse(await readFile10(path, "utf8"));
+  const config2 = JSON.parse(await readFile11(path, "utf8"));
   workspaceConfigSchema.parse(config2);
   const updates = pins.map(({ alias, commit, select }) => {
     const matches = (config2.packages ?? []).filter((pkg2) => pkg2.name === alias);
@@ -18004,7 +18086,7 @@ function upsertPackage(config2, entry) {
   return workspaceConfigSchema.parse({ ...parsed, packages });
 }
 function globalWorkspaceConfigPath(globalRoot = homedir4()) {
-  return join12(globalRoot, ".agentwheel", "config.json");
+  return join13(globalRoot, ".agentwheel", "config.json");
 }
 async function findWorkspaceRoot(start = process.cwd()) {
   let current = resolve13(start);
@@ -18063,7 +18145,7 @@ function isCompositeWorkspaceProfile(profile) {
 }
 async function readConfigPath(path) {
   if (!await pathExists(path)) return emptyWorkspaceConfig();
-  return workspaceConfigSchema.parse(JSON.parse(await readFile10(path, "utf8")));
+  return workspaceConfigSchema.parse(JSON.parse(await readFile11(path, "utf8")));
 }
 function mergeWorkspaceTrust(global, project) {
   return {
@@ -18324,7 +18406,7 @@ var init_workspace = __esm({
 });
 
 // src/model/fleet.ts
-import { lstat as lstat2, readFile as readFile11, realpath } from "fs/promises";
+import { lstat as lstat2, readFile as readFile12, realpath } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { isAbsolute as isAbsolute10, relative as relative6, resolve as resolve14 } from "path";
 async function resolveWorkspaceScope(request = {}) {
@@ -18441,7 +18523,7 @@ async function readRequiredConfig(root, label) {
   const path = workspaceConfigPath(root);
   if (!await pathExists(path)) throw missingScopeError(label);
   try {
-    return workspaceConfigSchema.parse(JSON.parse(await readFile11(path, "utf8")));
+    return workspaceConfigSchema.parse(JSON.parse(await readFile12(path, "utf8")));
   } catch (error46) {
     throw new Error(`Invalid ${label} Agentwheel config at ${path}: ${error46 instanceof Error ? error46.message : String(error46)}`);
   }
@@ -18512,8 +18594,8 @@ var init_fleet = __esm({
 
 // src/mutation/repository.ts
 import { createHash as createHash8 } from "crypto";
-import { lstat as lstat3, readFile as readFile12, readlink, readdir as readdir5 } from "fs/promises";
-import { posix as posix4, relative as relative7, resolve as resolve15, sep as sep5 } from "path";
+import { lstat as lstat3, readFile as readFile13, readlink, readdir as readdir5 } from "fs/promises";
+import { dirname as dirname10, posix as posix4, relative as relative7, resolve as resolve15, sep as sep5 } from "path";
 async function discoverGitRepository(start) {
   const probe = await runProcess("git", ["-C", start, "rev-parse", "--show-toplevel"], { allowExitCodes: [0, 128] });
   if (probe.exitCode !== 0) return void 0;
@@ -18540,6 +18622,9 @@ async function assertGitPreflight(repository) {
   }
 }
 async function assertHeadLease(repositoryRoot, expectedHead, head, paths, provider) {
+  return assertHeadLeaseWithRecovery(repositoryRoot, expectedHead, head, paths, provider, []);
+}
+async function assertHeadLeaseWithRecovery(repositoryRoot, expectedHead, head, paths, provider, recoveryPaths, terminalChanges = /* @__PURE__ */ new Map()) {
   if (head === expectedHead) return;
   if (provider?.headLease !== "path-scoped" || paths.length === 0) {
     throw new Error(`Git HEAD lease mismatch: expected ${expectedHead}, found ${head}.`);
@@ -18575,10 +18660,65 @@ async function assertHeadLease(repositoryRoot, expectedHead, head, paths, provid
       "-z",
       commit
     ])).stdout);
-    if (touched.some((path) => protectedPaths.some((protectedPath) => path === protectedPath || path.startsWith(`${protectedPath}/`) || protectedPath.startsWith(`${path}/`)))) {
-      throw new Error(`Git HEAD lease overlaps protected paths in intervening commit ${commit}.`);
+    for (const path of touched) {
+      if (!protectedPaths.some((protectedPath) => overlaps(path, protectedPath))) continue;
+      if (terminalChanges.get(commit)?.has(path)) continue;
+      const proof = recoveryPaths.find((entry) => entry.path === path && paths.includes(path));
+      if (!proof || overlaps(path, ".agentwheel/config.json") || overlaps(path, ".syncwheel/manifest.json") || await gitPathMode(repositoryRoot, commit, path) !== "100644" || await hashHeadPath(repositoryRoot, expectedHead, path) !== proof.beforeSha256 || await hashHeadPath(repositoryRoot, commit, path) !== proof.afterSha256 || await hashHeadPath(repositoryRoot, head, path) !== proof.afterSha256 || await hashWorkingPath(repositoryRoot, path) !== proof.afterSha256) {
+        throw new Error(`Git HEAD lease overlaps protected paths in intervening commit ${commit}.`);
+      }
+    }
+  }
+}
+function overlaps(left, right) {
+  return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+async function committedRecoveryPaths(repositoryRoot, expectedHead, head, declarations, receiptPaths, provider) {
+  await verifyRevisionPaths(repositoryRoot, expectedHead, receiptPaths);
+  const committed = [];
+  for (const entry of receiptPaths) {
+    if (!declarations.includes(entry.path)) throw new Error(`Recovery path was not declared: ${entry.path}.`);
+    if (await hashHeadPath(repositoryRoot, head, entry.path) === entry.afterSha256 && entry.beforeSha256 !== entry.afterSha256) {
+      await assertRecoveryFileIdentity(repositoryRoot, expectedHead, head, entry.path);
+      committed.push(entry);
     }
   }
+  await assertHeadLeaseWithRecovery(repositoryRoot, expectedHead, head, declarations, provider, committed);
+  return committed;
+}
+async function verifyCompletedRecoveryPaths(repositoryRoot, expectedHead, declarations, savedPaths, provider, productCommitSha, productPaths, controlCommitSha) {
+  const head = await currentHead(repositoryRoot);
+  await verifyRevisionPaths(repositoryRoot, expectedHead, savedPaths);
+  for (const entry of savedPaths) {
+    await assertRecoveryFileIdentity(repositoryRoot, expectedHead, head, entry.path);
+    if (await hashHeadPath(repositoryRoot, head, entry.path) !== entry.afterSha256) {
+      throw new Error(`Committed recovery path changed during provider completion: ${entry.path}.`);
+    }
+  }
+  const terminalChanges = /* @__PURE__ */ new Map();
+  if (productCommitSha) terminalChanges.set(productCommitSha, new Set(productPaths));
+  if (controlCommitSha) terminalChanges.set(controlCommitSha, /* @__PURE__ */ new Set([".syncwheel/manifest.json"]));
+  await assertHeadLeaseWithRecovery(repositoryRoot, expectedHead, head, declarations, provider, savedPaths, terminalChanges);
+}
+async function gitPathMode(repositoryRoot, head, path) {
+  const tree = (await runProcess("git", ["-C", repositoryRoot, "ls-tree", "-z", head, "--", path])).stdout.toString("utf8");
+  const entry = tree.split("\0").find((value) => value.slice(value.indexOf("	") + 1) === path);
+  return entry?.split(" ")[0];
+}
+async function assertRecoveryFileIdentity(repositoryRoot, expectedHead, head, path) {
+  if (await gitPathMode(repositoryRoot, expectedHead, path) !== "100644" || await gitPathMode(repositoryRoot, head, path) !== "100644") {
+    throw new Error(`Recovery requires an existing regular non-executable Git file: ${path}.`);
+  }
+  const absolute = resolve15(repositoryRoot, ...path.split("/"));
+  const stats = await lstat3(absolute);
+  if (!stats.isFile() || (stats.mode & 73) !== 0) throw new Error(`Recovery file identity changed: ${path}.`);
+  let ancestor = dirname10(absolute);
+  while (true) {
+    if ((await lstat3(ancestor)).isSymbolicLink()) throw new Error(`Recovery symlink ancestor is unsupported: ${path}.`);
+    const parent = dirname10(ancestor);
+    if (parent === ancestor) break;
+    ancestor = parent;
+  }
 }
 function isAgentwheelWritablePath(path) {
   return /^\.agentwheel(?:\/|$)/u.test(path) || /^profiles\/[^/]+\/\.agentwheel(?:\/|$)/u.test(path);
@@ -18661,7 +18801,7 @@ async function hashWorkingPath(repositoryRoot, path) {
     throw error46;
   }
   if (stats.isSymbolicLink()) return sha256(Buffer.from(await readlink(absolute), "utf8"));
-  if (stats.isFile()) return sha256(await readFile12(absolute));
+  if (stats.isFile()) return sha256(await readFile13(absolute));
   if (stats.isDirectory()) return hashDirectory(absolute);
   throw new Error(`Unsupported repository path kind: ${path}`);
 }
@@ -18674,7 +18814,7 @@ async function hashDirectory(root) {
       const relativePath = normalizeRepoPath(relative7(root, absolute));
       if (entry.isDirectory()) await walk2(absolute);
       else if (entry.isSymbolicLink()) hash3.update(relativePath).update("\0").update(await readlink(absolute)).update("\0");
-      else if (entry.isFile()) hash3.update(relativePath).update("\0").update(await readFile12(absolute)).update("\0");
+      else if (entry.isFile()) hash3.update(relativePath).update("\0").update(await readFile13(absolute)).update("\0");
     }
   }
   await walk2(root);
@@ -18710,9 +18850,9 @@ var init_repository = __esm({
 
 // src/mutation/providers.ts
 import { createHash as createHash9 } from "crypto";
-import { chmod as chmod2, mkdtemp, open as open3, readFile as readFile13, rename as rename5, rm as rm4, rmdir, stat as stat3, writeFile as writeFile7 } from "fs/promises";
+import { chmod as chmod2, mkdtemp, open as open3, readFile as readFile14, rename as rename5, rm as rm4, rmdir, stat as stat3, writeFile as writeFile7 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { isAbsolute as isAbsolute11, join as join13, resolve as resolve16 } from "path";
+import { isAbsolute as isAbsolute11, join as join14, resolve as resolve16 } from "path";
 function revisionProviderRejection(error46) {
   return error46 instanceof RevisionProviderRejectedError ? error46.response : void 0;
 }
@@ -18821,8 +18961,8 @@ async function openImmutableExecutableSnapshot(bytes) {
       `Command revision providers require an unlinked immutable executable snapshot, which is unsupported on ${process.platform}.`
     );
   }
-  const root = await mkdtemp(join13(tmpdir2(), "agentwheel-revision-command-"));
-  const path = join13(root, "entrypoint");
+  const root = await mkdtemp(join14(tmpdir2(), "agentwheel-revision-command-"));
+  const path = join14(root, "entrypoint");
   let snapshot;
   try {
     await chmod2(root, 448);
@@ -18976,8 +19116,8 @@ async function finalizeGit(providerId, request, config2) {
   const indexLease = await captureIndexLease(request.repositoryRoot);
   await assertIndexTree(request.repositoryRoot, repository.head);
   const hookBaseline = await snapshotRepository(request.repositoryRoot);
-  const tempRoot = await mkdtemp(join13(tmpdir2(), "agentwheel-git-index-"));
-  const indexPath = join13(tempRoot, "index");
+  const tempRoot = await mkdtemp(join14(tmpdir2(), "agentwheel-git-index-"));
+  const indexPath = join14(tempRoot, "index");
   const env2 = { ...process.env, GIT_INDEX_FILE: indexPath };
   let commitSha;
   try {
@@ -18988,14 +19128,14 @@ async function finalizeGit(providerId, request, config2) {
     await verifyTemporaryIndexPaths(request, env2);
     await runProcess("git", ["-C", request.repositoryRoot, "diff", "--cached", "--check"], { env: env2 });
     const tree = (await runProcess("git", ["-C", request.repositoryRoot, "write-tree"], { env: env2 })).stdout.toString("utf8").trim();
-    const messagePath = join13(tempRoot, "COMMIT_EDITMSG");
+    const messagePath = join14(tempRoot, "COMMIT_EDITMSG");
     await writeFile7(messagePath, commitMessage(request, planDigest), { encoding: "utf8", mode: 384 });
     await runCommitHooks(request, env2, messagePath);
     assertRepositorySnapshotEqual(hookBaseline, await snapshotRepository(request.repositoryRoot), "Git commit hooks");
     const stagedAfterHooks = splitNull2((await runProcess("git", ["-C", request.repositoryRoot, "diff", "--cached", "--name-only", "-z"], { env: env2 })).stdout);
     assertExactSet(stagedAfterHooks, request.paths.map((entry) => entry.path), "temporary Git index after hooks");
     await verifyTemporaryIndexPaths(request, env2);
-    const message = await readFile13(messagePath, "utf8");
+    const message = await readFile14(messagePath, "utf8");
     assertCommitMessageContract(message, request, planDigest);
     commitSha = (await runProcess("git", ["-C", request.repositoryRoot, "commit-tree", tree, "-p", repository.head], {
       env: env2,
@@ -19114,7 +19254,7 @@ async function captureIndexLease(repositoryRoot) {
   const rawPath = (await runProcess("git", ["-C", repositoryRoot, "rev-parse", "--git-path", "index"])).stdout.toString("utf8").trim();
   const path = isAbsolute11(rawPath) ? rawPath : resolve16(repositoryRoot, rawPath);
   try {
-    const [content, info] = await Promise.all([readFile13(path), stat3(path)]);
+    const [content, info] = await Promise.all([readFile14(path), stat3(path)]);
     return { path, sha256: sha2562(content), mode: info.mode & 511 };
   } catch (error46) {
     if (isMissing4(error46)) return { path, sha256: null, mode: 384 };
@@ -19122,15 +19262,15 @@ async function captureIndexLease(repositoryRoot) {
   }
 }
 async function replaceIndexCas(repositoryRoot, lease, commitSha) {
-  const tempRoot = await mkdtemp(join13(tmpdir2(), "agentwheel-index-replacement-"));
-  const replacementPath = join13(tempRoot, "index");
+  const tempRoot = await mkdtemp(join14(tmpdir2(), "agentwheel-index-replacement-"));
+  const replacementPath = join14(tempRoot, "index");
   const lockPath = `${lease.path}.lock`;
   let handle;
   try {
     await runProcess("git", ["-C", repositoryRoot, "read-tree", commitSha], {
       env: { ...process.env, GIT_INDEX_FILE: replacementPath }
     });
-    const replacement = await readFile13(replacementPath);
+    const replacement = await readFile14(replacementPath);
     handle = await open3(lockPath, "wx", lease.mode);
     const current = await readOptionalFile(lease.path);
     const currentSha256 = current ? sha2562(current) : null;
@@ -19172,7 +19312,7 @@ async function hashGitObject(repositoryRoot, spec) {
 }
 async function readOptionalFile(path) {
   try {
-    return await readFile13(path);
+    return await readFile14(path);
   } catch (error46) {
     if (isMissing4(error46)) return null;
     throw error46;
@@ -19279,7 +19419,7 @@ var init_providers = __esm({
 // src/mutation/coordinator.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname10, isAbsolute as isAbsolute12, relative as relative8, resolve as resolve17, sep as sep6 } from "path";
+import { dirname as dirname11, isAbsolute as isAbsolute12, relative as relative8, resolve as resolve17, sep as sep6 } from "path";
 function dirtyRepositoryPaths(repositoryRoot, baseline, paths) {
   const conflicts = /* @__PURE__ */ new Set();
   for (const path of paths) {
@@ -19353,12 +19493,15 @@ async function resumeMutation(operationId, action) {
       );
       receipt = await updateMutationReceipt(receipt, { paths, status: "mutation-applied" });
     }
-    await invokeRevisionProvider(provider, providerRequest(receipt, "preflight", paths), {
+    const request = action === "recover" && receipt.runtimeJournals.length > 0 ? await recoveryProviderRequest(receipt, paths) : providerRequest(receipt, action, paths);
+    await invokeRevisionProvider(provider, revisionProviderRequestSchema.parse({ ...request, action: "preflight" }), {
       workspaceRoot: receipt.workspaceRoot
     });
-    const response = await invokeRevisionProvider(provider, providerRequest(receipt, action, paths), {
+    if (action === "recover") await verifyRecoveryProjection(receipt, request);
+    const response = await invokeRevisionProvider(provider, request, {
       workspaceRoot: receipt.workspaceRoot
     });
+    await verifyCompletedRecoveryProjection(receipt, request, response);
     return updateMutationReceipt(receipt, {
       status: receiptStatusForProvider(response.status),
       providerResponse: response,
@@ -19401,17 +19544,19 @@ async function recoverMutationRuntime(operationId, options = {}) {
           `Mutation '${receipt.operationId}' repository HEAD lease changed before runtime recovery.`
         );
       }
-      await assertHeadLease(
+      if (receipt.noCommit) await assertHeadLease(receipt.repositoryRoot, receipt.expectedHead, repository.head, [], receipt.provider);
+      else await committedRecoveryPaths(
         receipt.repositoryRoot,
         receipt.expectedHead,
         repository.head,
-        receipt.noCommit ? [] : declarations,
+        declarations,
+        receipt.paths,
         receipt.provider
       );
       await assertGitPreflight(repository);
       await collectIntroducedPaths(receipt.repositoryRoot, receipt.expectedHead, baseline, declarations);
     }
-    mutation = GovernedMutation.activateExisting(receipt, baseline, lock);
+    mutation = GovernedMutation.activateExisting(receipt, baseline, lock, options.beforeProviderCompletion);
     const [{ recoverPendingApply: recoverPendingApply2 }, { readLinkedLocalApplyJournal: readLinkedLocalApplyJournal2 }] = await Promise.all([
       Promise.resolve().then(() => (init_apply(), apply_exports)),
       Promise.resolve().then(() => (init_transaction(), transaction_exports))
@@ -19523,7 +19668,7 @@ async function mutationPolicyForWorkspace(workspaceRoot, globalRoot = homedir6()
   const globalConfig2 = await readWorkspaceConfig(globalRoot);
   const global = globalConfig2.schemaVersion === 4 ? globalConfig2.mutationPolicy : void 0;
   let existingRoot = resolve17(workspaceRoot);
-  while (!await pathExists(existingRoot) && dirname10(existingRoot) !== existingRoot) existingRoot = dirname10(existingRoot);
+  while (!await pathExists(existingRoot) && dirname11(existingRoot) !== existingRoot) existingRoot = dirname11(existingRoot);
   const owner = await resolveWorkspaceOwnershipScope(existingRoot, { globalRoot });
   const fleetConfig = owner.fleetId ? await readWorkspaceConfig(owner.root) : void 0;
   const fleet = fleetConfig?.schemaVersion === 4 ? fleetConfig.mutationPolicy : void 0;
@@ -19545,6 +19690,50 @@ function mergeMutationPolicies(global, scoped) {
     revisioning
   });
 }
+async function recoveryProviderRequest(receipt, paths) {
+  const request = providerRequest(receipt, "recover", paths);
+  if (receipt.noCommit) return request;
+  const head = await currentHead(request.repositoryRoot);
+  const committed = await committedRecoveryPaths(
+    request.repositoryRoot,
+    request.expectedHead,
+    head,
+    readMutationPathDeclarations(receipt.operationId),
+    paths,
+    receipt.provider
+  );
+  if (committed.length === 0) return request;
+  const saved = new Set(committed.map((entry) => entry.path));
+  return revisionProviderRequestSchema.parse({
+    ...request,
+    expectedHead: head,
+    paths: paths.filter((entry) => !saved.has(entry.path))
+  });
+}
+async function verifyCompletedRecoveryProjection(receipt, request, response) {
+  if (request.expectedHead === receipt.expectedHead) return;
+  if (response.action !== "recover" && response.action !== "finalize") throw new Error("Recovery requires a terminal provider response.");
+  const remaining = new Set(request.paths.map((entry) => entry.path));
+  await verifyCompletedRecoveryPaths(
+    request.repositoryRoot,
+    receipt.expectedHead,
+    readMutationPathDeclarations(receipt.operationId),
+    receipt.paths.filter((entry) => !remaining.has(entry.path)),
+    receipt.provider,
+    response.productCommitSha,
+    request.paths.map((entry) => entry.path),
+    response.controlCommitSha
+  );
+}
+async function verifyRecoveryProjection(receipt, request) {
+  if (request.expectedHead === receipt.expectedHead) return;
+  if (await currentHead(request.repositoryRoot) !== request.expectedHead) throw new Error("Recovery projection HEAD changed.");
+  const verified = await recoveryProviderRequest(receipt, receipt.paths);
+  if (JSON.stringify(verified) !== JSON.stringify(request)) throw new Error("Recovery projection changed before provider completion.");
+  const repository = await discoverGitRepository(request.repositoryRoot);
+  if (!repository) throw new Error("Recovery repository disappeared.");
+  await assertGitPreflight(repository);
+}
 function providerRequest(receipt, action, paths) {
   if (!receipt.repositoryRoot || !receipt.expectedHead || !receipt.provider) {
     throw new Error(`Mutation '${receipt.operationId}' is missing revision provider request state.`);
@@ -19614,17 +19803,21 @@ var init_coordinator = __esm({
     init_repository();
     init_session_ownership();
     GovernedMutation = class _GovernedMutation {
-      constructor(policy, receipt, baseline, lock) {
+      constructor(policy, receipt, baseline, lock, runtimeRecovery = false, beforeProviderCompletion) {
         this.policy = policy;
         this.receipt = receipt;
         this.baseline = baseline;
         this.lock = lock;
+        this.runtimeRecovery = runtimeRecovery;
+        this.beforeProviderCompletion = beforeProviderCompletion;
         this.operationId = receipt.operationId;
       }
       policy;
       receipt;
       baseline;
       lock;
+      runtimeRecovery;
+      beforeProviderCompletion;
       operationId;
       closed = false;
       static async begin(options) {
@@ -19730,7 +19923,7 @@ var init_coordinator = __esm({
             );
           }
           this.receipt = await updateMutationReceipt(this.receipt, { status: "handler-succeeded" });
-          paths = await this.collectPaths();
+          paths = await this.collectPaths(action === "recover" && this.runtimeRecovery);
           this.receipt = await updateMutationReceipt(this.receipt, { paths, status: "mutation-applied" });
         } catch (error46) {
           this.receipt = await updateMutationReceipt(this.receipt, {
@@ -19748,12 +19941,16 @@ var init_coordinator = __esm({
             return this.receipt;
           }
           const provider = this.policy.revisioning.provider;
-          await invokeRevisionProvider(provider, providerRequest(this.receipt, "preflight", paths), {
+          const request = this.runtimeRecovery && action === "recover" ? await recoveryProviderRequest(this.receipt, paths) : providerRequest(this.receipt, action, paths);
+          await invokeRevisionProvider(provider, revisionProviderRequestSchema.parse({ ...request, action: "preflight" }), {
             workspaceRoot: this.receipt.workspaceRoot
           });
-          const response = await invokeRevisionProvider(provider, providerRequest(this.receipt, action, paths), {
+          if (this.runtimeRecovery) await verifyRecoveryProjection(this.receipt, request);
+          await this.beforeProviderCompletion?.();
+          const response = await invokeRevisionProvider(provider, request, {
             workspaceRoot: this.receipt.workspaceRoot
           });
+          await verifyCompletedRecoveryProjection(this.receipt, request, response);
           this.receipt = await updateMutationReceipt(this.receipt, {
             status: receiptStatusForProvider(response.status),
             providerResponse: response
@@ -19813,7 +20010,7 @@ var init_coordinator = __esm({
         const runtimeJournals = upsertRuntimeJournal(this.receipt.runtimeJournals, existing, status);
         this.receipt = await updateMutationReceipt(this.receipt, { runtimeJournals });
       }
-      static activateExisting(receipt, baseline, lock) {
+      static activateExisting(receipt, baseline, lock, beforeProviderCompletion) {
         if (receipt.revisionMode === "commit-after-verify" && !receipt.provider) {
           throw new Error(`Mutation '${receipt.operationId}' is missing its revision provider recovery policy.`);
         }
@@ -19831,24 +20028,41 @@ var init_coordinator = __esm({
           journal: "required",
           revisioning: { mode: "off" }
         });
-        const mutation = new _GovernedMutation(policy, receipt, baseline, lock);
+        const mutation = new _GovernedMutation(policy, receipt, baseline, lock, true, beforeProviderCompletion);
         activeMutation = mutation;
         return mutation;
       }
-      async collectPaths() {
+      async collectPaths(recover = false) {
         if (!this.receipt.repositoryRoot || !this.receipt.expectedHead || !this.baseline) return [];
         const declarations = [.../* @__PURE__ */ new Set([
           ...declaredMutationPaths(),
           ...readMutationPathDeclarations(this.receipt.operationId)
         ])].sort((a, b) => a.localeCompare(b));
-        if (this.receipt.provider) await assertHeadLease(
+        const head = await currentHead(this.receipt.repositoryRoot);
+        const committed = recover && !this.receipt.noCommit ? await committedRecoveryPaths(
           this.receipt.repositoryRoot,
           this.receipt.expectedHead,
-          await currentHead(this.receipt.repositoryRoot),
+          head,
+          declarations,
+          this.receipt.paths,
+          this.receipt.provider
+        ) : [];
+        if (this.receipt.provider && !recover) await assertHeadLease(
+          this.receipt.repositoryRoot,
+          this.receipt.expectedHead,
+          head,
           this.receipt.noCommit ? [] : declarations,
           this.receipt.provider
         );
-        return collectIntroducedPaths(this.receipt.repositoryRoot, this.receipt.expectedHead, this.baseline, declarations);
+        if (recover && this.receipt.noCommit) await assertHeadLease(
+          this.receipt.repositoryRoot,
+          this.receipt.expectedHead,
+          head,
+          [],
+          this.receipt.provider
+        );
+        const introduced = await collectIntroducedPaths(this.receipt.repositoryRoot, this.receipt.expectedHead, this.baseline, declarations);
+        return [...committed, ...introduced].sort((a, b) => a.path.localeCompare(b.path));
       }
       async close() {
         if (this.closed) return;
@@ -19863,13 +20077,13 @@ var init_coordinator = __esm({
 
 // src/transport/ownership-snapshot.ts
 import { createHash as createHash10 } from "crypto";
-import { lstat as lstat4, readdir as readdir6, readFile as readFile14 } from "fs/promises";
-import { dirname as dirname11, join as join14, relative as relative9, resolve as resolve18 } from "path";
+import { lstat as lstat4, readdir as readdir6, readFile as readFile15 } from "fs/promises";
+import { dirname as dirname12, join as join15, relative as relative9, resolve as resolve18 } from "path";
 async function assertSnapshotAncestors(path) {
   let current = resolve18(path);
   while (true) {
     if ((await lstat4(current)).isSymbolicLink()) throw new Error(`Symlink path is unsupported: ${current}`);
-    const parent = dirname11(current);
+    const parent = dirname12(current);
     if (parent === current) return;
     current = parent;
   }
@@ -19884,9 +20098,9 @@ async function ownershipRuntimeSnapshot(path) {
     }
     hash3.update(JSON.stringify([relative9(path, candidate), info.isDirectory() ? "dir" : "file", info.mode & 4095]));
     if (info.isDirectory()) {
-      for (const name of (await readdir6(candidate)).sort()) await visit2(join14(candidate, name));
+      for (const name of (await readdir6(candidate)).sort()) await visit2(join15(candidate, name));
     } else {
-      const content = await readFile14(candidate);
+      const content = await readFile15(candidate);
       hash3.update(String(content.length)).update("\0").update(content);
     }
   }
@@ -19935,7 +20149,7 @@ __export(transaction_exports, {
 });
 import { createHash as createHash11 } from "crypto";
 import { cp as cp2, lstat as lstat5, mkdir as mkdir7, open as open4, rm as rm5, stat as stat4 } from "fs/promises";
-import { dirname as dirname12, join as join15, relative as relative10, resolve as resolve19, sep as sep7 } from "path";
+import { dirname as dirname13, join as join16, relative as relative10, resolve as resolve19, sep as sep7 } from "path";
 async function assertNoSymlinkPath2(path) {
   const absolute = resolve19(path);
   let current = absolute;
@@ -19945,7 +20159,7 @@ async function assertNoSymlinkPath2(path) {
     } catch (error46) {
       if (error46.code !== "ENOENT") throw error46;
     }
-    const parent = dirname12(current);
+    const parent = dirname13(current);
     if (parent === current) break;
     current = parent;
   }
@@ -19998,7 +20212,7 @@ function metadataAuditPath(audit, path) {
   if (resolve19(audit.workspaceRoot) !== audit.workspaceRoot || path !== `.agentwheel/${audit.kind === "ownership-handoff" ? "ownership-handoffs" : "ownership-releases"}/${audit.operationId}.json`) {
     throw new Error("Invalid ownership release audit path.");
   }
-  return join15(audit.workspaceRoot, ...path.split("/"));
+  return join16(audit.workspaceRoot, ...path.split("/"));
 }
 function metadataRuntimePath(root, path) {
   const result = resolve19(root, path);
@@ -20016,7 +20230,7 @@ async function syncMetadataPath(path, directoryOnly = false) {
       await file2.close();
     }
   }
-  const directory = await open4(directoryOnly ? path : dirname12(path), "r");
+  const directory = await open4(directoryOnly ? path : dirname13(path), "r");
   try {
     await directory.sync();
   } finally {
@@ -20025,19 +20239,19 @@ async function syncMetadataPath(path, directoryOnly = false) {
 }
 function applyLockPath(targetRoot, adapter, scope = {}) {
   const installationType = scope.installationType ?? "local";
-  return join15(metadataDir(targetRoot), `${stateKeyFor(adapter, { installationType })}.runtime-apply-lock`);
+  return join16(metadataDir(targetRoot), `${stateKeyFor(adapter, { installationType })}.runtime-apply-lock`);
 }
 function applyJournalPath(targetRoot, adapter, scope = {}) {
-  return join15(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-journal.json`);
+  return join16(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-journal.json`);
 }
 function applyBackupDir(targetRoot, adapter, scope = {}) {
-  return join15(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-backups`);
+  return join16(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-backups`);
 }
 async function acquireApplyLock(targetRoot, adapter, transport = localTransport, options = {}, scope = {}) {
   assertGovernedRuntimeTransportSupported(transport);
   if (transport.kind === "local-run-as") await transport.prepareApply();
   const lockPath = applyLockPath(targetRoot, adapter, scope);
-  const ownerPath = join15(lockPath, "owner.json");
+  const ownerPath = join16(lockPath, "owner.json");
   const metadata = {
     pid: process.pid,
     adapter,
@@ -20106,7 +20320,7 @@ async function listApplyJournals(targetRoot, adapter, transport = localTransport
   const found = [];
   for (const fileName of await transport.listDir(metadataDir(targetRoot))) {
     if (!fileName.endsWith(suffix)) continue;
-    const path = join15(metadataDir(targetRoot), fileName);
+    const path = join16(metadataDir(targetRoot), fileName);
     const journal = parseApplyJournal(JSON.parse(await transport.readFile(path)));
     if (journal.adapter !== adapter || (journal.installationType ?? "local") !== installationType) continue;
     found.push({ path, journal });
@@ -20118,7 +20332,7 @@ async function listAllApplyJournals(targetRoot, adapter, transport = localTransp
   const found = [];
   for (const fileName of await transport.listDir(metadataDir(targetRoot))) {
     if (!fileName.endsWith(suffix)) continue;
-    const path = join15(metadataDir(targetRoot), fileName);
+    const path = join16(metadataDir(targetRoot), fileName);
     const journal = parseApplyJournal(JSON.parse(await transport.readFile(path)));
     if (adapter === void 0 || journal.adapter === adapter) found.push({ path, journal });
   }
@@ -20166,7 +20380,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(dirname12(path), true);
+  if ((existing?.metadataAudit || existing?.metadataGuards) && transport.kind === "local") await syncMetadataPath(dirname13(path), true);
   if (existing?.mutation) await resolveMutationRuntimeJournal(existing.mutation.operationId, path);
 }
 async function abortApplyJournal(targetRoot, adapter, transport = localTransport, scope = {}) {
@@ -20176,7 +20390,7 @@ async function abortApplyJournal(targetRoot, adapter, transport = localTransport
     const journalPath = applyJournalPath(targetRoot, adapter, scope);
     if (!await transport.pathExists(journalPath)) return void 0;
     const stateKey = stateKeyFor(adapter, scope);
-    const archivePath = join15(metadataDir(targetRoot), "archive", `${stateKey}.apply-journal.failed-${journalTimestamp(/* @__PURE__ */ new Date())}.json`);
+    const archivePath = join16(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) {
@@ -20309,7 +20523,7 @@ async function recordBackup(operation, index, targetRoot, adapter, transport = l
       hadExisting
     };
   }
-  const backupPath = join15(applyBackupDir(targetRoot, adapter, scope), String(index));
+  const backupPath = join16(applyBackupDir(targetRoot, adapter, scope), String(index));
   if (transport.kind === "local-run-as") {
     assertGovernedRuntimeTransportSupported(transport);
     await transport.rm(backupPath);
@@ -20317,7 +20531,7 @@ async function recordBackup(operation, index, targetRoot, adapter, transport = l
     await transport.copyWithin(operation.destPath, backupPath, operation.kind);
   } else {
     await rm5(backupPath, { recursive: true, force: true });
-    await mkdir7(dirname12(backupPath), { recursive: true });
+    await mkdir7(dirname13(backupPath), { recursive: true });
     await cp2(operation.destPath, backupPath, { recursive: operation.kind === "dir", dereference: true });
   }
   return {
@@ -20388,7 +20602,7 @@ function assertApplyJournalCompletedOperations(journal) {
     if (!operation || !["create", "update", "remove"].includes(operation.action) || item.destPath !== operation.destPath || item.kind !== operation.kind || typeof item.hadExisting !== "boolean" || item.completed !== void 0 && typeof item.completed !== "boolean") {
       throw new Error("Apply journal completion does not match its immutable operation.");
     }
-    const expectedBackup = join15(applyBackupDir(journal.targetRoot, journal.adapter, {
+    const expectedBackup = join16(applyBackupDir(journal.targetRoot, journal.adapter, {
       installationType: journal.installationType,
       stateKey: journal.stateKey
     }), String(item.index));
@@ -20414,16 +20628,25 @@ var init_transaction = __esm({
 });
 
 // src/install/toml-merge.ts
-import { mkdir as mkdir8, readFile as readFile16, writeFile as writeFile8 } from "fs/promises";
-import { parse as parseToml } from "smol-toml";
-import { dirname as dirname13 } from "path";
+import { mkdir as mkdir8, readFile as readFile17, writeFile as writeFile8 } from "fs/promises";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { dirname as dirname14 } from "path";
 async function mergeCodexTomlMcp(sourcePath, destPath) {
-  const source = JSON.parse(await readFile16(sourcePath, "utf8"));
+  const source = JSON.parse(await readFile17(sourcePath, "utf8"));
   const servers = extractMcpServers(source);
-  const current = await pathExists(destPath) ? await readFile16(destPath, "utf8") : "";
-  const withoutManaged = removeManagedMcpSections(current, Object.keys(servers));
-  const merged = appendMcpServers(withoutManaged, servers);
-  await mkdir8(dirname13(destPath), { recursive: true });
+  const current = await pathExists(destPath) ? await readFile17(destPath, "utf8") : "";
+  const parsed = parseToml(current, { integersAsBigInt: "asNeeded" });
+  const currentServers = isPlainRecord(parsed.mcp_servers) ? parsed.mcp_servers : {};
+  const blocks = [];
+  for (const [name, server] of Object.entries(servers).sort(([a], [b]) => a.localeCompare(b))) {
+    const rendered = parseToml(formatMcpServer(name, server), { integersAsBigInt: "asNeeded" });
+    const declared = rendered.mcp_servers[name];
+    const mergedServer = mergeManagedFields(currentServers[name], declared);
+    blocks.push(managedValueMatches(declared, mergedServer) ? formatMcpServer(name, server) : stringifyToml({ mcp_servers: { [name]: mergedServer } }).trimEnd());
+  }
+  const merged = appendMcpServers(removeManagedMcpSections(current, Object.keys(servers)), blocks);
+  parseToml(merged, { integersAsBigInt: "asNeeded" });
+  await mkdir8(dirname14(destPath), { recursive: true });
   await writeFile8(destPath, merged, "utf8");
 }
 function mismatchedCodexTomlMcpServers(source, currentContent) {
@@ -20465,7 +20688,7 @@ function isPlainRecord(value) {
 }
 function extractMcpServers(source) {
   const raw = isRecord2(source.mcpServers) ? source.mcpServers : source;
-  const servers = {};
+  const servers = /* @__PURE__ */ Object.create(null);
   for (const [name, value] of Object.entries(raw)) {
     if (!isRecord2(value)) continue;
     servers[name] = value;
@@ -20476,23 +20699,39 @@ function extractMcpServers(source) {
   return servers;
 }
 function removeManagedMcpSections(content, serverNames) {
-  if (serverNames.length === 0 || content.trim() === "") return content;
   const names = new Set(serverNames);
-  const lines = content.split(/\r?\n/);
   const kept = [];
   let skipping = false;
-  for (const line of lines) {
-    const section = line.match(/^\s*\[([^\]]+)]\s*$/)?.[1];
-    if (section) {
-      const match = section.match(/^mcp_servers\.([^.\]]+)(?:\.|$)/);
-      skipping = match ? names.has(unquoteTomlKey(match[1] ?? "")) : false;
+  let offset = 0;
+  for (const line of content.split(/(?<=\n)/)) {
+    if (line.trimStart().startsWith("[")) {
+      try {
+        parseToml(content.slice(0, offset), { integersAsBigInt: "asNeeded" });
+        const header = parseToml(line, { integersAsBigInt: "asNeeded" });
+        const servers = isPlainRecord(header.mcp_servers) ? header.mcp_servers : {};
+        skipping = Object.keys(servers).some((name) => names.has(name));
+      } catch {
+      }
     }
     if (!skipping) kept.push(line);
+    offset += line.length;
   }
-  return kept.join("\n").replace(/\n{3,}$/g, "\n\n");
+  return kept.join("");
+}
+function mergeManagedFields(current, declared) {
+  if (!isPlainRecord(declared)) return declared;
+  const merged = isPlainRecord(current) ? { ...current } : {};
+  for (const [key, value] of Object.entries(declared)) {
+    Object.defineProperty(merged, key, {
+      value: mergeManagedFields(Object.hasOwn(merged, key) ? merged[key] : void 0, value),
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return merged;
 }
-function appendMcpServers(content, servers) {
-  const blocks = Object.entries(servers).sort(([a], [b]) => a.localeCompare(b)).map(([name, server]) => formatMcpServer(name, server));
+function appendMcpServers(content, blocks) {
   const prefix = content.trimEnd();
   return `${prefix ? `${prefix}
 
@@ -20572,14 +20811,14 @@ var init_toml_merge = __esm({
 });
 
 // src/install/yaml-merge.ts
-import { mkdir as mkdir9, readFile as readFile17, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname14 } from "path";
+import { mkdir as mkdir9, readFile as readFile18, writeFile as writeFile9 } from "fs/promises";
+import { dirname as dirname15 } from "path";
 import { parse as parse7, stringify } from "yaml";
 async function mergeYamlFile(sourcePath, destPath) {
-  const source = parseYamlValue(await readFile17(sourcePath, "utf8"));
-  const current = await pathExists(destPath) ? parseYamlValue(await readFile17(destPath, "utf8")) : {};
+  const source = parseYamlValue(await readFile18(sourcePath, "utf8"));
+  const current = await pathExists(destPath) ? parseYamlValue(await readFile18(destPath, "utf8")) : {};
   const merged = deepMerge2(current, source);
-  await mkdir9(dirname14(destPath), { recursive: true });
+  await mkdir9(dirname15(destPath), { recursive: true });
   await writeFile9(destPath, stringify(merged), "utf8");
 }
 function parseYamlValue(content) {
@@ -20637,8 +20876,8 @@ var init_yaml_merge = __esm({
 });
 
 // src/install/merge-removal.ts
-import { mkdir as mkdir10, readFile as readFile18, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname15 } from "path";
+import { mkdir as mkdir10, readFile as readFile19, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname16 } from "path";
 import { parse as parse8, stringify as stringify2 } from "yaml";
 function assertExactMergeContribution(contribution, strategy, currentContent) {
   if (strategy === "codex-toml-mcp") {
@@ -20715,7 +20954,7 @@ async function mergeRemovalForInstall(sourcePath, strategy, currentContent, opti
   return introducedMergeContent(parseMergeDestination(currentContent, strategy), source);
 }
 async function removeMergeContribution(destPath, strategy, removal) {
-  const content = await readFile18(destPath, "utf8");
+  const content = await readFile19(destPath, "utf8");
   if (strategy === "codex-toml-mcp") {
     const servers = isRecord4(removal.mcpServers) ? removal.mcpServers : removal;
     await writeFile10(destPath, removeCodexTomlMcpSections(content, Object.keys(servers)), "utf8");
@@ -20723,7 +20962,7 @@ async function removeMergeContribution(destPath, strategy, removal) {
   }
   const current = parseMergeDestination(content, strategy);
   removeIntroducedContent(current, removal);
-  await mkdir10(dirname15(destPath), { recursive: true });
+  await mkdir10(dirname16(destPath), { recursive: true });
   await writeFile10(destPath, strategy === "yaml-deep" ? stringify2(current) : `${JSON.stringify(current, null, 2)}
 `, "utf8");
 }
@@ -20739,7 +20978,7 @@ async function readMergeSource(sourcePath, strategy) {
   if (strategy === "openclaw-json-deep") {
     return requireRecord(await renderOpenClawJsonMergeSource(sourcePath), "OpenClaw JSON merge source");
   }
-  const content = await readFile18(sourcePath, "utf8");
+  const content = await readFile19(sourcePath, "utf8");
   if (strategy === "yaml-deep") return requireRecord(normalizeYamlValue2(parse8(content)), "YAML merge source");
   return requireRecord(JSON.parse(content), "JSON merge source");
 }
@@ -20991,9 +21230,9 @@ var init_desired = __esm({
 
 // src/install/instructions-block.ts
 import { createHash as createHash12 } from "crypto";
-import { mkdtemp as mkdtemp2, readFile as readFile19, realpath as realpath2, rm as rm6, writeFile as writeFile11 } from "fs/promises";
+import { mkdtemp as mkdtemp2, readFile as readFile20, realpath as realpath2, rm as rm6, writeFile as writeFile11 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { basename as basename2, dirname as dirname16, join as join16, relative as relative11 } from "path";
+import { basename as basename2, dirname as dirname17, join as join17, relative as relative11 } from "path";
 function exactManagedInstructionBlockSnapshot(content, selector) {
   const beginCount = [...content.matchAll(new RegExp(`<!-- BEGIN openpack:include ${escapeRegex2(selector)}(?=\\s|-->)`, "gu"))].length;
   const endCount = [...content.matchAll(new RegExp(`<!-- END openpack:include ${escapeRegex2(selector)}(?=\\s|-->)`, "gu"))].length;
@@ -21044,7 +21283,7 @@ function exactManagedInstructionBlockSnapshot(content, selector) {
   };
 }
 async function desiredManagedInstructionBlockHash(sourcePath) {
-  const source = await readFile19(sourcePath, "utf8");
+  const source = await readFile20(sourcePath, "utf8");
   return hashText(managedBlockBody(source));
 }
 async function readManagedInstructionBlockState(destPath, selector, transport) {
@@ -21064,7 +21303,7 @@ async function readManagedInstructionBlockState(destPath, selector, transport) {
   };
 }
 async function writeManagedInstructionBlock(sourcePath, destPath, selector, transport, options = {}) {
-  const source = await readFile19(sourcePath, "utf8");
+  const source = await readFile20(sourcePath, "utf8");
   const desired = renderManagedInstructionBlock(selector, source);
   const existing = await readOptionalText(destPath, transport);
   const merged = upsertManagedInstructionBlock(existing ?? "", selector, desired.block, options);
@@ -21176,7 +21415,7 @@ function assertCleanBlock(block, selector) {
   }
 }
 function referencesAgentsMd(content, claudePath, agentsPath) {
-  const claudeDir = dirname16(claudePath);
+  const claudeDir = dirname17(claudePath);
   for (const rawLine of content.split(/\r?\n/)) {
     const line = rawLine.trim();
     const atImport = /^@import\s+(.+)$/i.exec(line);
@@ -21185,8 +21424,8 @@ function referencesAgentsMd(content, claudePath, agentsPath) {
     if (!referenced) continue;
     const cleaned = referenced.trim().replace(/^["']|["']$/g, "");
     if (!/AGENTS\.md$/i.test(cleaned)) continue;
-    const candidate = cleaned.startsWith("/") ? cleaned : join16(claudeDir, cleaned);
-    if (relative11(dirname16(agentsPath), candidate).replaceAll("\\", "/") === "AGENTS.md") return true;
+    const candidate = cleaned.startsWith("/") ? cleaned : join17(claudeDir, cleaned);
+    if (relative11(dirname17(agentsPath), candidate).replaceAll("\\", "/") === "AGENTS.md") return true;
     if (candidate === agentsPath) return true;
   }
   return false;
@@ -21205,8 +21444,8 @@ async function writeTextWithTransport(path, content, transport) {
     await transport.writeFileAtomic(path, content);
     return;
   }
-  const tempRoot = await mkdtemp2(join16(tmpdir3(), "agentwheel-instructions-"));
-  const localPath = join16(tempRoot, basename2(path) || "instructions.md");
+  const tempRoot = await mkdtemp2(join17(tmpdir3(), "agentwheel-instructions-"));
+  const localPath = join17(tempRoot, basename2(path) || "instructions.md");
   try {
     await writeFile11(localPath, content, "utf8");
     await transport.atomicCopy(localPath, path, "file");
@@ -21244,9 +21483,9 @@ __export(apply_exports, {
 });
 import { execFile as execFile5 } from "child_process";
 import { createHash as createHash13, randomUUID as randomUUID3 } from "crypto";
-import { chmod as chmod3, link as link2, lstat as lstat6, mkdir as mkdir11, mkdtemp as mkdtemp3, open as open5, readFile as readFile20, rm as rm7, writeFile as writeFile12 } from "fs/promises";
+import { chmod as chmod3, link as link2, lstat as lstat6, mkdir as mkdir11, mkdtemp as mkdtemp3, open as open5, readFile as readFile21, rm as rm7, writeFile as writeFile12 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { basename as basename3, dirname as dirname17, join as join17, resolve as resolve20 } from "path";
+import { basename as basename3, dirname as dirname18, join as join18, resolve as resolve20 } from "path";
 import { promisify as promisify5 } from "util";
 async function applyInstallPlan(plan, sourceLock, options = {}) {
   return applyPlanTransactionally(plan, { ...options, sourceLock });
@@ -21346,6 +21585,10 @@ async function assertRuntimeStateRevision(plan, transport) {
 async function applyPlanTransactionally(plan, options = {}) {
   const transport = options.transport ?? localTransport;
   const scope = { installationType: plan.installationType, stateKey: plan.stateKey };
+  const openClawAcceptCapabilities = createOpenClawCapabilityDetector(async (args) => {
+    if (transport.kind === "local") return (await execFileAsync4("openclaw", args, { timeout: 1e4 })).stdout;
+    return transport.execFile?.("openclaw", args, { cwd: plan.targetRoot });
+  });
   if (plan.hasBlockingChanges) {
     const blockers = plan.operations.filter((operation) => operation.action === "drift" || operation.action === "conflict");
     throw new Error(`Refusing to apply with blocking changes: ${blockers.map((item) => item.relativeDestPath).join(", ")}`);
@@ -21406,6 +21649,7 @@ async function applyPlanTransactionally(plan, options = {}) {
         transport,
         now,
         executePlugins: options.executePlugins,
+        openClawAcceptCapabilities,
         graphLockDigest,
         plan
       });
@@ -21641,7 +21885,7 @@ async function assertCommittedJournalState(journal, expectedManifest, transport)
     }
   }
   if (journal.workspaceConfigPath && journal.workspaceConfig) {
-    const actual = JSON.parse(await readFile20(journal.workspaceConfigPath, "utf8"));
+    const actual = JSON.parse(await readFile21(journal.workspaceConfigPath, "utf8"));
     if (canonicalJson5(actual) !== canonicalJson5(journal.workspaceConfig)) {
       throw new Error(`Workspace config postcheck failed for ${journal.workspaceConfigPath}.`);
     }
@@ -21663,7 +21907,7 @@ async function assertMetadataAuditGuards(journal, after, transport, requireAfter
       throw new Error("Metadata-audit content digest is invalid.");
     }
     try {
-      if (await readFile20(path, "utf8") !== file2.content) throw new Error(`Metadata-audit file changed: ${path}`);
+      if (await readFile21(path, "utf8") !== file2.content) throw new Error(`Metadata-audit file changed: ${path}`);
     } catch (error46) {
       if (error46.code !== "ENOENT" || requireAfter) throw error46;
     }
@@ -21714,7 +21958,7 @@ async function createPrivateAuditDirectory(path) {
   } catch (error46) {
     if (error46.code !== "ENOENT") throw error46;
   }
-  await createPrivateAuditDirectory(dirname17(path));
+  await createPrivateAuditDirectory(dirname18(path));
   try {
     await mkdir11(path, { mode: 448 });
   } catch (error46) {
@@ -21725,14 +21969,14 @@ async function createPrivateAuditDirectory(path) {
   }
   await chmod3(path, 448);
   await syncMetadataPath(path, true);
-  await syncMetadataPath(dirname17(path), true);
+  await syncMetadataPath(dirname18(path), true);
 }
 async function writeAuditFileExclusive(path, content, validateCallerPath) {
   await assertNoSymlinkPath2(path);
-  await createPrivateAuditDirectory(dirname17(path));
+  await createPrivateAuditDirectory(dirname18(path));
   await assertNoSymlinkPath2(path);
   await validateCallerPath();
-  await syncMetadataPath(dirname17(dirname17(path)), true);
+  await syncMetadataPath(dirname18(dirname18(path)), true);
   const temporary = `${path}.pending-${randomUUID3()}`;
   try {
     const handle = await open5(temporary, "wx", 384);
@@ -21746,9 +21990,9 @@ async function writeAuditFileExclusive(path, content, validateCallerPath) {
     try {
       await link2(temporary, path);
     } catch (error46) {
-      if (error46.code !== "EEXIST" || await readFile20(path, "utf8") !== content) throw error46;
+      if (error46.code !== "EEXIST" || await readFile21(path, "utf8") !== content) throw error46;
     }
-    const directory = await open5(dirname17(path), "r");
+    const directory = await open5(dirname18(path), "r");
     try {
       await directory.sync();
     } finally {
@@ -21771,7 +22015,7 @@ async function applyOperation(operation, context) {
       throw new Error(`Invalid plugin operation missing hash: ${operation.relativeDestPath}`);
     }
     if (context.executePlugins) {
-      await executePluginInstall(operation, transport);
+      await executePluginInstall(operation, transport, context.openClawAcceptCapabilities);
     }
     return manifestEntryForOperation(operation, {
       now,
@@ -21931,8 +22175,15 @@ async function applyOperation(operation, context) {
   }
   return void 0;
 }
-async function executePluginInstall(operation, transport) {
-  const commands = semanticInstallCommands(operation);
+async function executePluginInstall(operation, transport, openClawAcceptCapabilities) {
+  const commands = await Promise.all(semanticInstallCommands(operation).map(async (command) => {
+    if (command.length !== 5 || command.slice(0, 4).join(" ") !== "openclaw plugins install --force") return command;
+    return openClawPluginInstallCommand({
+      path: command[4],
+      dryRun: false,
+      acceptCapabilities: await openClawAcceptCapabilities?.() ?? false
+    });
+  }));
   if (commands.length === 0) throw new Error(`Invalid plugin operation missing command: ${operation.relativeDestPath}`);
   if (!operation.sourcePath) {
     throw new Error(`Invalid plugin operation missing source path: ${operation.relativeDestPath}`);
@@ -21980,10 +22231,10 @@ async function prepareSemanticPluginState(operation, transport) {
 async function prepareClaudeMarketplace(operation, transport) {
   const spec = requireSemanticPluginState(operation);
   const marketplaceName = requireMarketplaceName(operation);
-  const marketplaceRoot = join17(spec.stateRoot, "marketplace");
+  const marketplaceRoot = join18(spec.stateRoot, "marketplace");
   await transport.rm(spec.stateRoot);
-  await transport.atomicCopy(requireSourcePath(operation), join17(marketplaceRoot, "plugins", spec.pluginName), operation.kind);
-  await transport.writeJsonAtomic(join17(marketplaceRoot, ".claude-plugin", "marketplace.json"), {
+  await transport.atomicCopy(requireSourcePath(operation), join18(marketplaceRoot, "plugins", spec.pluginName), operation.kind);
+  await transport.writeJsonAtomic(join18(marketplaceRoot, ".claude-plugin", "marketplace.json"), {
     name: marketplaceName,
     owner: { name: "Agentwheel" },
     plugins: [
@@ -21998,10 +22249,10 @@ async function prepareClaudeMarketplace(operation, transport) {
 async function prepareCodexMarketplace(operation, transport) {
   const spec = requireSemanticPluginState(operation);
   const marketplaceName = requireMarketplaceName(operation);
-  const marketplaceRoot = join17(spec.stateRoot, "marketplace");
+  const marketplaceRoot = join18(spec.stateRoot, "marketplace");
   await transport.rm(spec.stateRoot);
-  await transport.atomicCopy(requireSourcePath(operation), join17(marketplaceRoot, "plugins", spec.pluginName), operation.kind);
-  await transport.writeJsonAtomic(join17(marketplaceRoot, ".agents", "plugins", "marketplace.json"), {
+  await transport.atomicCopy(requireSourcePath(operation), join18(marketplaceRoot, "plugins", spec.pluginName), operation.kind);
+  await transport.writeJsonAtomic(join18(marketplaceRoot, ".agents", "plugins", "marketplace.json"), {
     name: marketplaceName,
     interface: {
       displayName: "Agentwheel"
@@ -22025,11 +22276,11 @@ async function prepareCodexMarketplace(operation, transport) {
 async function prepareCopilotPlugin(operation, transport) {
   const spec = requireSemanticPluginState(operation);
   await transport.rm(spec.stateRoot);
-  await transport.atomicCopy(requireSourcePath(operation), join17(spec.stateRoot, "plugin"), operation.kind);
+  await transport.atomicCopy(requireSourcePath(operation), join18(spec.stateRoot, "plugin"), operation.kind);
 }
 async function prepareHermesGitShim(operation, transport) {
   const spec = requireSemanticPluginState(operation);
-  const repoRoot = join17(spec.stateRoot, "repo");
+  const repoRoot = join18(spec.stateRoot, "repo");
   await transport.rm(spec.stateRoot);
   await transport.atomicCopy(requireSourcePath(operation), repoRoot, operation.kind);
   if (!transport.execFile) {
@@ -22084,8 +22335,8 @@ async function executeSemanticCommands(operation, commands, transport, options =
   if (!operation.sourcePath) {
     throw new Error(`Invalid semantic plugin operation missing source path: ${operation.relativeDestPath}`);
   }
-  const stagingRoot = join17(operation.destPath, ".agentwheel", "plugin-staging", `${process.pid}-${Date.now()}`);
-  const remoteSourcePath = join17(stagingRoot, basename3(operation.sourcePath));
+  const stagingRoot = join18(operation.destPath, ".agentwheel", "plugin-staging", `${process.pid}-${Date.now()}`);
+  const remoteSourcePath = join18(stagingRoot, basename3(operation.sourcePath));
   try {
     await transport.atomicCopy(operation.sourcePath, remoteSourcePath, operation.kind);
     for (const [command, ...args] of commands) {
@@ -22352,8 +22603,8 @@ async function mergeWithTransport(sourcePath, destPath, transport, merge2) {
     await merge2(sourcePath, destPath);
     return;
   }
-  const tempRoot = await mkdtemp3(join17(tmpdir4(), "agentwheel-merge-"));
-  const localDest = join17(tempRoot, basename3(destPath) || "merged");
+  const tempRoot = await mkdtemp3(join18(tmpdir4(), "agentwheel-merge-"));
+  const localDest = join18(tempRoot, basename3(destPath) || "merged");
   try {
     if (await transport.pathExists(destPath)) {
       await writeFile12(localDest, await transport.readFile(destPath), "utf8");
@@ -22369,8 +22620,8 @@ async function removeMergeWithTransport(destPath, strategy, removal, transport)
     await removeMergeContribution(destPath, strategy, removal);
     return;
   }
-  const tempRoot = await mkdtemp3(join17(tmpdir4(), "agentwheel-merge-remove-"));
-  const localDest = join17(tempRoot, basename3(destPath) || "merged");
+  const tempRoot = await mkdtemp3(join18(tmpdir4(), "agentwheel-merge-remove-"));
+  const localDest = join18(tempRoot, basename3(destPath) || "merged");
   try {
     await writeFile12(localDest, await transport.readFile(destPath), "utf8");
     await removeMergeContribution(localDest, strategy, removal);
@@ -22380,8 +22631,8 @@ async function removeMergeWithTransport(destPath, strategy, removal, transport)
   }
 }
 async function mergeOpenClawJsonWithTransport(sourcePath, destPath, transport) {
-  const tempRoot = await mkdtemp3(join17(tmpdir4(), "agentwheel-openclaw-merge-"));
-  const localDest = join17(tempRoot, basename3(destPath) || "openclaw.json");
+  const tempRoot = await mkdtemp3(join18(tmpdir4(), "agentwheel-openclaw-merge-"));
+  const localDest = join18(tempRoot, basename3(destPath) || "openclaw.json");
   const validationPath = transport.kind === "local" ? localDest : `${destPath}.validate-agentwheel-${process.pid}-${Date.now()}`;
   try {
     if (await transport.pathExists(destPath)) {
@@ -22407,8 +22658,8 @@ async function validateOpenClawConfig(configPath, destPath, transport) {
   if (!transport.execFile) {
     throw new Error(`Cannot validate OpenClaw config over ${transport.description}: transport does not support command execution.`);
   }
-  const openClawHome = dirname17(destPath);
-  const bundledBin = join17(openClawHome, "npm", "node_modules", ".bin", "openclaw");
+  const openClawHome = dirname18(destPath);
+  const bundledBin = join18(openClawHome, "npm", "node_modules", ".bin", "openclaw");
   const script = String.raw`
 set -euo pipefail
 cfg=$1
@@ -22436,6 +22687,7 @@ var init_apply = __esm({
     init_declarations();
     init_graph_lock();
     init_transport();
+    init_openclaw2();
     init_run_as_policy();
     init_json_merge();
     init_openclaw_json_merge();
@@ -22494,7 +22746,7 @@ import { createHash as createHash32 } from "crypto";
 import { existsSync } from "fs";
 import { mkdir as mkdir28, mkdtemp as mkdtemp6, readFile as readFile45, realpath as realpath4, rm as rm16, writeFile as writeFile24 } from "fs/promises";
 import { homedir as homedir18, tmpdir as tmpdir7 } from "os";
-import { basename as basename24, dirname as dirname41, isAbsolute as isAbsolute17, join as join66, relative as relative22, resolve as resolve48, sep as sep12 } from "path";
+import { basename as basename24, dirname as dirname42, isAbsolute as isAbsolute17, join as join66, relative as relative22, resolve as resolve48, sep as sep12 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { Command } from "commander";
 
@@ -22586,8 +22838,8 @@ import { basename as basename8, join as join28, relative as relative12 } from "p
 
 // src/staging/codex-subagents.ts
 init_fs();
-import { mkdir as mkdir12, readFile as readFile21, writeFile as writeFile13 } from "fs/promises";
-import { basename as basename4, dirname as dirname18, join as join18 } from "path";
+import { mkdir as mkdir12, readFile as readFile22, writeFile as writeFile13 } from "fs/promises";
+import { basename as basename4, dirname as dirname19, join as join19 } from "path";
 import { parse as parseYaml } from "yaml";
 var requiredCodexAgentFields = ["name", "description", "developer_instructions"];
 async function renderCodexSubagents(artifacts, stageRoot, adapter) {
@@ -22611,36 +22863,36 @@ async function renderCodexSubagents(artifacts, stageRoot, adapter) {
 async function renderCodexSubagent(artifact, stageRoot) {
   const sourcePath = artifact.stagedPath ?? artifact.sourcePath;
   const agentName = codexAgentName(artifact);
-  const renderedPath = join18(stageRoot, ".agentwheel-rendered", "codex-subagents", `${agentName}.toml`);
+  const renderedPath = join19(stageRoot, ".agentwheel-rendered", "codex-subagents", `${agentName}.toml`);
   const lowerSourcePath = sourcePath.toLowerCase();
   if (artifact.kind === "file" && (artifact.name.toLowerCase().endsWith(".toml") || lowerSourcePath.endsWith(".toml"))) {
-    const content = await readFile21(sourcePath, "utf8");
+    const content = await readFile22(sourcePath, "utf8");
     validateCodexAgentToml(content, sourcePath);
     return {
       ...artifact,
       name: agentName,
-      relativePath: join18("subagents", `${agentName}.toml`),
+      relativePath: join19("subagents", `${agentName}.toml`),
       kind: "file",
       hash: await hashPath(sourcePath)
     };
   }
-  const markdownPath = artifact.kind === "dir" ? join18(sourcePath, "AGENTS.md") : sourcePath;
+  const markdownPath = artifact.kind === "dir" ? join19(sourcePath, "AGENTS.md") : sourcePath;
   if (artifact.kind === "dir" && !await pathExists(markdownPath)) {
     throw new Error(`Codex subagent directory ${artifact.relativePath} must contain AGENTS.md.`);
   }
   if (artifact.kind === "file" && !artifact.name.toLowerCase().endsWith(".md") && !lowerSourcePath.endsWith(".md")) {
     throw new Error(`Codex subagent ${artifact.relativePath} must be a .toml file, .md file, or directory containing AGENTS.md.`);
   }
-  const markdown = await readFile21(markdownPath, "utf8");
+  const markdown = await readFile22(markdownPath, "utf8");
   const toml = markdownToCodexAgentToml(agentName, markdown);
-  await mkdir12(dirname18(renderedPath), { recursive: true });
+  await mkdir12(dirname19(renderedPath), { recursive: true });
   await writeFile13(renderedPath, toml, "utf8");
   return {
     ...artifact,
     name: agentName,
     sourcePath: renderedPath,
     stagedPath: renderedPath,
-    relativePath: join18("subagents", `${agentName}.toml`),
+    relativePath: join19("subagents", `${agentName}.toml`),
     kind: "file",
     hash: await hashPath(renderedPath)
   };
@@ -22715,8 +22967,8 @@ function escapeRegExp2(value) {
 
 // src/staging/copilot-artifacts.ts
 init_fs();
-import { mkdir as mkdir13, readFile as readFile22, writeFile as writeFile14 } from "fs/promises";
-import { basename as basename5, dirname as dirname19, join as join19 } from "path";
+import { mkdir as mkdir13, readFile as readFile23, writeFile as writeFile14 } from "fs/promises";
+import { basename as basename5, dirname as dirname20, join as join20 } from "path";
 async function renderCopilotArtifacts(artifacts, stageRoot, adapter) {
   if (adapter?.name !== "copilot") return artifacts;
   const names = /* @__PURE__ */ new Set();
@@ -22738,23 +22990,23 @@ async function renderCopilotArtifacts(artifacts, stageRoot, adapter) {
 async function renderCopilotSubagent(artifact, stageRoot) {
   const sourcePath = artifact.stagedPath ?? artifact.sourcePath;
   const agentName = copilotAgentName(artifact);
-  const renderedPath = join19(stageRoot, ".agentwheel-rendered", "copilot-subagents", `${agentName}.agent.md`);
-  const markdownPath = artifact.kind === "dir" ? join19(sourcePath, "AGENTS.md") : sourcePath;
+  const renderedPath = join20(stageRoot, ".agentwheel-rendered", "copilot-subagents", `${agentName}.agent.md`);
+  const markdownPath = artifact.kind === "dir" ? join20(sourcePath, "AGENTS.md") : sourcePath;
   if (artifact.kind === "dir" && !await pathExists(markdownPath)) {
     throw new Error(`Copilot subagent directory ${artifact.relativePath} must contain AGENTS.md.`);
   }
   if (artifact.kind === "file" && !artifact.name.toLowerCase().endsWith(".md")) {
     throw new Error(`Copilot subagent ${artifact.relativePath} must be a .md file or directory containing AGENTS.md.`);
   }
-  const markdown = await readFile22(markdownPath, "utf8");
-  await mkdir13(dirname19(renderedPath), { recursive: true });
+  const markdown = await readFile23(markdownPath, "utf8");
+  await mkdir13(dirname20(renderedPath), { recursive: true });
   await writeFile14(renderedPath, ensureCopilotAgentDescription(agentName, markdown), "utf8");
   return {
     ...artifact,
     name: `${agentName}.agent.md`,
     sourcePath: renderedPath,
     stagedPath: renderedPath,
-    relativePath: join19("subagents", `${agentName}.agent.md`),
+    relativePath: join20("subagents", `${agentName}.agent.md`),
     kind: "file",
     hash: await hashPath(renderedPath)
   };
@@ -22802,8 +23054,8 @@ function yamlString(value) {
 
 // src/staging/openclaw-subagents.ts
 init_fs();
-import { mkdir as mkdir14, readFile as readFile23, writeFile as writeFile15 } from "fs/promises";
-import { basename as basename6, dirname as dirname20, join as join20 } from "path";
+import { mkdir as mkdir14, readFile as readFile24, writeFile as writeFile15 } from "fs/promises";
+import { basename as basename6, dirname as dirname21, join as join21 } from "path";
 async function renderOpenClawSubagents(artifacts, stageRoot, adapter) {
   if (adapter?.name !== "openclaw") return artifacts;
   const names = /* @__PURE__ */ new Set();
@@ -22825,28 +23077,28 @@ async function renderOpenClawSubagents(artifacts, stageRoot, adapter) {
 async function renderOpenClawSubagent(artifact, stageRoot) {
   const sourcePath = artifact.stagedPath ?? artifact.sourcePath;
   const agentId = openClawAgentId(artifact);
-  const markdownPath = artifact.kind === "dir" ? join20(sourcePath, "AGENTS.md") : sourcePath;
+  const markdownPath = artifact.kind === "dir" ? join21(sourcePath, "AGENTS.md") : sourcePath;
   if (artifact.kind === "dir" && !await pathExists(markdownPath)) {
     throw new Error(`OpenClaw subagent directory ${artifact.relativePath} must contain AGENTS.md.`);
   }
   if (artifact.kind === "file" && !artifact.name.toLowerCase().endsWith(".md") && !sourcePath.toLowerCase().endsWith(".md")) {
     throw new Error(`OpenClaw subagent ${artifact.relativePath} must be a .md file or directory containing AGENTS.md.`);
   }
-  const parsed = splitFrontmatter3(await readFile23(markdownPath, "utf8"));
+  const parsed = splitFrontmatter3(await readFile24(markdownPath, "utf8"));
   const body = parsed.body.trim().length > 0 ? parsed.body.trim() : `# ${titleFromAgentId(agentId)}
 
 ${parsed.description ?? `OpenClaw subagent ${agentId}.`}`;
-  const renderedPath = join20(stageRoot, ".agentwheel-rendered", "openclaw-subagents", agentId, "AGENTS.md");
-  await mkdir14(dirname20(renderedPath), { recursive: true });
+  const renderedPath = join21(stageRoot, ".agentwheel-rendered", "openclaw-subagents", agentId, "AGENTS.md");
+  await mkdir14(dirname21(renderedPath), { recursive: true });
   await writeFile15(renderedPath, `${body}
 `, "utf8");
-  const renderedDir = dirname20(renderedPath);
+  const renderedDir = dirname21(renderedPath);
   return {
     ...artifact,
     name: agentId,
     sourcePath: renderedDir,
     stagedPath: renderedDir,
-    relativePath: join20("subagents", agentId),
+    relativePath: join21("subagents", agentId),
     kind: "dir",
     hash: await hashPath(renderedDir)
   };
@@ -22871,15 +23123,15 @@ function titleFromAgentId(agentId) {
 }
 
 // src/targets/plugins/claude.ts
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 
 // src/targets/plugins/common.ts
 init_fs();
-import { readFile as readFile24 } from "fs/promises";
-import { join as join21 } from "path";
+import { readFile as readFile25 } from "fs/promises";
+import { join as join22 } from "path";
 import { parseDocument } from "yaml";
 function pluginStateRoot(request) {
-  return join21(
+  return join22(
     request.targetRoot,
     ".agentwheel",
     "plugins",
@@ -22897,16 +23149,16 @@ function safeNameSegment(value) {
   return normalized.length > 0 ? normalized : "unnamed";
 }
 async function jsonPluginName(root, relativeManifestPath, fallback) {
-  const manifestPath = join21(root, relativeManifestPath);
+  const manifestPath = join22(root, relativeManifestPath);
   if (!await pathExists(manifestPath)) return fallback;
-  const parsed = JSON.parse(await readFile24(manifestPath, "utf8"));
+  const parsed = JSON.parse(await readFile25(manifestPath, "utf8"));
   return typeof parsed.name === "string" && parsed.name.trim().length > 0 ? parsed.name.trim() : fallback;
 }
 async function yamlPluginName(root, relativeManifestPaths, fallback) {
   for (const relativeManifestPath of relativeManifestPaths) {
-    const manifestPath = join21(root, relativeManifestPath);
+    const manifestPath = join22(root, relativeManifestPath);
     if (!await pathExists(manifestPath)) continue;
-    const document = parseDocument(await readFile24(manifestPath, "utf8"));
+    const document = parseDocument(await readFile25(manifestPath, "utf8"));
     const parsed = document.toJSON();
     if (!isRecord5(parsed)) continue;
     for (const key of ["name", "module", "package"]) {
@@ -22935,7 +23187,7 @@ async function claudePluginSpec(request) {
     packageName: request.artifact.packageName,
     installName: request.installName
   });
-  const marketplaceRoot = join22(stateRoot, "marketplace");
+  const marketplaceRoot = join23(stateRoot, "marketplace");
   const scope = claudeScope(request.installationType);
   const selector = `${pluginName}@${marketplaceName}`;
   return {
@@ -22960,7 +23212,7 @@ function claudeScope(installationType) {
 }
 
 // src/targets/plugins/codex.ts
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 async function codexPluginSpec(request) {
   const pluginName = await jsonPluginName(request.sourcePath, ".codex-plugin/plugin.json", request.installName);
   const marketplaceName = agentwheelMarketplaceName(request.artifact.packageName, pluginName);
@@ -22971,7 +23223,7 @@ async function codexPluginSpec(request) {
     packageName: request.artifact.packageName,
     installName: request.installName
   });
-  const marketplaceRoot = join23(stateRoot, "marketplace");
+  const marketplaceRoot = join24(stateRoot, "marketplace");
   const selector = `${pluginName}@${marketplaceName}`;
   return {
     runtime: "codex",
@@ -22990,7 +23242,7 @@ async function codexPluginSpec(request) {
 }
 
 // src/targets/plugins/copilot.ts
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 async function copilotPluginSpec(request) {
   if (request.installationType !== "user") {
     throw new Error("Copilot plugins are persistent user-level installs only; pass --installation-type user.");
@@ -23003,7 +23255,7 @@ async function copilotPluginSpec(request) {
     packageName: request.artifact.packageName,
     installName: request.installName
   });
-  const pluginRoot = join24(stateRoot, "plugin");
+  const pluginRoot = join25(stateRoot, "plugin");
   return {
     runtime: "copilot",
     pluginName,
@@ -23014,7 +23266,7 @@ async function copilotPluginSpec(request) {
 }
 
 // src/targets/plugins/hermes.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 async function hermesPluginSpec(request) {
   if (request.installationType !== "user") {
     throw new Error("Hermes plugins are user-level installs only; pass --installation-type user.");
@@ -23027,7 +23279,7 @@ async function hermesPluginSpec(request) {
     packageName: request.artifact.packageName,
     installName: request.installName
   });
-  const repoRoot = join25(stateRoot, "repo");
+  const repoRoot = join26(stateRoot, "repo");
   return {
     runtime: "hermes",
     pluginName,
@@ -23037,64 +23289,8 @@ async function hermesPluginSpec(request) {
   };
 }
 
-// src/targets/plugins/openclaw.ts
-init_fs();
-import { readFile as readFile25 } from "fs/promises";
-import { join as join26 } from "path";
-function openClawPluginInstallCommand(request) {
-  return ["openclaw", "plugins", "install", "--force", request.path];
-}
-function openClawPluginUninstallCommand(pluginName) {
-  return ["openclaw", "plugins", "uninstall", pluginName, "--force"];
-}
-async function openClawPluginSpec(request) {
-  if (request.format === "openclaw-clawhub-plugin") {
-    const metadata = await openClawClawHubPluginMetadata(request.path, request.fallbackPluginName);
-    return {
-      runtime: "openclaw",
-      pluginName: metadata.pluginName,
-      installCommands: [openClawPluginInstallCommand({ path: metadata.installSpec, dryRun: true })],
-      uninstallCommands: [openClawPluginUninstallCommand(metadata.pluginName)]
-    };
-  }
-  const pluginName = await openClawPluginName(request.path, request.fallbackPluginName);
-  return {
-    runtime: "openclaw",
-    pluginName,
-    installCommands: [openClawPluginInstallCommand({ path: request.path, dryRun: true })],
-    uninstallCommands: [openClawPluginUninstallCommand(pluginName)]
-  };
-}
-async function openClawPluginName(root, fallback) {
-  for (const manifestName of ["plugin.json", "openclaw.plugin.json"]) {
-    const manifestPath = join26(root, manifestName);
-    if (!await pathExists(manifestPath)) continue;
-    const parsed = JSON.parse(await readFile25(manifestPath, "utf8"));
-    if (typeof parsed.name === "string" && parsed.name.trim().length > 0) return parsed.name.trim();
-  }
-  return fallback;
-}
-async function openClawClawHubPluginMetadata(root, fallback) {
-  const metadataPath = join26(root, "clawhub.json");
-  if (!await pathExists(metadataPath)) {
-    throw new Error("OpenClaw ClawHub plugins must contain clawhub.json");
-  }
-  const parsed = JSON.parse(await readFile25(metadataPath, "utf8"));
-  const installSpec = stringField(parsed.installSpec);
-  if (!installSpec?.startsWith("clawhub:")) {
-    throw new Error("OpenClaw ClawHub plugin metadata must declare installSpec starting with clawhub:");
-  }
-  const pluginName = stringField(parsed.runtimeId) ?? installNameFor(stringField(parsed.name) ?? fallback);
-  return { installSpec, pluginName };
-}
-function stringField(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
-}
-function installNameFor(value) {
-  return value.split("/").at(-1).replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "clawhub-plugin";
-}
-
 // src/targets/plugins/index.ts
+init_openclaw2();
 async function semanticPluginSpecForArtifact(request) {
   if (request.semantic === "openclaw-plugin") {
     return openClawPluginSpec({
@@ -25391,7 +25587,7 @@ function errorMessage2(error46) {
 
 // src/source/clawhub.ts
 import { mkdir as mkdir15, rm as rm8, writeFile as writeFile16 } from "fs/promises";
-import { basename as basename10, dirname as dirname21, join as join32, resolve as resolve22 } from "path";
+import { basename as basename10, dirname as dirname22, join as join32, resolve as resolve22 } from "path";
 
 // src/model/package.ts
 init_main();
@@ -25964,7 +26160,7 @@ async function writeGeneratedPackage(root, packageInfo) {
   };
   const pluginPath = join32(root, "plugins", pluginId, "clawhub.json");
   await rm8(root, { recursive: true, force: true });
-  await mkdir15(dirname21(pluginPath), { recursive: true });
+  await mkdir15(dirname22(pluginPath), { recursive: true });
   await writeFile16(join32(root, "openpack.json"), `${JSON.stringify({
     schemaVersion: CURRENT_OPENPACK_SCHEMA_VERSION,
     name: `clawhub/${name}`,
@@ -25997,7 +26193,7 @@ function cachePathFor(packageName, cacheRoot) {
 import { execFile as execFile6 } from "child_process";
 import { mkdir as mkdir17, rename as rename6, rm as rm10, stat as stat7 } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { basename as basename11, dirname as dirname23, join as join35, resolve as resolve23, sep as sep8 } from "path";
+import { basename as basename11, dirname as dirname24, join as join35, resolve as resolve23, sep as sep8 } from "path";
 import { promisify as promisify6 } from "util";
 init_fs();
 
@@ -26080,7 +26276,7 @@ function isMissingFile(error46) {
 init_fs();
 import { randomUUID as randomUUID4 } from "crypto";
 import { mkdir as mkdir16, readdir as readdir9, readFile as readFile29, rm as rm9, stat as stat6, writeFile as writeFile17 } from "fs/promises";
-import { dirname as dirname22, join as join34 } from "path";
+import { dirname as dirname23, join as join34 } from "path";
 var snapshotNamePattern = /^(.*)-([0-9a-f]{12})$/i;
 var leaseMarker = ".agentwheel-lease-";
 async function pruneGitCache(cacheRoot, options = {}) {
@@ -26148,7 +26344,7 @@ async function removeGeneratedEntries(root, preserveGit) {
   }
 }
 async function pruneGitCacheUnlocked(cacheRoot, options) {
-  const referencedCommits = await referencedGraphLockCommits(join34(dirname22(cacheRoot), "locks"));
+  const referencedCommits = await referencedGraphLockCommits(join34(dirname23(cacheRoot), "locks"));
   const entries = await readdir9(cacheRoot, { withFileTypes: true });
   const groups = /* @__PURE__ */ new Map();
   for (const entry of entries) {
@@ -26215,7 +26411,7 @@ async function walkGraphLocks(root, visit2) {
   }
 }
 async function hasLiveSnapshotLease(snapshotPath, dryRun) {
-  const directory = dirname22(snapshotPath);
+  const directory = dirname23(snapshotPath);
   const prefix = `${snapshotPath.slice(directory.length + 1)}${leaseMarker}`;
   const entries = await readdir9(directory, { withFileTypes: true });
   let live = false;
@@ -26354,7 +26550,7 @@ var GitSourceDriver = class {
   async fetch(resolved) {
     return withFilesystemLock(`${resolved.resolvedPath}.lock`, resolved.cacheLockTimeoutMs ?? 3e4, async () => {
       const parsed = parseGitSource(resolved.source);
-      const cacheRoot = dirname23(resolved.resolvedPath);
+      const cacheRoot = dirname24(resolved.resolvedPath);
       await mkdir17(cacheRoot, { recursive: true });
       await assertOwnedByCurrentUser(cacheRoot);
       if (await pathExists(resolved.resolvedPath)) await assertOwnedByCurrentUser(resolved.resolvedPath);
@@ -26449,9 +26645,9 @@ async function resolveCommit(checkoutPath, ref) {
   throw lastError;
 }
 async function snapshotCommit(checkoutPath, commit) {
-  const snapshotPath = join35(dirname23(checkoutPath), `${basename11(checkoutPath)}-${commit.slice(0, 12)}`);
+  const snapshotPath = join35(dirname24(checkoutPath), `${basename11(checkoutPath)}-${commit.slice(0, 12)}`);
   if (await pathExists(snapshotPath)) return snapshotPath;
-  const tempPath = join35(dirname23(checkoutPath), `${basename11(snapshotPath)}.tmp-${process.pid}-${Date.now()}`);
+  const tempPath = join35(dirname24(checkoutPath), `${basename11(snapshotPath)}.tmp-${process.pid}-${Date.now()}`);
   const tempIndexPath = `${tempPath}.index`;
   await rm10(tempPath, { recursive: true, force: true });
   await rm10(tempIndexPath, { force: true });
@@ -26489,7 +26685,7 @@ async function assertOwnedByCurrentUser(path) {
 
 // src/source/mcp-registry.ts
 import { mkdir as mkdir18, writeFile as writeFile18 } from "fs/promises";
-import { basename as basename12, dirname as dirname24, join as join36, resolve as resolve24 } from "path";
+import { basename as basename12, dirname as dirname25, join as join36, resolve as resolve24 } from "path";
 init_fs();
 var registryBaseUrl = "https://registry.modelcontextprotocol.io/v0.1";
 var sourcePrefix2 = "mcp-registry:";
@@ -26597,7 +26793,7 @@ function isSafeHttpUrl(value) {
 async function writeGeneratedPackage2(root, server) {
   const serverId = installNameFor3(server.serverName);
   const mcpPath = join36(root, "mcp", `${serverId}.json`);
-  await mkdir18(dirname24(mcpPath), { recursive: true });
+  await mkdir18(dirname25(mcpPath), { recursive: true });
   await writeFile18(join36(root, "openpack.json"), `${JSON.stringify({
     schemaVersion: CURRENT_OPENPACK_SCHEMA_VERSION,
     name: `mcp-registry/${server.serverName}`,
@@ -26631,14 +26827,14 @@ import { createHash as createHash16, randomUUID as randomUUID5 } from "crypto";
 import { execFile as execFile7 } from "child_process";
 import { cp as cp3, mkdir as mkdir19, readFile as readFile30, rename as rename7, rm as rm11 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { basename as basename14, dirname as dirname26, join as join38, resolve as resolve25 } from "path";
+import { basename as basename14, dirname as dirname27, join as join38, resolve as resolve25 } from "path";
 import { promisify as promisify7 } from "util";
 import * as defaultSkillKit from "@skillkit/core";
 
 // src/source/skill-artifacts.ts
 init_fs();
 import { readdir as readdir10, stat as stat8 } from "fs/promises";
-import { basename as basename13, dirname as dirname25, extname as extname2, join as join37 } from "path";
+import { basename as basename13, dirname as dirname26, extname as extname2, join as join37 } from "path";
 async function artifactsFromSkillPaths(paths, packageName) {
   const artifacts = [];
   const seen = /* @__PURE__ */ new Set();
@@ -26675,7 +26871,7 @@ async function artifactFromSkillPath(item, packageName) {
     };
   }
   if (stats.isFile() && basename13(item.path).toLowerCase() === "skill.md") {
-    const dir = dirname25(item.path);
+    const dir = dirname26(item.path);
     const name = sanitizeSkillName(item.name ?? basename13(dir));
     return {
       type: "skills",
@@ -26783,7 +26979,7 @@ var SkillKitSourceDriver = class {
         sourceHash: await hashPath(resolved.resolvedPath)
       };
     }
-    const specCachePath = cachePathFor4(spec, dirname26(dirname26(resolved.resolvedPath)));
+    const specCachePath = cachePathFor4(spec, dirname27(dirname27(resolved.resolvedPath)));
     const refIdentity = resolved.requestedRef ?? "default";
     const lockPath = `${specCachePath}.ref-${createHash16("sha256").update(refIdentity).digest("hex")}.lock`;
     const inflightKey = `${lockPath}\0${requestedCommit ?? "movable"}`;
@@ -26804,11 +27000,11 @@ var SkillKitSourceDriver = class {
       throw new Error("SkillKit provider API unavailable or cannot resolve source. Expected @skillkit/core detectProvider().clone().");
     }
     const materialized = await withFilesystemLock(lockPath, resolved.cacheLockTimeoutMs ?? 3e4, async () => {
-      const immutablePath = requestedCommit ? cachePathFor4(spec, dirname26(dirname26(specCachePath)), requestedCommit) : void 0;
+      const immutablePath = requestedCommit ? cachePathFor4(spec, dirname27(dirname27(specCachePath)), requestedCommit) : void 0;
       if (immutablePath && await pathExists(immutablePath)) {
         return { path: immutablePath, commit: requestedCommit, cacheIdentity: requestedCommit };
       }
-      await mkdir19(dirname26(specCachePath), { recursive: true });
+      await mkdir19(dirname27(specCachePath), { recursive: true });
       const candidatePath = `${specCachePath}.agentwheel-tmp-${process.pid}-${randomUUID5()}`;
       const publishPath = `${candidatePath}.publish`;
       let result;
@@ -26830,7 +27026,7 @@ var SkillKitSourceDriver = class {
             `SkillKit provider resolved ${resolvedIdentity.commit ?? "non-Git content"} instead of requested commit ${requestedCommit}`
           );
         }
-        const cachePath = cachePathFor4(spec, dirname26(dirname26(specCachePath)), resolvedIdentity.cacheKey);
+        const cachePath = cachePathFor4(spec, dirname27(dirname27(specCachePath)), resolvedIdentity.cacheKey);
         if (await pathExists(cachePath)) {
           return { path: cachePath, commit: resolvedIdentity.commit, cacheIdentity: resolvedIdentity.cacheKey };
         }
@@ -27101,7 +27297,7 @@ init_identify();
 
 // src/staging/staging.ts
 import { chmod as chmod4, cp as cp5, mkdir as mkdir22, mkdtemp as mkdtemp4, readdir as readdir13, stat as stat12 } from "fs/promises";
-import { basename as basename19, dirname as dirname30, join as join43, relative as relative16, resolve as resolve29, sep as sep10 } from "path";
+import { basename as basename19, dirname as dirname31, join as join43, relative as relative16, resolve as resolve29, sep as sep10 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 init_fs();
 
@@ -27110,7 +27306,7 @@ init_artifact();
 init_fs();
 import { createHash as createHash17 } from "crypto";
 import { readdir as readdir11, readFile as readFile31, stat as stat10, writeFile as writeFile19 } from "fs/promises";
-import { basename as basename16, dirname as dirname27, extname as extname3, join as join40, relative as relative15, resolve as resolve28, sep as sep9 } from "path";
+import { basename as basename16, dirname as dirname28, extname as extname3, join as join40, relative as relative15, resolve as resolve28, sep as sep9 } 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/;
@@ -27365,11 +27561,11 @@ async function listMarkdownFiles(root) {
 function composeEntriesForFile(artifact, file2) {
   if (!artifact.compose?.length) return [];
   if (artifact.kind === "file") return [resolve28(artifact.stagedPath ?? artifact.sourcePath), resolve28(file2)].every(Boolean) && resolve28(artifact.stagedPath ?? artifact.sourcePath) === resolve28(file2) ? artifact.compose : [];
-  return basename16(file2) === "SKILL.md" && dirname27(file2) === resolve28(artifact.stagedPath ?? artifact.sourcePath) ? artifact.compose : [];
+  return basename16(file2) === "SKILL.md" && dirname28(file2) === resolve28(artifact.stagedPath ?? artifact.sourcePath) ? artifact.compose : [];
 }
 function isPrimaryMarkdownFile(artifact, file2) {
   if (artifact.kind === "file") return resolve28(artifact.stagedPath ?? artifact.sourcePath) === resolve28(file2);
-  return basename16(file2) === "SKILL.md" && dirname27(file2) === resolve28(artifact.stagedPath ?? artifact.sourcePath);
+  return basename16(file2) === "SKILL.md" && dirname28(file2) === resolve28(artifact.stagedPath ?? artifact.sourcePath);
 }
 function orderedForExpansion(artifacts) {
   return [...artifacts].sort((a, b) => Number(a.type === "fragments") - Number(b.type === "fragments"));
@@ -27417,7 +27613,7 @@ function artifactPathMap(artifacts) {
 // src/staging/customize.ts
 init_fs();
 import { cp as cp4, mkdir as mkdir20, readdir as readdir12, readFile as readFile32, writeFile as writeFile20 } from "fs/promises";
-import { dirname as dirname28, join as join41 } from "path";
+import { dirname as dirname29, join as join41 } from "path";
 async function applyCustomizations(artifacts, options) {
   let next = [...artifacts];
   next = await applyReplacements2(next, options, "override", installableArtifactTypes());
@@ -27441,7 +27637,7 @@ async function applyInstructionOverlay(artifacts, options) {
   const managed = await readFile32(artifact.stagedPath ?? artifact.sourcePath, "utf8");
   const local = await readFile32(overlayPath, "utf8");
   const composedPath = join41(options.stageRoot, ".agentwheel-composed", "instructions", "AGENTS.md");
-  await mkdir20(dirname28(composedPath), { recursive: true });
+  await mkdir20(dirname29(composedPath), { recursive: true });
   await writeFile20(
     composedPath,
     [
@@ -27514,7 +27710,7 @@ async function applyReplacements2(artifacts, options, channel, artifactTypes) {
         const artifactKind = entry.isDirectory() ? "dir" : "file";
         const existing = byKey.get(artifactMapKey);
         const stagedPath = join41(options.stageRoot, ".agentwheel-composed", channel, type, entry.name);
-        await mkdir20(dirname28(stagedPath), { recursive: true });
+        await mkdir20(dirname29(stagedPath), { recursive: true });
         await cp4(full, stagedPath, { recursive: artifactKind === "dir", dereference: true });
         byKey.set(artifactMapKey, {
           ...existing,
@@ -27560,7 +27756,7 @@ async function sortedDirEntries2(path) {
 // src/staging/claude-subagents.ts
 init_fs();
 import { mkdir as mkdir21, readFile as readFile33, writeFile as writeFile21 } from "fs/promises";
-import { basename as basename18, dirname as dirname29, join as join42 } from "path";
+import { basename as basename18, dirname as dirname30, join as join42 } from "path";
 async function renderClaudeSubagents(artifacts, stageRoot, adapter) {
   if (adapter?.name !== "claude") return artifacts;
   const names = /* @__PURE__ */ new Set();
@@ -27591,7 +27787,7 @@ async function renderClaudeSubagent(artifact, stageRoot) {
   }
   const content = await readFile33(markdownPath, "utf8");
   const renderedPath = join42(stageRoot, ".agentwheel-rendered", "claude-subagents", `${agentName}.md`);
-  await mkdir21(dirname29(renderedPath), { recursive: true });
+  await mkdir21(dirname30(renderedPath), { recursive: true });
   await writeFile21(renderedPath, content.endsWith("\n") ? content : `${content}
 `, "utf8");
   return {
@@ -27634,7 +27830,7 @@ async function stageResolvedArtifactsRaw(resolved, artifacts, parentDir = tmpdir
   await removeOnFailure(root, async () => {
     for (const artifact of artifacts) {
       const stagedPath = join43(root, artifact.relativePath);
-      await mkdir22(dirname30(stagedPath), { recursive: true });
+      await mkdir22(dirname31(stagedPath), { recursive: true });
       await cp5(artifact.sourcePath, stagedPath, {
         recursive: artifact.kind === "dir",
         dereference: true,
@@ -27740,7 +27936,7 @@ async function copyAsset(asset, source, dest) {
     throw new Error(`Asset include source is not a file or directory: ${source}`);
   }
   if (!asset.include?.length) {
-    await mkdir22(dirname30(dest), { recursive: true });
+    await mkdir22(dirname31(dest), { recursive: true });
     await cp5(source, dest, { recursive: true, dereference: true });
     if (asset.mode === "copy") await normalizeCopiedModes(dest);
     return;
@@ -27752,7 +27948,7 @@ async function copyAsset(asset, source, dest) {
   }
 }
 async function copyAssetFile(source, dest, asset) {
-  await mkdir22(dirname30(dest), { recursive: true });
+  await mkdir22(dirname31(dest), { recursive: true });
   await cp5(source, dest, { dereference: true });
   if (asset.mode === "copy") await chmod4(dest, 420);
 }
@@ -27808,7 +28004,7 @@ init_adapter();
 init_artifact();
 init_workspace();
 import { appendFile, cp as cp6, lstat as lstat7, mkdir as mkdir23, readdir as readdir15, rm as rm13 } from "fs/promises";
-import { dirname as dirname32, join as join46, relative as relative17 } from "path";
+import { dirname as dirname33, join as join46, relative as relative17 } from "path";
 
 // src/resolve/graph.ts
 import { createHash as createHash19 } from "crypto";
@@ -27946,7 +28142,7 @@ import { resolve as resolve31 } from "path";
 // src/registry/client.ts
 import { readFile as readFile35, rm as rm12, stat as stat13 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname31, join as join44, resolve as resolve30 } from "path";
+import { dirname as dirname32, join as join44, resolve as resolve30 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/model/registry.ts
@@ -28067,7 +28263,7 @@ var RegistryClient = class {
       const stats = await stat13(fullPath);
       return readFile35(stats.isDirectory() ? join44(fullPath, "index.json") : fullPath, "utf8");
     }
-    const resolved = await this.git.fetch(await this.git.resolve(source, { cacheRoot: join44(dirname31(this.cachePath), "registry-repos") }));
+    const resolved = await this.git.fetch(await this.git.resolve(source, { cacheRoot: join44(dirname32(this.cachePath), "registry-repos") }));
     return readFile35(join44(resolved.resolvedPath, "index.json"), "utf8");
   }
   warnCompatibility(entries) {
@@ -28438,6 +28634,7 @@ Run without ${lockLabel === "Offline" ? "--offline" : "--frozen-lock"} first.`
     if (!satisfiesVersionRange(fetched.version, requirement.version)) {
       throw new Error(`Package ${fetched.name}@${fetched.version} does not satisfy requested version ${requirement.version}`);
     }
+    const requestedRef = frozen ? frozen.node.requestedRef : fetched.resolved.requestedRef;
     const nodeKey = `${normalized.normalizedSource}\0${fetched.name}`;
     let selectionImport = requirement.selection ? await resolveSelectionImport(fetched.resolved.resolvedPath, fetched.resolved.driver, requirement.selection) : void 0;
     const selected = computeSelectedSelectors(
@@ -28464,7 +28661,7 @@ Run without ${lockLabel === "Offline" ? "--offline" : "--frozen-lock"} first.`
           source: fetched.resolved.source,
           normalizedSource: normalized.normalizedSource,
           driver: fetched.resolved.driver,
-          requestedRef: fetched.resolved.requestedRef,
+          requestedRef,
           resolvedCommit: fetched.resolved.resolvedCommit,
           cacheIdentity: fetched.resolved.cacheIdentity,
           sourceHash: fetched.sourceHash,
@@ -28522,7 +28719,7 @@ Run without ${lockLabel === "Offline" ? "--offline" : "--frozen-lock"} first.`
         alias: requirement.alias,
         source: requirement.source,
         normalizedSource: normalized.normalizedSource,
-        requestedRef: fetched.resolved.requestedRef,
+        requestedRef,
         version: requirement.version,
         mode: requirement.mode,
         optional: requirement.optional,
@@ -29194,7 +29391,7 @@ init_declarations();
 async function remember(workspaceRoot, runtime, text) {
   const overlayPath = join46(workspaceRoot, ".agentwheel", "overlays", runtime, "instructions.local.md");
   declareMutationPath(overlayPath);
-  await mkdir23(dirname32(overlayPath), { recursive: true });
+  await mkdir23(dirname33(overlayPath), { recursive: true });
   await appendFile(overlayPath, `${text.trim()}
 `, "utf8");
   return { overlayPath };
@@ -29227,7 +29424,7 @@ async function ejectArtifact(workspaceRoot, item) {
     } else {
       declareMutationPath(ejectedPath);
     }
-    await mkdir23(dirname32(ejectedPath), { recursive: true });
+    await mkdir23(dirname33(ejectedPath), { recursive: true });
     await rm13(ejectedPath, { recursive: true, force: true });
     await cp6(sourcePath, ejectedPath, { recursive: artifact.kind === "dir", dereference: true });
     return {
@@ -29346,7 +29543,7 @@ init_adapter();
 init_graph_lock();
 import { createHash as createHash21 } from "crypto";
 import { mkdir as mkdir25, readdir as readdir16 } from "fs/promises";
-import { basename as basename21, dirname as dirname34, join as join49, posix as posix7, resolve as resolve34 } from "path";
+import { basename as basename21, dirname as dirname35, join as join49, posix as posix7, resolve as resolve34 } from "path";
 init_paths();
 init_merge_removal();
 init_transaction();
@@ -30034,7 +30231,7 @@ init_zod();
 init_fs();
 import { mkdir as mkdir24, readFile as readFile38 } from "fs/promises";
 import { homedir as homedir13 } from "os";
-import { dirname as dirname33, join as join48 } from "path";
+import { dirname as dirname34, join as join48 } from "path";
 var trustStoreSchema = external_exports.object({
   version: external_exports.literal(1),
   acceptedSources: external_exports.array(external_exports.string().min(1)).default([])
@@ -30110,7 +30307,7 @@ async function readTrustStore(path) {
   return trustStoreSchema.parse(JSON.parse(await readFile38(path, "utf8")));
 }
 async function writeTrustStore(path, store) {
-  await mkdir24(dirname33(path), { recursive: true });
+  await mkdir24(dirname34(path), { recursive: true });
   await writeJsonAtomic(path, trustStoreSchema.parse(store));
 }
 function defaultTrustStorePath() {
@@ -30610,7 +30807,7 @@ async function discoverTargetApplyJournal(options) {
       continue;
     }
     if (!journal.graphLockPath || !journal.graphLock || !journal.graphLockDigest) continue;
-    if (resolve34(dirname34(journal.graphLockPath)) !== resolve34(dirname34(options.graphLockPath))) continue;
+    if (resolve34(dirname35(journal.graphLockPath)) !== resolve34(dirname35(options.graphLockPath))) continue;
     if (options.transport.kind === "ssh") {
       throw new Error(
         `Legacy SSH apply journal at ${item.path} does not record its original endpoint; Agentwheel cannot prove endpoint identity, so the journal was preserved.`
@@ -30752,7 +30949,7 @@ async function resolvePriorTargetState(options) {
   return {};
 }
 async function discoverLegacyStateCandidates(options) {
-  const directory = dirname34(options.graphLockPath);
+  const directory = dirname35(options.graphLockPath);
   let names;
   try {
     names = await readdir16(directory);
@@ -31040,7 +31237,7 @@ function mcpServerNames(strategy, removal) {
   return new Set(Object.keys(servers));
 }
 function globalConfigRoot(globalRoot) {
-  return dirname34(dirname34(globalWorkspaceConfigPath(globalRoot)));
+  return dirname35(dirname35(globalWorkspaceConfigPath(globalRoot)));
 }
 function ownedByWorkspace(owner, desiredOwner, workspaceRoot, ownsSubWorkspaces) {
   if (owner === desiredOwner) return true;
@@ -31188,7 +31385,7 @@ function targetLabel(target) {
 init_workspace();
 init_run_as_identity();
 init_fs();
-import { basename as basename22, dirname as dirname35, join as join50, resolve as resolve35 } from "path";
+import { basename as basename22, dirname as dirname36, join as join50, resolve as resolve35 } from "path";
 var runtimeMarkers = [
   { adapter: "openclaw", dirs: [".openclaw", ".clawdbot", ".moltbot"] },
   { adapter: "claude", dirs: [".claude"] },
@@ -31314,7 +31511,7 @@ async function detectRuntimeTargets(cwd = process.cwd(), adapterFilter) {
     if (adapterFilter && marker.adapter !== adapterFilter) continue;
     for (const dir of marker.dirs) {
       if (basename22(root) === dir) {
-        matches.push({ adapter: marker.adapter, targetRoot: dirname35(root) });
+        matches.push({ adapter: marker.adapter, targetRoot: dirname36(root) });
       } else if (await pathExists(join50(root, dir))) {
         matches.push({ adapter: marker.adapter, targetRoot: root });
       }
@@ -31361,7 +31558,7 @@ function dedupeTargets(matches) {
 function runtimeScanRoot(request) {
   const root = resolve35(request.targetRoot ?? request.cwd ?? process.cwd());
   if (request.targetRoot) return root;
-  return runtimeMarkers.some((marker) => marker.dirs.includes(basename22(root))) ? dirname35(root) : root;
+  return runtimeMarkers.some((marker) => marker.dirs.includes(basename22(root))) ? dirname36(root) : root;
 }
 
 // src/lifecycle/profile.ts
@@ -31695,7 +31892,7 @@ init_selection();
 // src/cli/update-check.ts
 import { mkdir as mkdir26, readFile as readFile39, writeFile as writeFile22 } from "fs/promises";
 import { homedir as homedir14 } from "os";
-import { dirname as dirname36, join as join51 } from "path";
+import { dirname as dirname37, join as join51 } from "path";
 var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_TIMEOUT_MS = 300;
 var REGISTRY_URL = "https://registry.npmjs.org/agentwheel";
@@ -31748,7 +31945,7 @@ async function readCache(path) {
   }
 }
 async function writeCache(path, cache) {
-  await mkdir26(dirname36(path), { recursive: true });
+  await mkdir26(dirname37(path), { recursive: true });
   await writeFile22(path, `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
@@ -31984,11 +32181,11 @@ init_graph_lock();
 
 // src/cli/version.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname37, join as join54 } from "path";
+import { dirname as dirname38, join as join54 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var FALLBACK_VERSION = "0.0.0";
 function resolveCliVersion() {
-  let dir = dirname37(fileURLToPath3(import.meta.url));
+  let dir = dirname38(fileURLToPath3(import.meta.url));
   while (true) {
     try {
       const pkg = JSON.parse(readFileSync2(join54(dir, "package.json"), "utf8"));
@@ -31997,7 +32194,7 @@ function resolveCliVersion() {
       }
     } catch {
     }
-    const parent = dirname37(dir);
+    const parent = dirname38(dir);
     if (parent === dir) return FALLBACK_VERSION;
     dir = parent;
   }
@@ -32906,7 +33103,7 @@ init_graph_lock();
 init_manifest();
 import { createHash as createHash26 } from "crypto";
 import { lstat as lstat8, readdir as readdir17 } from "fs/promises";
-import { basename as basename23, dirname as dirname38, join as join57, posix as posix8, relative as relative18, resolve as resolve42 } from "path";
+import { basename as basename23, dirname as dirname39, join as join57, posix as posix8, relative as relative18, resolve as resolve42 } from "path";
 async function inventoryHistoricalLocks(fleetRoot) {
   const root = join57(fleetRoot, ".agentwheel", "locks");
   const found = [];
@@ -32953,7 +33150,7 @@ async function planLegacyRecovery(input) {
   const { graphPlan, installRoot, targetKey: targetKey2, adapter, installationType, historicalLocks, transport } = input;
   assertCompleteGraphPlan(graphPlan);
   const binding = {
-    targetLockDir: dirname38(graphPlan.graphLockPath),
+    targetLockDir: dirname39(graphPlan.graphLockPath),
     stableLockPath: graphPlan.graphLockPath,
     stableStateKey: graphPlan.plan.stateKey,
     currentFingerprint: graphPlan.targetFingerprint,
@@ -33065,7 +33262,7 @@ function claimFor(item, entry, locks, binding) {
   const evidence = [];
   const owner = "workspaceOwner" in entry ? entry.workspaceOwner : legacyUnownedWorkspaceOwner;
   const sameRoot = binding.transportKind === "ssh" ? posix8.normalize(item.manifest.targetRoot) === posix8.normalize(binding.installRoot) : resolve42(item.manifest.targetRoot) === resolve42(binding.installRoot);
-  const inTargetDir = matches.filter((candidate) => resolve42(dirname38(candidate.path)) === resolve42(binding.targetLockDir));
+  const inTargetDir = matches.filter((candidate) => resolve42(dirname39(candidate.path)) === resolve42(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");
@@ -35114,7 +35311,7 @@ init_fleet();
 // src/lifecycle/fleet-normalize.ts
 import { createHash as createHash31 } from "crypto";
 import { homedir as homedir17 } from "os";
-import { dirname as dirname40, isAbsolute as isAbsolute16, join as join65, relative as relative21, resolve as resolve47 } from "path";
+import { dirname as dirname41, isAbsolute as isAbsolute16, join as join65, relative as relative21, resolve as resolve47 } from "path";
 init_manifest2();
 init_paths();
 init_merge_removal();
@@ -35140,7 +35337,7 @@ init_caller_write_trust();
 import { AsyncLocalStorage } from "async_hooks";
 import { readFile as readLocalFile, readdir as readLocalDir, rm as removeLocal, mkdir as mkdir27, open as open6, rename as rename9 } from "fs/promises";
 import { randomUUID as randomUUID8 } from "crypto";
-import { dirname as dirname39, isAbsolute as isAbsolute15, relative as relative20, resolve as resolve46, sep as sep11 } from "path";
+import { dirname as dirname40, isAbsolute as isAbsolute15, relative as relative20, resolve as resolve46, sep as sep11 } from "path";
 var contexts = new AsyncLocalStorage();
 var inside = (root, path) => {
   const rel = relative20(root, resolve46(path));
@@ -35202,7 +35399,7 @@ async function normalizationRemove(path, options) {
   }
   await assertNormalizationCallerWrite(path);
   await removeLocal(path, options);
-  if (normalizationIdentities().length) await syncMetadataPath(dirname39(path), true);
+  if (normalizationIdentities().length) await syncMetadataPath(dirname40(path), true);
 }
 async function normalizationWriteJson(path, data) {
   const transport = normalizationTransport(path);
@@ -35216,7 +35413,7 @@ async function normalizationWriteJson(path, data) {
   }
   await assertNormalizationCallerWrite(path);
   await assertNoSymlinkPath2(path);
-  await mkdir27(dirname39(path), { recursive: true, mode: 448 });
+  await mkdir27(dirname40(path), { recursive: true, mode: 448 });
   await assertNormalizationCallerWrite(path);
   const temporary = `${path}.pending-${randomUUID8()}`;
   try {
@@ -35230,8 +35427,8 @@ async function normalizationWriteJson(path, data) {
       await file2.close();
     }
     await rename9(temporary, path);
-    await syncMetadataPath(dirname39(path), true);
-    await syncMetadataPath(dirname39(dirname39(path)), true);
+    await syncMetadataPath(dirname40(path), true);
+    await syncMetadataPath(dirname40(dirname40(path)), true);
   } finally {
     await removeLocal(temporary, { force: true });
   }
@@ -36282,7 +36479,7 @@ async function releasedTargetStateForGraph(scope, graph, identityFleetId = scope
     ...current,
     stateKey,
     targetFingerprint,
-    graphLockPath: join65(dirname40(graph.path), `${targetFingerprint}.graph-lock.json`),
+    graphLockPath: join65(dirname41(graph.path), `${targetFingerprint}.graph-lock.json`),
     manifestPath: installManifestPath(current.installRoot, current.adapter, {
       installationType: current.installationType,
       stateKey
@@ -37536,7 +37733,7 @@ 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 = join66(await realpath4(dirname41(requestedReport)), basename24(requestedReport));
+  const reportPath = join66(await realpath4(dirname42(requestedReport)), basename24(requestedReport));
   const reportInsideTarget = relative22(resolve48(target.targetRoot), reportPath);
   if (reportInsideTarget === "" || !reportInsideTarget.startsWith("..") && !isAbsolute17(reportInsideTarget)) {
     throw new Error("Recovery report must be outside the runtime target root.");
@@ -40559,7 +40756,7 @@ async function initPackage(root) {
   await writeFile24(instructionsPath, "# Agent Instructions\n", "utf8");
 }
 async function defaultBootstrapPackage(_root) {
-  const packageRoot = await findAgentwheelPackageRoot(dirname41(fileURLToPath4(import.meta.url)));
+  const packageRoot = await findAgentwheelPackageRoot(dirname42(fileURLToPath4(import.meta.url)));
   if (!packageRoot) return void 0;
   return {
     name: "agentwheel",
@@ -40606,7 +40803,7 @@ async function findAgentwheelPackageRoot(start) {
   let current = resolve48(start);
   while (true) {
     if (await findPackageManifestPath(current, { warnLegacy: false })) return current;
-    const parent = dirname41(current);
+    const parent = dirname42(current);
     if (parent === current) return void 0;
     current = parent;
   }