@hasna/skills 0.10.60 → 0.10.61

package/bin/index.js

@@ -36888,7 +36888,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.60",
+    version: "0.10.61",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -36925,6 +36925,7 @@ var init_package = __esm(() => {
       "!dist/test-preload.d.ts",
       "!dist/platform",
       "bin/",
+      "native/kernel-lock-acl-darwin",
       "migrations/",
       "docs/skill-standard.md",
       "docs/plugin-admission.md",
@@ -36938,8 +36939,8 @@ var init_package = __esm(() => {
     types: "./dist/index.d.ts",
     scripts: {
       clean: "rm -rf bin/ dist/",
-      build: "bun run clean && bun build --external @hasna/contracts/kernel-lock ./src/cli/index.tsx --outdir ./bin --target bun && bun build --external @hasna/contracts/kernel-lock ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/index.ts --outfile ./bin/server.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/worker.ts --outfile ./bin/worker.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/migrate.ts --outfile ./bin/migrate.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/maintenance.ts --outfile ./bin/maintenance.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/index.ts ./src/storage.ts ./src/sdk/index.ts ./src/admin-contract.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
-      "build:js": "rm -rf dist && bun build --external @hasna/contracts/kernel-lock ./src/index.ts ./src/storage.ts ./src/sdk/index.ts ./src/admin-contract.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
+      build: "bun run clean && bun build --external @hasna/contracts/kernel-lock ./src/cli/index.tsx --outdir ./bin --target bun && bun build --external @modelcontextprotocol/sdk ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/index.ts --outfile ./bin/server.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/worker.ts --outfile ./bin/worker.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/migrate.ts --outfile ./bin/migrate.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/maintenance.ts --outfile ./bin/maintenance.js --target bun && bun build ./src/index.ts ./src/storage.ts ./src/sdk/index.ts ./src/admin-contract.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist && bun scripts/stage-kernel-lock-assets.ts",
+      "build:js": "rm -rf dist && bun build ./src/index.ts ./src/storage.ts ./src/sdk/index.ts ./src/admin-contract.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist && bun scripts/stage-kernel-lock-assets.ts",
       test: "bun test --timeout 30000",
       dev: "bun run ./src/cli/index.tsx",
       "dev:watch": "bun --watch run ./src/cli/index.tsx",
@@ -39899,7 +39900,7 @@ var init_agent_adapters = __esm(() => {
     codex: { root: ".codex/skills", config: ".codex/hooks.json", events: ["UserPromptSubmit", "SessionStart", "SubagentStart"], promptContext: true },
     gemini: { root: ".gemini/skills", config: ".gemini/settings.json", events: ["BeforeAgent", "SessionStart"], promptContext: true },
     opencode: { root: ".config/opencode/skills", config: ".config/opencode/opencode.json", events: ["chat.message"], promptContext: true },
-    sumi: { root: ".hasna-internal/sumi/config/skills", config: ".hasna-internal/sumi/config/sumi.json", events: ["prompt", "context"], promptContext: true },
+    sumi: { root: null, config: null, events: ["prompt", "context"], promptContext: true },
     hermes: { root: ".hermes/skills", config: ".hermes/config.yaml", events: ["pre_llm_call", "pre_tool_call"], promptContext: true, promptFailureMode: "open", toolFailureMode: "supervised-child-errors-block", requiresNativeTrust: true },
     cursor: { root: ".cursor/skills", config: ".cursor/hooks.json", events: ["beforeSubmitPrompt", "sessionStart"], promptContext: false }
   };
@@ -54091,37 +54092,136 @@ var init_agent_codex = __esm(() => {
 });
 
 // src/lib/agent-sumi.ts
-import { existsSync as existsSync12, lstatSync as lstatSync18, realpathSync as realpathSync8 } from "fs";
-import { join as join27, resolve as resolve15 } from "path";
-function sumiConfigDirectory(home, env3 = process.env) {
+import { spawnSync as spawnSync3 } from "child_process";
+import { accessSync as accessSync2, constants as constants11, existsSync as existsSync12, lstatSync as lstatSync18, realpathSync as realpathSync8, statSync as statSync9 } from "fs";
+import { delimiter as delimiter2, isAbsolute as isAbsolute15, join as join27, resolve as resolve15 } from "path";
+function recordWithKeys(value, keys2) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === keys2.length && keys2.every((key) => Object.hasOwn(value, key));
+}
+function absolutePath3(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute15(value) && resolve15(value) === value;
+}
+function absoluteInput(value) {
+  return value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute15(value);
+}
+function resolveSumiPathsCommand(pathValue) {
+  if (!pathValue)
+    return null;
+  for (const directory of pathValue.split(delimiter2)) {
+    if (!directory || /[\x00-\x1f\x7f]/.test(directory))
+      continue;
+    const candidate = resolve15(directory, "sumi-paths");
+    try {
+      accessSync2(candidate, constants11.X_OK);
+      if (statSync9(candidate).isFile())
+        return candidate;
+    } catch {}
+  }
+  return null;
+}
+function validPathPlan(value, home, cwd2) {
+  if (!recordWithKeys(value, ["schemaVersion", "kind", "home", "cwd", "roots", "legacyRoots", "configFiles", "skillRoots"]))
+    return false;
+  if (value.schemaVersion !== 1 || value.kind !== "sumi-paths" || value.home !== resolve15(home) || value.cwd !== resolve15(cwd2))
+    return false;
+  if (!recordWithKeys(value.roots, SUMI_PATH_KEYS) || !recordWithKeys(value.legacyRoots, SUMI_PATH_KEYS))
+    return false;
+  for (const key of SUMI_PATH_KEYS) {
+    if (!absolutePath3(value.roots[key]))
+      return false;
+    if (value.legacyRoots[key] !== null && !absolutePath3(value.legacyRoots[key]))
+      return false;
+  }
+  if (!recordWithKeys(value.configFiles, ["canonical", "legacy"]) || !recordWithKeys(value.skillRoots, ["canonical", "legacy"]))
+    return false;
+  if (!absolutePath3(value.configFiles.canonical) || !absolutePath3(value.skillRoots.canonical))
+    return false;
+  if (value.configFiles.legacy !== null && !absolutePath3(value.configFiles.legacy))
+    return false;
+  if (value.skillRoots.legacy !== null && !absolutePath3(value.skillRoots.legacy))
+    return false;
+  const configRoot = value.roots.config;
+  const legacyConfigRoot = value.legacyRoots.config;
+  if (typeof configRoot !== "string" || legacyConfigRoot !== null && typeof legacyConfigRoot !== "string")
+    return false;
+  if (value.configFiles.canonical !== join27(configRoot, "sumi.json") || value.skillRoots.canonical !== join27(configRoot, "skills"))
+    return false;
+  if (legacyConfigRoot === null)
+    return value.configFiles.legacy === null && value.skillRoots.legacy === null;
+  return value.configFiles.legacy === join27(legacyConfigRoot, "sumi.json") && value.skillRoots.legacy === join27(legacyConfigRoot, "skills");
+}
+function sumiPathPlan(home, cwd2 = process.cwd(), env3 = process.env) {
   for (const key of ["SUMI_CONFIG", "SUMI_CONFIG_CONTENT"])
     if (env3[key] !== undefined)
-      throw new Error(`Sumi ${key} requires a dedicated discovery adapter; unset it before Skills integration`);
-  const selected = (key) => env3[key]?.trim() ? env3[key] : undefined;
-  const expand = (value) => resolve15(value === "~" ? home : value.startsWith("~/") ? join27(home, value.slice(2)) : value);
-  const explicit = selected("SUMI_CONFIG_DIR");
-  const xdg = selected("XDG_CONFIG_HOME");
-  const custom = selected("SUMI_HOME");
-  const canonical7 = explicit ? expand(explicit) : xdg ? join27(expand(xdg), "sumi") : join27(custom ? expand(custom) : join27(home, ".hasna-internal/sumi"), "config");
-  if (explicit || xdg || custom)
-    return canonical7;
-  const legacy = join27(home, ".config/sumi");
-  const a = lstatSync18(canonical7, { throwIfNoEntry: false }), b = lstatSync18(legacy, { throwIfNoEntry: false });
-  if (a && b && realpathSync8(canonical7) !== realpathSync8(legacy))
+      throw new SumiPathResolverError("SUMI_PATH_CONFIG_UNSUPPORTED");
+  if (!absoluteInput(home) || !absoluteInput(cwd2))
+    throw new SumiPathResolverError("SUMI_PATH_INPUT_REFUSED");
+  const runtimePath = process.env.PATH ?? "";
+  const executable2 = resolveSumiPathsCommand(runtimePath);
+  if (!executable2 || !isAbsolute15(executable2))
+    throw new SumiPathResolverError("SUMI_PATH_RESOLVER_UNAVAILABLE");
+  const childEnv = { PATH: runtimePath };
+  for (const key of SUMI_PATH_SELECTORS)
+    if (env3[key] !== undefined)
+      childEnv[key] = env3[key];
+  let child2;
+  try {
+    child2 = spawnSync3(executable2, ["--json", "--home", resolve15(home), "--cwd", resolve15(cwd2)], {
+      cwd: resolve15(cwd2),
+      env: childEnv,
+      encoding: "buffer",
+      timeout: 3000,
+      maxBuffer: SUMI_PATH_OUTPUT_LIMIT,
+      shell: false
+    });
+  } catch {
+    throw new SumiPathResolverError("SUMI_PATH_RESOLVER_UNAVAILABLE");
+  }
+  const stdoutBytes = child2.stdout === null ? 0 : Buffer.byteLength(child2.stdout);
+  const stderrBytes = child2.stderr === null ? 0 : Buffer.byteLength(child2.stderr);
+  if (child2.error || child2.signal || !child2.stdout || stdoutBytes > SUMI_PATH_OUTPUT_LIMIT || stderrBytes > 0) {
+    throw new SumiPathResolverError("SUMI_PATH_RESOLVER_UNAVAILABLE");
+  }
+  let result2;
+  try {
+    result2 = JSON.parse(child2.stdout.toString("utf8"));
+  } catch {
+    throw new SumiPathResolverError("SUMI_PATH_RESOLVER_INVALID_RESPONSE");
+  }
+  if (recordWithKeys(result2, ["schemaVersion", "kind", "code"]) && result2.schemaVersion === 1 && result2.kind === "sumi-paths-error" && (result2.code === "SUMI_PATH_INPUT_REFUSED" || result2.code === "SUMI_PATH_CONFIG_UNSUPPORTED") && child2.status === 2) {
+    throw new SumiPathResolverError(result2.code);
+  }
+  if (child2.status !== 0 || !validPathPlan(result2, home, cwd2))
+    throw new SumiPathResolverError("SUMI_PATH_RESOLVER_INVALID_RESPONSE");
+  return result2;
+}
+function selectedConfigDirectory(plan) {
+  const canonical7 = plan.roots.config, legacy = plan.legacyRoots.config;
+  if (legacy === null)
+    return existsSync12(canonical7) ? realpathSync8(canonical7) : canonical7;
+  const canonicalStat = lstatSync18(canonical7, { throwIfNoEntry: false }), legacyStat = lstatSync18(legacy, { throwIfNoEntry: false });
+  if (canonicalStat && legacyStat && realpathSync8(canonical7) !== realpathSync8(legacy))
     throw new Error("Sumi config roots conflict; complete native home adoption before Skills integration");
-  const path = a ? canonical7 : b ? legacy : canonical7;
-  if (!existsSync12(path))
-    return path;
-  const physical = realpathSync8(path);
-  if ((a?.isSymbolicLink() || b?.isSymbolicLink()) && ![canonical7, legacy].includes(physical))
+  const selected = canonicalStat ? canonical7 : legacyStat ? legacy : canonical7;
+  if (!existsSync12(selected))
+    return selected;
+  const physical = realpathSync8(selected);
+  if ((canonicalStat?.isSymbolicLink() || legacyStat?.isSymbolicLink()) && ![canonical7, legacy].includes(physical))
     throw new Error("Sumi config alias must resolve to its canonical or legacy root");
   return physical;
 }
-function sumiBridgeRoot(home) {
-  return join27(sumiConfigDirectory(home), "skills");
+function sumiConfigDirectory(home, env3 = process.env, cwd2 = process.cwd()) {
+  return selectedConfigDirectory(sumiPathPlan(home, cwd2, env3));
+}
+function sumiSkillRoots(home, cwd2 = process.cwd(), env3 = process.env) {
+  const plan = sumiPathPlan(home, cwd2, env3);
+  return [join27(selectedConfigDirectory(plan), "skills")];
 }
-function sumiConfigPath(home) {
-  return join27(sumiConfigDirectory(home), "sumi.json");
+function sumiBridgeRoot(home, cwd2 = process.cwd(), env3 = process.env) {
+  return sumiSkillRoots(home, cwd2, env3)[0];
+}
+function sumiConfigPath(home, cwd2 = process.cwd(), env3 = process.env) {
+  return join27(sumiConfigDirectory(home, env3, cwd2), "sumi.json");
 }
 function renderSumiPlugin(command, profile) {
   return renderSumiPluginVersion(command, profile, false);
@@ -54207,8 +54307,19 @@ export default {
 };
 `;
 }
-var SUMI_SKILL_PERMISSIONS;
+var SUMI_PATH_SELECTORS, SUMI_PATH_KEYS, SUMI_PATH_OUTPUT_LIMIT, SumiPathResolverError, SUMI_SKILL_PERMISSIONS;
 var init_agent_sumi = __esm(() => {
+  SUMI_PATH_SELECTORS = ["SUMI_HOME", "SUMI_CONFIG_DIR", "XDG_DATA_HOME", "XDG_CACHE_HOME", "XDG_CONFIG_HOME", "XDG_STATE_HOME"];
+  SUMI_PATH_KEYS = ["data", "cache", "config", "state"];
+  SUMI_PATH_OUTPUT_LIMIT = 128 * 1024;
+  SumiPathResolverError = class SumiPathResolverError extends Error {
+    code;
+    constructor(code) {
+      super(`Sumi path discovery refused (${code})`);
+      this.code = code;
+      this.name = "SumiPathResolverError";
+    }
+  };
   SUMI_SKILL_PERMISSIONS = [
     { action: "skill", resource: "*", effect: "deny" },
     { action: "skill", resource: "skills-cli", effect: "allow" }
@@ -54216,9 +54327,9 @@ var init_agent_sumi = __esm(() => {
 });
 
 // src/lib/codex-hook-trust-files.ts
-import { closeSync as closeSync10, constants as constants11, fstatSync as fstatSync10, fsyncSync as fsyncSync3, lstatSync as lstatSync19, openSync as openSync10, readlinkSync as readlinkSync5, readSync as readSync8, writeFileSync as writeFileSync5 } from "fs";
+import { closeSync as closeSync10, constants as constants12, fstatSync as fstatSync10, fsyncSync as fsyncSync3, lstatSync as lstatSync19, openSync as openSync10, readlinkSync as readlinkSync5, readSync as readSync8, writeFileSync as writeFileSync5 } from "fs";
 import { createHash as createHash18 } from "crypto";
-import { dirname as dirname15, isAbsolute as isAbsolute15, resolve as resolve16 } from "path";
+import { dirname as dirname15, isAbsolute as isAbsolute16, resolve as resolve16 } from "path";
 function need6(value, code) {
   if (!value)
     throw new Error(`CODEX_HOOK_TRUST_${code}`);
@@ -54238,7 +54349,7 @@ function safeParents(file) {
 function directAliasTarget(link2) {
   const text2 = readlinkSync5(link2), parts = text2.split("/");
   let first = 0;
-  if (isAbsolute15(text2))
+  if (isAbsolute16(text2))
     first = 1;
   else
     while (parts[first] === "..")
@@ -54254,7 +54365,7 @@ function snapshot(file, privateFile = false, options = {}) {
   const initial2 = lstatSync19(file, { bigint: true });
   need6(initial2.isFile() && initial2.uid === BigInt(process.getuid()) && (initial2.nlink === 1n || readOnlyPackage && initial2.nlink > 1n) && (initial2.mode & 0o022n) === 0n && (!privateFile || (initial2.mode & 0o777n) === 0o600n), "UNSAFE_FILE");
   need6(initial2.size <= 8n * 1024n * 1024n, "FILE_BOUND");
-  const fd = openSync10(file, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
+  const fd = openSync10(file, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
   try {
     const before2 = fstatSync10(fd, { bigint: true });
     need6(sameStat(initial2, before2), "INPUT_CHANGED");
@@ -54279,7 +54390,7 @@ function unchanged2(before2) {
 }
 function save(file, content) {
   safeParents(file);
-  const fd = openSync10(file, constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW, 384);
+  const fd = openSync10(file, constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW, 384);
   try {
     writeFileSync5(fd, content);
     fsyncSync3(fd);
@@ -54290,35 +54401,152 @@ function save(file, content) {
 var sameStat = (a, b) => ["dev", "ino", "uid", "nlink", "mode", "size", "mtimeNs", "ctimeNs"].every((key) => a[key] === b[key]);
 var init_codex_hook_trust_files = () => {};
 
+// src/server/launcher-environment-policy.ts
+function renderLegacyPinnedLauncher(binding) {
+  const names = LEGACY_ENV_NAMES.join(" ");
+  const prefixes = LEGACY_ENV_PREFIXES.join("|");
+  return [
+    "#!/bin/sh -p",
+    `# ${LEGACY_PINNED_LAUNCHER_SCHEMA}`,
+    "# Written by `skills self-update`; rewrite it with `skills self-update`, do not edit by hand.",
+    "# Runs the exact Skills entry below under one exact Bun from one trusted directory with",
+    "# no working-directory configuration (no bunfig.toml, no .env, no macros, no auto-install)",
+    "# and only the environment names allowed here. Everything else, BUN_* and NODE_OPTIONS",
+    "# included, never reaches the runtime. The CLI returns to the caller's directory itself.",
+    "# `-p` keeps the caller's exported functions and shell options out of this shell.",
+    "set -eu",
+    `${LAUNCH_CWD_VARIABLE2}=$(pwd -P 2>/dev/null || :)`,
+    `export ${LAUNCH_CWD_VARIABLE2}`,
+    `set -- '${binding.runtime}' ${PINNED_LAUNCHER_BUN_FLAGS.join(" ")} '--cwd=${binding.cwd}' '${binding.entry}' "$@"`,
+    "hasna_skills_env=$(LC_ALL=C /usr/bin/awk 'BEGIN {",
+    `  n = split("${names}", exact, " ")`,
+    "  for (i = 1; i <= n; i++) allow[exact[i]] = 1",
+    "  for (name in ENVIRON) {",
+    "    if (name !~ /^[A-Za-z_][A-Za-z0-9_]*$/) continue",
+    `    if (name == "LC_ALL" || (!(name in allow) && name !~ /^(${prefixes})_/)) continue`,
+    '    value = ENVIRON[name]; quoted = ""',
+    '    while ((k = index(value, "\\047")) > 0) { quoted = quoted substr(value, 1, k - 1) "\\047\\\\\\047\\047"; value = substr(value, k + 1) }',
+    '    printf "\\047%s=%s\\047 ", name, quoted value',
+    "  }",
+    "}')",
+    'eval "set -- $hasna_skills_env \\"\\$@\\""',
+    'if [ "${LC_ALL+x}" = x ]; then set -- "LC_ALL=$LC_ALL" "$@"; fi',
+    'exec /usr/bin/env -i "$@"',
+    ""
+  ].join(`
+`);
+}
+function isStorageLocatorEnvironmentName(name) {
+  return storageLocators.has(name);
+}
+var LEGACY_PINNED_LAUNCHER_SCHEMA = "hasna-skills-pinned-launcher-v1", LAUNCH_CWD_VARIABLE2 = "HASNA_SKILLS_LAUNCH_CWD", PINNED_LAUNCHER_BUN_FLAGS, LEGACY_ENV_NAMES, LEGACY_ENV_PREFIXES, SERVER_LAUNCHER_ENV_NAMES, STORAGE_LOCATOR_ENV_NAMES, storageLocators, CLIENT_LAUNCHER_STORAGE_DENY_AWK = `    if (name == "DATABASE_URL" || name == "HASNA_SKILLS_DATABASE_URL" || name == "SKILLS_DATABASE_URL") continue`;
+var init_launcher_environment_policy = __esm(() => {
+  PINNED_LAUNCHER_BUN_FLAGS = ["--config=/dev/null", "--no-env-file", "--no-macros", "--no-install"];
+  LEGACY_ENV_NAMES = [
+    "HOME",
+    "PATH",
+    "TMPDIR",
+    "TERM",
+    "TERM_PROGRAM",
+    "TERM_PROGRAM_VERSION",
+    "COLORTERM",
+    "LANG",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "TZ",
+    "NO_COLOR",
+    "FORCE_COLOR",
+    "CI",
+    "COLUMNS",
+    "LINES",
+    "EDITOR",
+    "VISUAL",
+    "PAGER",
+    "SSH_AUTH_SOCK",
+    "DATABASE_URL",
+    "TERMINAL_CWD",
+    "CODEX_HOME",
+    "HERMES_HOME",
+    "HERMES_ENABLE_PROJECT_PLUGINS",
+    "HOST",
+    "PORT",
+    "NODE_ENV",
+    "AGENT_ID",
+    "ECS_CONTAINER_METADATA_URI_V4"
+  ];
+  LEGACY_ENV_PREFIXES = ["HASNA", "SKILLS", "SKILL", "MCP", "XDG", "LC", "AWS"];
+  SERVER_LAUNCHER_ENV_NAMES = ["DATABASE_URL"];
+  STORAGE_LOCATOR_ENV_NAMES = ["DATABASE_URL", "HASNA_SKILLS_DATABASE_URL", "SKILLS_DATABASE_URL"];
+  storageLocators = new Set(STORAGE_LOCATOR_ENV_NAMES);
+});
+
 // src/cli/commands/runtime-launcher.ts
 import { createHash as createHash19 } from "crypto";
-import { closeSync as closeSync11, constants as constants12, fchmodSync, fstatSync as fstatSync11, fsyncSync as fsyncSync4, lstatSync as lstatSync20, openSync as openSync11, readFileSync as readFileSync15, readlinkSync as readlinkSync6, realpathSync as realpathSync9, symlinkSync, writeSync as writeSync2 } from "fs";
-import { isAbsolute as isAbsolute16 } from "path";
-function pinnedLauncherEnvironment(env3) {
+import { closeSync as closeSync11, constants as constants13, fchmodSync, fstatSync as fstatSync11, fsyncSync as fsyncSync4, lstatSync as lstatSync20, openSync as openSync11, readFileSync as readFileSync15, readlinkSync as readlinkSync6, realpathSync as realpathSync9, symlinkSync, writeSync as writeSync2 } from "fs";
+import { isAbsolute as isAbsolute17 } from "path";
+function pinnedLauncherEnvironment(env3, profile = "client") {
+  assertLauncherProfile(profile);
   const result2 = {};
-  for (const [name, value] of Object.entries(env3)) {
-    if (value === undefined || !ENV_NAME.test(name) || !ENV_EXACT.has(name) && !ENV_PREFIX.test(name))
+  for (const name of Object.keys(env3)) {
+    if (!ENV_NAME.test(name))
+      continue;
+    const storageLocator = isStorageLocatorEnvironmentName(name);
+    if (storageLocator && profile === "client")
       continue;
-    result2[name] = value;
+    if (!storageLocator && !ENV_EXACT.has(name) && !ENV_PREFIX.test(name))
+      continue;
+    const value = env3[name];
+    if (value !== undefined)
+      result2[name] = value;
   }
   return result2;
 }
+function assertLauncherProfile(profile) {
+  if (profile !== "client" && profile !== "server")
+    throw new Error("LAUNCHER_PROFILE_INVALID");
+}
+function launcherProfileForBin(name, entry) {
+  const bins = {
+    skills: ["bin/index.js", "client"],
+    "skills-mcp": ["bin/mcp.js", "client"],
+    "skills-serve": ["bin/server.js", "server"],
+    "skills-server": ["bin/server.js", "server"],
+    "skills-worker": ["bin/worker.js", "server"],
+    "skills-maintenance": ["bin/maintenance.js", "server"],
+    "skills-migrate": ["bin/migrate.js", "server"]
+  };
+  const contract = bins[name];
+  if (!contract || entry !== contract[0])
+    throw new Error("LAUNCHER_BIN_CONTRACT_INVALID");
+  return contract[1];
+}
 function sha2562(bytes) {
   return createHash19("sha256").update(bytes).digest("hex");
 }
 function assertLauncherPath(value, code) {
-  if (typeof value !== "string" || !isAbsolute16(value) || /['\x00-\x1f\x7f]/.test(value))
+  if (typeof value !== "string" || !isAbsolute17(value) || /['\x00-\x1f\x7f]/.test(value))
     throw new Error(code);
 }
 function renderPinnedLauncher(binding) {
   assertLauncherPath(binding.runtime, "LAUNCHER_RUNTIME_PATH_INVALID");
   assertLauncherPath(binding.cwd, "LAUNCHER_CWD_PATH_INVALID");
   assertLauncherPath(binding.entry, "LAUNCHER_ENTRY_PATH_INVALID");
-  const names = PINNED_LAUNCHER_ENV_NAMES.join(" ");
+  if (binding.format === "v1") {
+    if (binding.profile !== undefined)
+      throw new Error("LAUNCHER_PROFILE_INVALID");
+    return renderLegacyPinnedLauncher(binding);
+  }
+  if (binding.format !== undefined && binding.format !== "v2")
+    throw new Error("LAUNCHER_FORMAT_INVALID");
+  const profile = binding.profile === undefined ? "client" : binding.profile;
+  assertLauncherProfile(profile);
+  const names = [...PINNED_LAUNCHER_ENV_NAMES, ...profile === "server" ? SERVER_LAUNCHER_ENV_NAMES : []].join(" ");
   const prefixes = PINNED_LAUNCHER_ENV_PREFIXES.join("|");
   return [
     "#!/bin/sh -p",
     `# ${PINNED_LAUNCHER_SCHEMA}`,
+    `# environment-profile: ${profile}`,
     "# Written by `skills self-update`; rewrite it with `skills self-update`, do not edit by hand.",
     "# Runs the exact Skills entry below under one exact Bun from one trusted directory with",
     "# no working-directory configuration (no bunfig.toml, no .env, no macros, no auto-install)",
@@ -54326,15 +54554,16 @@ function renderPinnedLauncher(binding) {
     "# included, never reaches the runtime. The CLI returns to the caller's directory itself.",
     "# `-p` keeps the caller's exported functions and shell options out of this shell.",
     "set -eu",
-    `${LAUNCH_CWD_VARIABLE2}=$(pwd -P 2>/dev/null || :)`,
-    `export ${LAUNCH_CWD_VARIABLE2}`,
-    `set -- '${binding.runtime}' ${PINNED_LAUNCHER_BUN_FLAGS.join(" ")} '--cwd=${binding.cwd}' '${binding.entry}' "$@"`,
+    `${LAUNCH_CWD_VARIABLE3}=$(pwd -P 2>/dev/null || :)`,
+    `export ${LAUNCH_CWD_VARIABLE3}`,
+    `set -- '${binding.runtime}' ${PINNED_LAUNCHER_BUN_FLAGS2.join(" ")} '--cwd=${binding.cwd}' '${binding.entry}' "$@"`,
     "hasna_skills_env=$(LC_ALL=C /usr/bin/awk 'BEGIN {",
     `  n = split("${names}", exact, " ")`,
     "  for (i = 1; i <= n; i++) allow[exact[i]] = 1",
     "  for (name in ENVIRON) {",
     "    if (name !~ /^[A-Za-z_][A-Za-z0-9_]*$/) continue",
     `    if (name == "LC_ALL" || (!(name in allow) && name !~ /^(${prefixes})_/)) continue`,
+    ...profile === "client" ? [CLIENT_LAUNCHER_STORAGE_DENY_AWK] : [],
     '    value = ENVIRON[name]; quoted = ""',
     '    while ((k = index(value, "\\047")) > 0) { quoted = quoted substr(value, 1, k - 1) "\\047\\\\\\047\\047"; value = substr(value, k + 1) }',
     '    printf "\\047%s=%s\\047 ", name, quoted value',
@@ -54351,7 +54580,19 @@ function parsePinnedLauncher(text2) {
   const match = COMMAND_LINE.exec(text2);
   if (!match)
     return null;
-  const binding = { runtime: match[1], cwd: match[2], entry: match[3] };
+  let metadata;
+  if (text2.split(`
+`)[1] === `# ${LEGACY_PINNED_LAUNCHER_SCHEMA}`)
+    metadata = { format: "v1" };
+  else if (text2.split(`
+`)[1] === `# ${PINNED_LAUNCHER_SCHEMA}`) {
+    const profile = /^# environment-profile: (client|server)$/m.exec(text2)?.[1];
+    if (!profile)
+      return null;
+    metadata = { format: "v2", profile };
+  } else
+    return null;
+  const binding = { runtime: match[1], cwd: match[2], entry: match[3], ...metadata };
   try {
     if (renderPinnedLauncher(binding) !== text2)
       return null;
@@ -54398,7 +54639,7 @@ function inspectLauncher(path) {
   const binding = parsePinnedLauncher(text2);
   if (!binding)
     return { kind: "foreign" };
-  return { kind: "pinned", runtime: binding.runtime, cwd: binding.cwd, target: binding.entry, sha256: sha2562(text2), text: text2 };
+  return { kind: "pinned", format: binding.format, profile: binding.profile, runtime: binding.runtime, cwd: binding.cwd, target: binding.entry, sha256: sha2562(text2), text: text2 };
 }
 function launcherTarget(path) {
   const inspected = inspectLauncher(path);
@@ -54415,17 +54656,22 @@ function launcherIs(path, state) {
   }
   if (state.shape === "symlink")
     return inspected.kind === "symlink" && inspected.linkTarget === state.linkTarget && inspected.target === state.target;
-  return inspected.kind === "pinned" && inspected.sha256 === state.sha256 && inspected.runtime === state.runtime && inspected.cwd === state.cwd && inspected.target === state.target;
+  return inspected.kind === "pinned" && inspected.sha256 === state.sha256 && inspected.runtime === state.runtime && inspected.cwd === state.cwd && inspected.target === state.target && inspected.format === (state.format ?? "v1") && inspected.profile === state.profile;
 }
 function pinnedLauncherText(state) {
-  const text2 = renderPinnedLauncher({ runtime: state.runtime, cwd: state.cwd, entry: state.target });
+  if (state.format === "v2")
+    assertLauncherProfile(state.profile);
+  const text2 = renderPinnedLauncher({ runtime: state.runtime, cwd: state.cwd, entry: state.target, format: state.format === undefined ? "v1" : state.format, profile: state.profile });
   if (sha2562(text2) !== state.sha256)
     throw new Error("LAUNCHER_TEXT_DIGEST_MISMATCH");
   return text2;
 }
-function pinnedLauncherState(runtime, cwd2, target) {
-  const text2 = renderPinnedLauncher({ runtime, cwd: cwd2, entry: target });
-  return { shape: "pinned", runtime, cwd: cwd2, target, sha256: sha2562(text2) };
+function pinnedLauncherState(runtime, cwd2, target, metadata = { format: "v2", profile: "client" }) {
+  const format = metadata.format === undefined ? "v1" : metadata.format, profile = metadata.profile;
+  if (format === "v2")
+    assertLauncherProfile(profile);
+  const text2 = renderPinnedLauncher({ runtime, cwd: cwd2, entry: target, format, profile });
+  return { shape: "pinned", runtime, cwd: cwd2, target, sha256: sha2562(text2), format, ...profile ? { profile } : {} };
 }
 function materializeLauncher(path, state) {
   if (state.shape === "symlink") {
@@ -54435,7 +54681,7 @@ function materializeLauncher(path, state) {
     return;
   }
   const text2 = pinnedLauncherText(state);
-  const fd = openSync11(path, constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW, 493);
+  const fd = openSync11(path, constants13.O_WRONLY | constants13.O_CREAT | constants13.O_EXCL | constants13.O_NOFOLLOW, 493);
   try {
     const bytes = Buffer.from(text2, "utf8");
     let written = 0;
@@ -54491,9 +54737,10 @@ function assertPinnedLauncherShell() {
   if (probe.exitCode !== 0)
     throw new Error("LAUNCHER_SHELL_UNSUPPORTED");
 }
-var PINNED_LAUNCHER_SCHEMA = "hasna-skills-pinned-launcher-v1", LAUNCH_CWD_VARIABLE2 = "HASNA_SKILLS_LAUNCH_CWD", PINNED_LAUNCHER_BUN_FLAGS, PINNED_LAUNCHER_ENV_NAMES, PINNED_LAUNCHER_ENV_PREFIXES, ENV_NAME, ENV_PREFIX, ENV_EXACT, COMMAND_LINE, PINNED_LAUNCHER_MAX_BYTES;
+var PINNED_LAUNCHER_SCHEMA = "hasna-skills-pinned-launcher-v2", LAUNCH_CWD_VARIABLE3 = "HASNA_SKILLS_LAUNCH_CWD", PINNED_LAUNCHER_BUN_FLAGS2, PINNED_LAUNCHER_ENV_NAMES, PINNED_LAUNCHER_ENV_PREFIXES, ENV_NAME, ENV_PREFIX, ENV_EXACT, COMMAND_LINE, PINNED_LAUNCHER_MAX_BYTES;
 var init_runtime_launcher = __esm(() => {
-  PINNED_LAUNCHER_BUN_FLAGS = ["--config=/dev/null", "--no-env-file", "--no-macros", "--no-install"];
+  init_launcher_environment_policy();
+  PINNED_LAUNCHER_BUN_FLAGS2 = ["--config=/dev/null", "--no-env-file", "--no-macros", "--no-install"];
   PINNED_LAUNCHER_ENV_NAMES = [
     "HOME",
     "PATH",
@@ -54516,7 +54763,6 @@ var init_runtime_launcher = __esm(() => {
     "VISUAL",
     "PAGER",
     "SSH_AUTH_SOCK",
-    "DATABASE_URL",
     "TERMINAL_CWD",
     "CODEX_HOME",
     "HERMES_HOME",
@@ -54531,16 +54777,32 @@ var init_runtime_launcher = __esm(() => {
   ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
   ENV_PREFIX = new RegExp(`^(${PINNED_LAUNCHER_ENV_PREFIXES.join("|")})_`);
   ENV_EXACT = new Set(PINNED_LAUNCHER_ENV_NAMES);
-  COMMAND_LINE = new RegExp(`^set -- '([^']+)' ${PINNED_LAUNCHER_BUN_FLAGS.join(" ")} '--cwd=([^']+)' '([^']+)' "\\$@"$`, "m");
+  COMMAND_LINE = new RegExp(`^set -- '([^']+)' ${PINNED_LAUNCHER_BUN_FLAGS2.join(" ")} '--cwd=([^']+)' '([^']+)' "\\$@"$`, "m");
   PINNED_LAUNCHER_MAX_BYTES = 16 * 1024;
 });
 
 // src/lib/agent-integration.ts
 import { createHash as createHash20, randomUUID as randomUUID6 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual7 } from "util";
-import { existsSync as existsSync13, lstatSync as lstatSync21, statSync as statSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync16, readdirSync as readdirSync8, opendirSync as opendirSync3, readlinkSync as readlinkSync7, realpathSync as realpathSync10, renameSync as renameSync3, rmdirSync as rmdirSync2, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4, chmodSync, openSync as openSync12, closeSync as closeSync12, fsyncSync as fsyncSync5, fstatSync as fstatSync12, readSync as readSync9, constants as constants13, linkSync as linkSync2 } from "fs";
-import { dirname as dirname16, join as join28, resolve as resolve17, relative as relative6, isAbsolute as isAbsolute17, sep as sep7 } from "path";
+import { existsSync as existsSync13, lstatSync as lstatSync21, statSync as statSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync16, readdirSync as readdirSync8, opendirSync as opendirSync3, readlinkSync as readlinkSync7, realpathSync as realpathSync10, renameSync as renameSync3, rmdirSync as rmdirSync2, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4, chmodSync, openSync as openSync12, closeSync as closeSync12, fsyncSync as fsyncSync5, fstatSync as fstatSync12, readSync as readSync9, constants as constants14, linkSync as linkSync2 } from "fs";
+import { dirname as dirname16, join as join28, resolve as resolve17, relative as relative6, isAbsolute as isAbsolute18, sep as sep7 } from "path";
 import { homedir as homedir3 } from "os";
+function nativeAgentRoot(home, agent, cwd2 = process.cwd()) {
+  if (agent === "sumi")
+    return sumiBridgeRoot(home, cwd2);
+  const root = AGENT_ADAPTERS[agent].root;
+  if (typeof root !== "string")
+    throw new Error(`Native skill root is unavailable for ${agent}`);
+  return join28(home, root);
+}
+function nativeAgentConfig(home, agent, cwd2 = process.cwd()) {
+  if (agent === "sumi")
+    return sumiConfigPath(home, cwd2);
+  const config = AGENT_ADAPTERS[agent].config;
+  if (typeof config !== "string")
+    throw new Error(`Native configuration path is unavailable for ${agent}`);
+  return join28(home, config);
+}
 function hasTrustedDarwinAcl(fd, allowDenyOnly = false) {
   try {
     const { dlopen, read: read2, ptr } = __require("bun:ffi");
@@ -54603,7 +54865,7 @@ function isSystemRootAlias(path) {
           throw new Error("Writable system alias directory");
       } else if ((stat.mode & 0o1000n) === 0n)
         throw new Error("Unprotected system temporary directory");
-      const fd = openSync12(directory, constants13.O_RDONLY | constants13.O_DIRECTORY | constants13.O_NOFOLLOW);
+      const fd = openSync12(directory, constants14.O_RDONLY | constants14.O_DIRECTORY | constants14.O_NOFOLLOW);
       try {
         if (directoryIdentity(fstatSync12(fd, { bigint: true })) !== directoryIdentity(stat) || !hasTrustedDarwinAcl(fd) || directoryIdentity(fstatSync12(fd, { bigint: true })) !== directoryIdentity(stat))
           throw new Error("Unverified system alias directory ACL");
@@ -54648,7 +54910,7 @@ function readRootAlias(home, agent) {
   if (!targetStat?.isDirectory())
     throw new Error(`Agent root alias must target an existing directory: ${alias}`);
   const target = realpathSync10(targetPath), inside = relative6(realHome, target);
-  if (!inside || inside === ".." || inside.startsWith(`..${sep7}`) || isAbsolute17(inside))
+  if (!inside || inside === ".." || inside.startsWith(`..${sep7}`) || isAbsolute18(inside))
     throw new Error(`Agent root alias target must be inside the real home: ${alias}`);
   return { agent, home: realHome, alias, target, link: link2, aliasIdentity: `${stat.dev}:${stat.ino}:${stat.ctimeNs}`, targetIdentity: `${targetStat.dev}:${targetStat.ino}` };
 }
@@ -54674,13 +54936,13 @@ function disabledCodexSkillPaths(config, aliases) {
   const rows = skills.config;
   if (!Array.isArray(rows))
     return [];
-  if (rows.some((entry) => !entry || typeof entry !== "object" || Array.isArray(entry) || typeof entry.enabled !== "boolean" || entry.path !== undefined === (entry.name !== undefined) || entry.path !== undefined && (typeof entry.path !== "string" || !isAbsolute17(entry.path)) || entry.name !== undefined && (typeof entry.name !== "string" || !entry.name.trim())))
+  if (rows.some((entry) => !entry || typeof entry !== "object" || Array.isArray(entry) || typeof entry.enabled !== "boolean" || entry.path !== undefined === (entry.name !== undefined) || entry.path !== undefined && (typeof entry.path !== "string" || !isAbsolute18(entry.path)) || entry.name !== undefined && (typeof entry.name !== "string" || !entry.name.trim())))
     return [];
   if (rows.some((entry) => entry.name !== undefined && entry.enabled !== false))
     return [];
   const settings = new Map;
   for (const entry of rows) {
-    if (typeof entry.path !== "string" || !isAbsolute17(entry.path))
+    if (typeof entry.path !== "string" || !isAbsolute18(entry.path))
       continue;
     let document3;
     try {
@@ -54712,7 +54974,7 @@ function readNativeBytes(path, maximum = 64 * 1024 * 1024) {
   const before2 = lstatSync21(path);
   if (!before2.isFile() || before2.size > maximum)
     throw new Error("Unsupported or oversized native skill file");
-  const descriptor = openSync12(path, constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK);
+  const descriptor = openSync12(path, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
   try {
     const opened = fstatSync12(descriptor);
     if (!opened.isFile() || opened.dev !== before2.dev || opened.ino !== before2.ino || opened.size !== before2.size)
@@ -54785,16 +55047,16 @@ function parseNativeMigrationTargetManifest(input) {
       throw new Error("Invalid native migration target fields");
     if (!ROOTS.some(([agent]) => agent === item.agent))
       throw new Error(`Unsupported native migration target agent: ${item.agent}`);
-    if (!isAbsolute17(item.projectRoot) || resolve17(item.projectRoot) !== item.projectRoot)
+    if (!isAbsolute18(item.projectRoot) || resolve17(item.projectRoot) !== item.projectRoot)
       throw new Error(`Native migration target project root must be an existing absolute directory: ${item.projectRoot}`);
     const projectRoot = canonicalSystemPath(item.projectRoot);
     if (!existsSync13(projectRoot) || !lstatSync21(projectRoot).isDirectory())
       throw new Error(`Native migration target project root must be an existing absolute directory: ${item.projectRoot}`);
     assertSafePath(projectRoot);
-    if (isAbsolute17(item.path) || item.path.includes("\\") || item.path.length === 0 || item.path.includes("\x00"))
+    if (isAbsolute18(item.path) || item.path.includes("\\") || item.path.length === 0 || item.path.includes("\x00"))
       throw new Error(`Native migration target path must be normalized and project-relative: ${item.path}`);
     const resolved = resolve17(projectRoot, item.path), normalized = relative6(projectRoot, resolved);
-    if (!normalized || normalized === ".." || normalized.startsWith(`..${sep7}`) || isAbsolute17(normalized) || normalized !== item.path)
+    if (!normalized || normalized === ".." || normalized.startsWith(`..${sep7}`) || isAbsolute18(normalized) || normalized !== item.path)
       throw new Error(`Native migration target path escapes or is not normalized: ${item.path}`);
     if (!/^[0-9a-f]{64}$/.test(item.treeSha256))
       throw new Error(`Invalid native migration tree digest for ${item.path}`);
@@ -54815,13 +55077,13 @@ function selectNativeMigrationTargets(inventory, manifest) {
   const identities = new Set;
   const selected = [];
   for (const target of manifest.targets) {
-    if (!isAbsolute17(target.projectRoot) || resolve17(target.projectRoot) !== target.projectRoot)
+    if (!isAbsolute18(target.projectRoot) || resolve17(target.projectRoot) !== target.projectRoot)
       throw new Error(`Native migration target project root must be an existing absolute directory: ${target.projectRoot}`);
     const projectRoot = canonicalSystemPath(target.projectRoot), normalized = relative6(projectRoot, resolve17(projectRoot, target.path));
     if (!existsSync13(projectRoot) || !lstatSync21(projectRoot).isDirectory())
       throw new Error(`Native migration target project root must be an existing absolute directory: ${target.projectRoot}`);
     assertSafePath(projectRoot);
-    if (isAbsolute17(target.path) || target.path.includes("\\") || target.path.includes("\x00") || !normalized || normalized === ".." || normalized.startsWith(`..${sep7}`) || normalized !== target.path || !/^[0-9a-f]{64}$/.test(target.treeSha256))
+    if (isAbsolute18(target.path) || target.path.includes("\\") || target.path.includes("\x00") || !normalized || normalized === ".." || normalized.startsWith(`..${sep7}`) || normalized !== target.path || !/^[0-9a-f]{64}$/.test(target.treeSha256))
       throw new Error(`Invalid native migration target: ${target.path}`);
     const identity6 = `${target.agent}\x00${canonicalSystemPath(projectRoot)}\x00${normalized}`;
     if (identities.has(identity6))
@@ -54864,25 +55126,32 @@ function isCodexSkillDiscoveryInput(path) {
 }
 function inventoryNativeSkills(home = homedir3(), options = {}) {
   home = canonicalSystemPath(home);
-  if (options.reviewedCacheAlias !== undefined && (!options.includeVendor || !isAbsolute17(options.reviewedCacheAlias) || resolve17(options.reviewedCacheAlias) !== options.reviewedCacheAlias))
+  if (options.reviewedCacheAlias !== undefined && (!options.includeVendor || !isAbsolute18(options.reviewedCacheAlias) || resolve17(options.reviewedCacheAlias) !== options.reviewedCacheAlias))
     throw new Error("A reviewed cache alias requires vendor inventory and an exact absolute path");
-  if (options.disabledVendorPaths?.some((path) => !isAbsolute17(path) || resolve17(path) !== path))
+  if (options.disabledVendorPaths?.some((path) => !isAbsolute18(path) || resolve17(path) !== path))
     throw new Error("Disabled vendor paths must be exact absolute paths");
   const reviewedCacheAlias = options.reviewedCacheAlias === undefined ? undefined : canonicalSystemPath(options.reviewedCacheAlias);
   const disabledVendorPaths = new Set((options.disabledVendorPaths ?? []).map(canonicalSystemPath));
   const aliases = rootAliases(home, options.allowRootAliases);
   const selectedAgents = options.agents ? new Set(options.agents) : undefined;
   const includesAgent = (agent) => !selectedAgents || selectedAgents.has(agent);
-  const rootDefinitions = selectedAgents ? ROOTS.filter(([agent, path]) => selectedAgents.has(agent) || selectedAgents.has("hermes") && agent === "codex" && path === ".agents/skills") : ROOTS;
+  const rootDefinitions = selectedAgents ? ROOTS.filter(([agent, path]) => agent !== "sumi" && selectedAgents.has(agent) || selectedAgents.has("hermes") && agent === "codex" && path === ".agents/skills") : ROOTS.filter(([agent]) => agent !== "sumi");
   const roots = rootDefinitions.map(([agent, path]) => [agent, canonicalAgentPath(join28(home, path), aliases)]);
-  const bridgePaths = Object.entries(AGENT_ADAPTERS).filter(([agent]) => agent !== "sumi" || includesAgent("sumi")).map(([agent, adapter]) => canonicalAgentPath(join28(agent === "sumi" ? sumiBridgeRoot(home) : join28(home, adapter.root), CLI_BRIDGE_NAME), aliases));
+  const includesSumi = !selectedAgents || selectedAgents.has("sumi");
+  if (includesSumi)
+    for (const path of sumiSkillRoots(home))
+      roots.push(["sumi", canonicalAgentPath(path, aliases)]);
+  const bridgePaths = Object.entries(AGENT_ADAPTERS).filter(([agent]) => agent !== "sumi" || includesSumi).map(([agent]) => canonicalAgentPath(join28(nativeAgentRoot(home, agent), CLI_BRIDGE_NAME), aliases));
   for (const project of projectAncestorDirectories([...options.projectDirs ?? [], ...options.projectDir ? [options.projectDir] : []])) {
     for (const [agent, path] of rootDefinitions)
       roots.push([agent, canonicalAgentPath(join28(project, path), aliases)]);
-    if (selectedAgents?.has("sumi"))
+    if (selectedAgents?.has("sumi")) {
+      for (const path of sumiSkillRoots(home, project))
+        roots.push(["sumi", canonicalAgentPath(path, aliases)]);
       for (const directory of [".claude", ".agents"])
         for (const name of ["skill", "skills"])
           roots.push(["sumi", canonicalAgentPath(join28(project, directory, name), aliases)]);
+    }
   }
   const installationInputs = options.codexInstallationInputRoots ?? [];
   if (installationInputs.some((input) => resolve17(input) !== input || realpathSync10(input) !== input || roots.some(([agent, path]) => agent === "codex" && (path === input || path.startsWith(input + sep7) || input.startsWith(path + sep7)))))
@@ -54900,7 +55169,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
   let reviewedCacheAliasFound = false;
   function verifiedSiblingCacheAlias(agent, path, parent) {
     const link2 = readlinkSync7(path), lexicalTarget = resolve17(parent, link2);
-    if (isAbsolute17(link2) ? link2 !== lexicalTarget : dirname16(link2) !== ".")
+    if (isAbsolute18(link2) ? link2 !== lexicalTarget : dirname16(link2) !== ".")
       return false;
     const target = canonicalSystemPath(lexicalTarget);
     if (dirname16(target) !== parent)
@@ -54980,7 +55249,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
         continue;
       const child2 = join28(path, name);
       if (isVendor && lstatSync21(child2, { throwIfNoEntry: false })?.isSymbolicLink()) {
-        const target = statSync9(child2, { throwIfNoEntry: false });
+        const target = statSync10(child2, { throwIfNoEntry: false });
         if (target?.isFile() || pluginCache && target?.isDirectory() && verifiedSiblingCacheAlias(agent, child2, path)) {
           scan.entries++;
           continue;
@@ -55244,8 +55513,7 @@ function planAgentIntegration(options) {
     if (!INTEGRATION_AGENTS.includes(agent))
       throw new Error(`Unsupported agent: ${agent}`);
     const { command, profileId: profileId2 } = bindings.get(agent);
-    const adapter = AGENT_ADAPTERS[agent];
-    const bridgePath = canonicalAgentPath(join28(agent === "sumi" ? sumiBridgeRoot(home) : join28(home, adapter.root), CLI_BRIDGE_NAME), aliases);
+    const bridgePath = canonicalAgentPath(join28(nativeAgentRoot(home, agent, options.projectDir ?? process.cwd()), CLI_BRIDGE_NAME), aliases);
     assertSafePath(bridgePath);
     if (existsSync13(bridgePath) && !isOwnedCliBridge(bridgePath, [bridgePath]))
       throw new Error(`Refusing to overwrite an unrecognized or modified Skills bridge: ${bridgePath}`);
@@ -55254,7 +55522,7 @@ function planAgentIntegration(options) {
       if (before3 !== after3)
         changes.push({ path: path2, before: before3, after: after3 });
     }
-    const path = canonicalAgentPath(agent === "sumi" ? sumiConfigPath(home) : join28(home, adapter.config), aliases);
+    const path = canonicalAgentPath(nativeAgentConfig(home, agent, options.projectDir ?? process.cwd()), aliases);
     const before2 = readOptional(path);
     if (agent === "hermes") {
       const supervisorPath = join28(dataDir3, "agent-hooks", "hermes.js"), supervisorBefore = readOptional(supervisorPath), supervisorAfter = renderHermesSupervisor(command, profileId2);
@@ -55279,7 +55547,7 @@ function planAgentIntegration(options) {
       if (config.permissions !== undefined && (!Array.isArray(config.permissions) || config.permissions.some((rule) => !rule || typeof rule.action !== "string" || typeof rule.resource !== "string" || !["allow", "deny", "ask"].includes(rule.effect))))
         throw new Error("Expected Sumi native permission rules");
       config.permissions = [...(config.permissions ?? []).filter((rule) => rule.action !== "skill"), ...SUMI_SKILL_PERMISSIONS];
-      const pluginPath = join28(sumiConfigDirectory(home), "plugins", "skills-cli.js"), pluginBefore = readOptional(pluginPath);
+      const pluginPath = join28(sumiConfigDirectory(home, process.env, options.projectDir ?? process.cwd()), "plugins", "skills-cli.js"), pluginBefore = readOptional(pluginPath);
       const pluginAfter = renderSumiPlugin(command, profileId2);
       const priorCommand = policy.bridge?.commands?.sumi, priorProfile = policy.bridge?.profiles?.sumi ?? policy.profileId;
       if (pluginBefore !== null && pluginBefore !== pluginAfter && !(typeof priorCommand === "string" && typeof priorProfile === "string" && isManagedSumiPlugin(pluginBefore, priorCommand, priorProfile)))
@@ -55370,7 +55638,7 @@ function projectedHookAcl(path, observed) {
   if (process.platform !== "darwin")
     return;
   const identity6 = observed.isDirectory() ? (stat) => `${stat.dev}:${stat.ino}:${stat.uid}:${stat.mode}` : (stat) => `${stat.dev}:${stat.ino}:${stat.ctimeNs}:${stat.uid}:${stat.mode}:${stat.nlink}:${stat.size}:${stat.mtimeNs}`;
-  const fd = openSync12(path, constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK | (observed.isDirectory() ? constants13.O_DIRECTORY : 0));
+  const fd = openSync12(path, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK | (observed.isDirectory() ? constants14.O_DIRECTORY : 0));
   try {
     if (identity6(fstatSync12(fd, { bigint: true })) !== identity6(observed) || !hasTrustedDarwinAcl(fd, true) || identity6(fstatSync12(fd, { bigint: true })) !== identity6(observed) || identity6(lstatSync21(path, { bigint: true })) !== identity6(observed))
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
@@ -55380,7 +55648,7 @@ function projectedHookAcl(path, observed) {
 }
 function projectedHookExecutable(command, expectedResolved) {
   try {
-    if (!isAbsolute17(command) || /[\0\r\n]/.test(command) || resolve17(command) !== command)
+    if (!isAbsolute18(command) || /[\0\r\n]/.test(command) || resolve17(command) !== command)
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     command = canonicalSystemPath(command);
     const parents2 = (file = command) => {
@@ -55600,7 +55868,7 @@ function planAgentSettingsWitnessUpgrade(options) {
   const binding = policy.bridge?.discovery?.[options.agent];
   if (!binding || binding.agent !== options.agent || binding.method !== "reviewed")
     throw new Error("Settings witness upgrade requires an existing reviewed native binding");
-  const configPath = canonicalAgentPath(options.agent === "sumi" ? sumiConfigPath(home) : join28(home, options.agent === "claude" ? ".claude/settings.json" : ".codex/config.toml"), aliases);
+  const configPath = canonicalAgentPath(options.agent === "sumi" ? nativeAgentConfig(home, "sumi", options.projectDir ?? process.cwd()) : join28(home, options.agent === "claude" ? ".claude/settings.json" : ".codex/config.toml"), aliases);
   const settings = readOptional(configPath);
   if (settings === null || sha3(settings) !== options.expectedSettingsSha256)
     throw new Error("Native settings preimage changed");
@@ -55778,7 +56046,7 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
 }
 function syncArchiveDirectory(path) {
   assertSafePath(path);
-  const descriptor = openSync12(path, constants13.O_RDONLY | constants13.O_DIRECTORY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK);
+  const descriptor = openSync12(path, constants14.O_RDONLY | constants14.O_DIRECTORY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
   try {
     fsyncSync5(descriptor);
   } finally {
@@ -55790,7 +56058,7 @@ function writeArchiveJournal(path, value) {
   const temporary = `${path}.skills-${randomUUID6()}`;
   let descriptor;
   try {
-    descriptor = openSync12(temporary, constants13.O_WRONLY | constants13.O_CREAT | constants13.O_EXCL | constants13.O_NOFOLLOW, 384);
+    descriptor = openSync12(temporary, constants14.O_WRONLY | constants14.O_CREAT | constants14.O_EXCL | constants14.O_NOFOLLOW, 384);
     writeFileSync6(descriptor, `${JSON.stringify(value)}
 `);
     fsyncSync5(descriptor);
@@ -55824,7 +56092,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
   recheckRootAliases(aliases);
   for (const entry of inventory.filter((entry2) => entry2.bridge)) {
     const adapter = AGENT_ADAPTERS[entry.agent];
-    const expected = adapter && entry.bridgeHome ? canonicalAgentPath(join28(entry.agent === "sumi" ? sumiBridgeRoot(entry.bridgeHome) : join28(entry.bridgeHome, adapter.root), CLI_BRIDGE_NAME), aliases) : undefined;
+    const expected = adapter && entry.bridgeHome ? canonicalAgentPath(join28(nativeAgentRoot(entry.bridgeHome, entry.agent), CLI_BRIDGE_NAME), aliases) : undefined;
     if (!expected || treeHash(entry.path) !== entry.hash || !isOwnedCliBridge(entry.path, [expected]))
       throw new Error(`Skills bridge changed after planning: ${entry.path}`);
   }
@@ -55948,7 +56216,7 @@ function isInertCodexPluginCacheCopy(entry, cache3, allowedHostPaths, read2) {
       return false;
     const document3 = join28(entry.path, "SKILL.md");
     const inside = relative6(cache3, entry.path);
-    if (!inside || isAbsolute17(inside) || inside.split(sep7).some((segment) => segment === ".."))
+    if (!inside || isAbsolute18(inside) || inside.split(sep7).some((segment) => segment === ".."))
       return false;
     assertSafePath(entry.path);
     if (!lstatSync21(cache3).isDirectory() || !lstatSync21(entry.path).isDirectory() || !lstatSync21(document3).isFile())
@@ -55980,14 +56248,14 @@ function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscov
   if (!Array.isArray(aliases))
     throw new Error("NATIVE_SKILL_DRIFT: invalid root alias binding");
   recheckRootAliases(aliases);
-  const expected = canonicalAgentPath(join28(agent === "sumi" ? sumiBridgeRoot(home) : join28(home, AGENT_ADAPTERS[agent].root), CLI_BRIDGE_NAME), aliases);
+  const expected = canonicalAgentPath(join28(nativeAgentRoot(home, agent, options.projectDir ?? process.cwd()), CLI_BRIDGE_NAME), aliases);
   if (!isOwnedCliBridge(expected, [expected]))
     throw new Error("NATIVE_SKILL_DRIFT: the native Skills bridge is missing or modified; repair it before continuing");
   const roots = projectAncestorDirectories([options.projectDir ?? process.cwd(), ...options.projectDirs ?? [], ...agent === "hermes" && process.env.TERMINAL_CWD ? [process.cwd()] : []]);
   const visible = (entry) => entry.agent === agent || ["codex", "gemini", "opencode", "hermes", "sumi"].includes(agent) && entry.path.includes(`${sep7}.agents${sep7}skills${sep7}`) || ["opencode", "sumi"].includes(agent) && entry.agent === "claude";
   const discovery = provenDiscovery ?? binding.discovery?.[agent];
   assertProjectDiscovery(agent, [...roots], home, (path) => canonicalAgentPath(path, aliases), discovery);
-  const configPath = canonicalAgentPath(agent === "sumi" ? sumiConfigPath(home) : join28(home, AGENT_ADAPTERS[agent].config), aliases), config = agent === "hermes" ? parseHermesConfig(readOptional(configPath)) : jsonObject(readOptional(configPath), configPath);
+  const configPath = canonicalAgentPath(nativeAgentConfig(home, agent, options.projectDir ?? process.cwd()), aliases), config = agent === "hermes" ? parseHermesConfig(readOptional(configPath)) : jsonObject(readOptional(configPath), configPath);
   const command = binding.commands?.[agent], profile = binding.profiles?.[agent];
   if (typeof command !== "string" || typeof profile !== "string")
     throw new Error("NATIVE_SKILL_DRIFT: the native hook command/profile binding is missing");
@@ -55999,7 +56267,7 @@ function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscov
       throw new Error("NATIVE_SKILL_DRIFT: Hermes supervisor binding changed; run skills hook install");
     assertHermesProtection(home, config, command, profile, supervisor);
   } else if (agent === "sumi") {
-    if (JSON.stringify(config.permissions?.filter((rule) => rule.action === "skill")) !== JSON.stringify(SUMI_SKILL_PERMISSIONS) || !isManagedSumiPlugin(readOptional(join28(sumiConfigDirectory(home), "plugins", "skills-cli.js")), command, profile))
+    if (JSON.stringify(config.permissions?.filter((rule) => rule.action === "skill")) !== JSON.stringify(SUMI_SKILL_PERMISSIONS) || !isManagedSumiPlugin(readOptional(join28(sumiConfigDirectory(home, process.env, options.projectDir ?? process.cwd()), "plugins", "skills-cli.js")), command, profile))
       throw new Error("NATIVE_SKILL_DRIFT: Sumi bridge protection changed; run skills hook install");
   } else if (agent === "opencode") {
     if (JSON.stringify(config.permission?.skill) !== JSON.stringify({ "*": "deny", [CLI_BRIDGE_NAME]: "allow" }) || readOptional(join28(home, ".config", "opencode", "plugins", "skills-cli.js")) !== renderOpenCodePlugin(command, profile))
@@ -56105,7 +56373,7 @@ function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscov
       return escaped.length > 768 ? `${escaped.slice(0, 384)}...${escaped.slice(-381)}` : escaped;
     });
     const remaining = unexpected.length - paths.length;
-    throw new Error(`NATIVE_SKILL_DRIFT: ${unexpected.length} unexpected native skill copies were found: ${paths.join(", ")}${remaining ? `; ${remaining} more` : ""}. Review skills migrate native --project <working-directory> --include-unmanaged --include-vendor --json before continuing; it inventories that directory and its ancestors. Use --apply after reviewing the archive plan.${adapterRefusal ? ` Native policy adapter refused: ${adapterRefusal}` : ""}`);
+    throw new Error(`NATIVE_SKILL_DRIFT: ${unexpected.length} unexpected native skill copies were found: ${paths.join(", ")}${remaining ? `; ${remaining} more` : ""}. Review skills migrate native --agent ${agent} --project <working-directory> --include-unmanaged --include-vendor --json before continuing; it inventories that directory and its ancestors. Use --apply after reviewing the archive plan.${adapterRefusal ? ` Native policy adapter refused: ${adapterRefusal}` : ""}`);
   }
   recheckRootAliases(aliases);
 }
@@ -56170,7 +56438,7 @@ var init_agent_integration = __esm(() => {
 });
 
 // src/lib/home-migration.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, readdirSync as readdirSync9, renameSync as renameSync4, rmSync, statSync as statSync10, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readdirSync as readdirSync9, renameSync as renameSync4, rmSync, statSync as statSync11, writeFileSync as writeFileSync7 } from "fs";
 import { join as join29 } from "path";
 function layoutMigrationRecordPath(appDir) {
   return join29(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD);
@@ -56183,7 +56451,7 @@ function migrationAppDir(homeDir2) {
 }
 function looksLikeSkillDirectory(path) {
   try {
-    if (!statSync10(path).isDirectory())
+    if (!statSync11(path).isDirectory())
       return false;
   } catch {
     return false;
@@ -56315,7 +56583,7 @@ import {
   readdirSync as readdirSync10,
   renameSync as renameSync5,
   rmSync as rmSync2,
-  statSync as statSync11,
+  statSync as statSync12,
   writeFileSync as writeFileSync8
 } from "fs";
 import { homedir as homedir4 } from "os";
@@ -56432,7 +56700,7 @@ function containsSkillDirectories(path) {
 }
 function isDirectory(path) {
   try {
-    return statSync11(path).isDirectory();
+    return statSync12(path).isDirectory();
   } catch {
     return false;
   }
@@ -57962,8 +58230,8 @@ var init_plugin_projection = __esm(() => {
 
 // src/lib/plugin-projection-store.ts
 import { createHash as createHash22, randomUUID as randomUUID7 } from "crypto";
-import { constants as constants14, closeSync as closeSync13, fchmodSync as fchmodSync2, fstatSync as fstatSync13, fsyncSync as fsyncSync6, linkSync as linkSync3, lstatSync as lstatSync23, mkdirSync as mkdirSync10, openSync as openSync13, opendirSync as opendirSync4, readSync as readSync10, renameSync as renameSync6, rmdirSync as rmdirSync3, rmSync as rmSync4, unlinkSync as unlinkSync5, writeSync as writeSync3 } from "fs";
-import { dirname as dirname18, isAbsolute as isAbsolute18, join as join34, parse as parse6, resolve as resolve18 } from "path";
+import { constants as constants15, closeSync as closeSync13, fchmodSync as fchmodSync2, fstatSync as fstatSync13, fsyncSync as fsyncSync6, linkSync as linkSync3, lstatSync as lstatSync23, mkdirSync as mkdirSync10, openSync as openSync13, opendirSync as opendirSync4, readSync as readSync10, renameSync as renameSync6, rmdirSync as rmdirSync3, rmSync as rmSync4, unlinkSync as unlinkSync5, writeSync as writeSync3 } from "fs";
+import { dirname as dirname18, isAbsolute as isAbsolute19, join as join34, parse as parse6, resolve as resolve18 } from "path";
 function stat(path) {
   try {
     return lstatSync23(path, { bigint: true });
@@ -57974,7 +58242,7 @@ function stat(path) {
   }
 }
 function canonical7(path) {
-  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute18(path) && resolve18(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
+  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute19(path) && resolve18(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
 }
 function owner(stats, system = false) {
   const current = uid();
@@ -58324,8 +58592,8 @@ function pluginExecutableDigest(path) {
 var READ_FLAGS, WRITE_FLAGS, uid = () => typeof process.getuid === "function" ? BigInt(process.getuid()) : undefined, missing = (error) => Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
 var init_plugin_projection_store = __esm(() => {
   init_plugin_projection();
-  READ_FLAGS = constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK;
-  WRITE_FLAGS = constants14.O_WRONLY | constants14.O_CREAT | constants14.O_EXCL | constants14.O_NOFOLLOW | constants14.O_NONBLOCK;
+  READ_FLAGS = constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK;
+  WRITE_FLAGS = constants15.O_WRONLY | constants15.O_CREAT | constants15.O_EXCL | constants15.O_NOFOLLOW | constants15.O_NONBLOCK;
 });
 
 // src/lib/selected-manifest.ts
@@ -58356,7 +58624,7 @@ var init_selected_manifest = __esm(() => {
 
 // src/lib/plugin-admission.ts
 import { homedir as homedir6 } from "os";
-import { isAbsolute as isAbsolute19, join as join35, resolve as resolve19 } from "path";
+import { isAbsolute as isAbsolute20, join as join35, resolve as resolve19 } from "path";
 function pluginAdmissionRoot() {
   return join35(homedir6(), ".hasna", "skills", "plugin-admission");
 }
@@ -58369,7 +58637,7 @@ function validatePluginTarget(value) {
   for (const registration of value.registrations) {
     pluginKeys(registration, ["scope", "projectPath"]);
     pluginNeed(registration.scope === "user" || registration.scope === "project", "Unsupported plugin registration scope");
-    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute19(registration.projectPath) && resolve19(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
+    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute20(registration.projectPath) && resolve19(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
     const key = JSON.stringify([registration.scope, registration.projectPath]);
     pluginNeed(!scopes.has(key), "Duplicate plugin registration scope");
     scopes.add(key);
@@ -58377,7 +58645,7 @@ function validatePluginTarget(value) {
   for (const key of ["native", "resolver"]) {
     pluginKeys(value[key], key === "native" ? ["version", "executable", "digest"] : ["executable", "digest"]);
     pluginText(value[key].executable);
-    pluginNeed(isAbsolute19(value[key].executable) && resolve19(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
+    pluginNeed(isAbsolute20(value[key].executable) && resolve19(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
     pluginDigest(value[key].digest);
   }
   pluginNeed(["2.1.274", "2.1.276"].includes(value.native.version), "Plugin admission requires a certified Claude command-source runtime (2.1.274 or 2.1.276)");
@@ -58527,7 +58795,7 @@ function pluginResolverCommand(binding) {
 }
 function root(options) {
   const path = options.storeRoot ?? pluginAdmissionRoot();
-  pluginNeed(isAbsolute19(path) && resolve19(path) === path, "Invalid plugin admission store root");
+  pluginNeed(isAbsolute20(path) && resolve19(path) === path, "Invalid plugin admission store root");
   return path;
 }
 function pluginBindingPath(storeRoot, id) {
@@ -58734,8 +59002,8 @@ var init_plugin_admission = __esm(() => {
 });
 
 // src/lib/plugin-discovery.ts
-import { closeSync as closeSync14, constants as constants15, fstatSync as fstatSync14, lstatSync as lstatSync24, openSync as openSync14, opendirSync as opendirSync5, readSync as readSync11 } from "fs";
-import { basename as basename10, dirname as dirname19, isAbsolute as isAbsolute20, join as join36, resolve as resolve20 } from "path";
+import { closeSync as closeSync14, constants as constants16, fstatSync as fstatSync14, lstatSync as lstatSync24, openSync as openSync14, opendirSync as opendirSync5, readSync as readSync11 } from "fs";
+import { basename as basename10, dirname as dirname19, isAbsolute as isAbsolute21, join as join36, resolve as resolve20 } from "path";
 function validateManagedPluginWitnesses(value) {
   pluginNeed(Array.isArray(value) && value.length > 0 && value.length <= PLUGIN_PROJECTION_LIMITS.registrations, "Invalid managed plugin witness collection");
   const seen = new Set;
@@ -58744,12 +59012,12 @@ function validateManagedPluginWitnesses(value) {
     pluginNeed(typeof item.bindingId === "string" && /^[a-f0-9]{64}$/.test(item.bindingId) && !seen.has(item.bindingId), "Invalid or duplicate managed plugin witness");
     seen.add(item.bindingId);
     pluginText(item.storeRoot);
-    pluginNeed(isAbsolute20(item.storeRoot) && resolve20(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
+    pluginNeed(isAbsolute21(item.storeRoot) && resolve20(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
   }
 }
 function safe3(path) {
   pluginText(path);
-  pluginNeed(isAbsolute20(path) && resolve20(path) === path, "Invalid plugin registry path");
+  pluginNeed(isAbsolute21(path) && resolve20(path) === path, "Invalid plugin registry path");
   for (let at2 = path;; at2 = dirname19(at2)) {
     pluginNeed(!lstatSync24(at2, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
     if (at2 === dirname19(at2))
@@ -58760,7 +59028,7 @@ function readRegistry(path) {
   safe3(path);
   const initial2 = lstatSync24(path);
   pluginNeed(initial2.isFile() && initial2.size <= 1024 * 1024, "Plugin registry is not a bounded regular file");
-  const fd = openSync14(path, constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK);
+  const fd = openSync14(path, constants16.O_RDONLY | constants16.O_NOFOLLOW | constants16.O_NONBLOCK);
   try {
     const opened = fstatSync14(fd);
     pluginNeed(opened.isFile() && opened.ino === initial2.ino && opened.dev === initial2.dev, "Plugin registry changed during open");
@@ -58886,14 +59154,14 @@ var init_plugin_discovery = __esm(() => {
 
 // src/lib/claude-marketplace-registry.ts
 import { createHash as createHash23 } from "crypto";
-import { closeSync as closeSync15, constants as constants16, fstatSync as fstatSync15, lstatSync as lstatSync25, openSync as openSync15, readSync as readSync12 } from "fs";
-import { basename as basename11, dirname as dirname20, isAbsolute as isAbsolute21, resolve as resolve21 } from "path";
+import { closeSync as closeSync15, constants as constants17, fstatSync as fstatSync15, lstatSync as lstatSync25, openSync as openSync15, readSync as readSync12 } from "fs";
+import { basename as basename11, dirname as dirname20, isAbsolute as isAbsolute22, resolve as resolve21 } from "path";
 function need7(value, reason2) {
   if (!value)
     throw new Error(`Claude marketplace registry ${reason2}`);
 }
-function absolutePath3(value) {
-  need7(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute21(value) && resolve21(value) === value, "requires a normalized absolute path");
+function absolutePath4(value) {
+  need7(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute22(value) && resolve21(value) === value, "requires a normalized absolute path");
 }
 function parents2(path) {
   const result2 = [];
@@ -58906,13 +59174,13 @@ function parents2(path) {
   }
 }
 function readRegistry2(path, budget2) {
-  absolutePath3(path);
+  absolutePath4(path);
   need7(basename11(path) === "known_marketplaces.json", "requires known_marketplaces.json");
   need7(Number.isSafeInteger(budget2.remaining) && budget2.remaining >= 0, "has an invalid byte budget");
   const ancestors2 = parents2(path), initial2 = lstatSync25(path, { bigint: true });
   need7(initial2.isFile() && !initial2.isSymbolicLink() && initial2.size <= BigInt(CLAUDE_MARKETPLACE_REGISTRY_LIMITS.bytes), "is not a bounded regular file");
   need7(initial2.size <= BigInt(budget2.remaining), "exceeds its aggregate byte limit");
-  const fd = openSync15(path, constants16.O_RDONLY | constants16.O_NOFOLLOW | constants16.O_NONBLOCK);
+  const fd = openSync15(path, constants17.O_RDONLY | constants17.O_NOFOLLOW | constants17.O_NONBLOCK);
   try {
     const opened = fstatSync15(fd, { bigint: true });
     need7(opened.isFile() && sameFile2(initial2, opened), "changed during open");
@@ -59039,8 +59307,8 @@ function normalizeRow(row, version = 1) {
     return;
   const sourceLocation = textField(field2(source, location));
   if (type.value === "directory")
-    absolutePath3(sourceLocation);
-  absolutePath3(textField(field2(row, "installLocation")));
+    absolutePath4(sourceLocation);
+  absolutePath4(textField(field2(row, "installLocation")));
   const updated = textField(field2(row, "lastUpdated"));
   need7(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(updated), "contains an invalid recognized update timestamp");
   const millis = Date.parse(updated);
@@ -59201,7 +59469,7 @@ var fail3 = () => new Error('CODEX_HOOK_TRUST_UNSUPPORTED_LAYOUT: preserve and c
 var init_codex_hook_trust_layout = () => {};
 
 // src/lib/codex-hook-additions-review.ts
-import { isAbsolute as isAbsolute22 } from "path";
+import { isAbsolute as isAbsolute23 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual9 } from "util";
 function exactKeys2(value, keys2) {
   need6(value && typeof value === "object" && !Array.isArray(value) && isDeepStrictEqual9(Object.keys(value).sort(), [...keys2].sort()), "RECONCILE_ADDITIONS_REVIEW_SCHEMA");
@@ -59215,7 +59483,7 @@ function readReviewedAdditionTrustStates(proof, before2, current, journalHooks)
   return captured.states;
 }
 function reviewNativeHookAdditions(options) {
-  need6(isAbsolute22(options.path), "RECONCILE_ADDITIONS_REVIEW_PATH");
+  need6(isAbsolute23(options.path), "RECONCILE_ADDITIONS_REVIEW_PATH");
   const reviewFile = snapshot(options.path, true), review = JSON.parse(reviewFile.text);
   exactKeys2(review, ["version", "kind", "reason", "producerEvidence", "journalIntentSha256", "policySha256", "configCurrentSha256", "hooksCurrentSha256", "producerBefore", "additions"]);
   need6((review.version === 1 || review.version === 2) && review.kind === "native-hook-additions" && text2(review.reason) && text2(review.producerEvidence), "RECONCILE_ADDITIONS_REVIEW_SCHEMA");
@@ -59223,7 +59491,7 @@ function reviewNativeHookAdditions(options) {
     need6(hash2(review[name]) && review[name] === expected, "RECONCILE_ADDITIONS_REVIEW_CHANGED");
   exactKeys2(review.producerBefore, ["configPath", "configSha256", "hooksPath", "hooksSha256"]);
   const before2 = review.producerBefore;
-  need6(isAbsolute22(before2.configPath) && isAbsolute22(before2.hooksPath) && hash2(before2.configSha256) && hash2(before2.hooksSha256), "RECONCILE_ADDITIONS_PRODUCER_PREIMAGE");
+  need6(isAbsolute23(before2.configPath) && isAbsolute23(before2.hooksPath) && hash2(before2.configSha256) && hash2(before2.hooksSha256), "RECONCILE_ADDITIONS_PRODUCER_PREIMAGE");
   const producerConfig = snapshot(before2.configPath, true), producerHooks = snapshot(before2.hooksPath, true);
   need6(producerConfig.sha256 === before2.configSha256 && producerHooks.sha256 === before2.hooksSha256 && producerHooks.sha256 === options.hooksBefore.sha256, "RECONCILE_ADDITIONS_PRODUCER_PREIMAGE");
   const original = structure(options.configBefore.text), producer = structure(producerConfig.text), expectedProducer = structuredClone(original), originalKeys = options.journalHooks.map((hook) => hook.key);
@@ -59316,13 +59584,13 @@ function createCodexHookDiscoveryRecovery(binding, before2, current, hooks, addi
   need6(isDeepStrictEqual10(expected, actual) && codexTrustReconcileWitness(before2.text, keys2) === codexTrustReconcileWitness(current.text, keys2) && codexTrustUnmanagedSemantic(before2.text, keys2) === codexTrustUnmanagedSemantic(current.text, keys2), "RECONCILE_DISCOVERY_TRUST_WITNESS");
   unchanged2(before2);
   unchanged2(current);
-  const witness = Object.freeze({ configPath: current.file, beforeSha256: before2.sha256, currentSha256: current.sha256, discoverySha256: sha4(JSON.stringify(binding)), typedProjectionSha256: projection });
+  const witness = Object.freeze({ configPath: current.file, beforeSha256: before2.sha256, currentSha256: current.sha256, discoverySha256: discoveryDigest(binding), typedProjectionSha256: projection });
   proofs2.set(witness, { before: before2, current, recheckAdditions });
   return witness;
 }
 function assertCodexHookDiscoveryRecovery(binding, witness) {
   const proof = proofs2.get(witness);
-  need6(!!proof && binding.agent === "codex" && witness.discoverySha256 === sha4(JSON.stringify(binding)), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
+  need6(!!proof && binding.agent === "codex" && witness.discoverySha256 === discoveryDigest(binding), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   unchanged2(proof.before);
   unchanged2(proof.current);
   proof.recheckAdditions();
@@ -59334,7 +59602,14 @@ function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witnes
   need6(source.sha256 === witness.beforeSha256 && currentDigest === witness.currentSha256, "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   return true;
 }
-var sha4 = (text3) => createHash24("sha256").update(text3).digest("hex"), fields, structure2 = (text3) => JSON.parse(JSON.stringify(Bun.TOML.parse(text3))), proofs2;
+var sha4 = (text3) => createHash24("sha256").update(text3).digest("hex"), fields, structure2 = (text3) => JSON.parse(JSON.stringify(Bun.TOML.parse(text3))), discoveryDigest = (binding) => {
+  const controls = binding.codexDisabledPluginSkills;
+  if (!Object.hasOwn(binding, "codexDisabledPluginSkills") || Array.isArray(controls) && controls.length === 0) {
+    const { codexDisabledPluginSkills: _controls, ...withoutControls } = binding;
+    return sha4(JSON.stringify({ ...withoutControls, codexDisabledPluginSkills: [] }));
+  }
+  return sha4(JSON.stringify(binding));
+}, proofs2;
 var init_codex_hook_discovery_recovery = __esm(() => {
   init_codex_hook_trust_files();
   init_codex_hook_trust_layout();
@@ -59347,7 +59622,7 @@ var init_codex_hook_discovery_recovery = __esm(() => {
 // src/lib/agent-discovery.ts
 import { createHash as createHash25 } from "crypto";
 import { lstatSync as lstatSync26, readFileSync as readFileSync21, readdirSync as readdirSync11, realpathSync as realpathSync11 } from "fs";
-import { basename as basename12, dirname as dirname21, isAbsolute as isAbsolute23, join as join37, resolve as resolve22, sep as sep8 } from "path";
+import { basename as basename12, dirname as dirname21, isAbsolute as isAbsolute24, join as join37, resolve as resolve22, sep as sep8 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual11 } from "util";
 function discoveryRootUnresolved(agent, command, detail) {
   return new Error(`${DISCOVERY_ROOT_UNRESOLVED}: ${agent} discovery cannot resolve its "${command}" executable: ${detail}. The reviewed discovery is unchanged; this is an environment gap, not drift.`);
@@ -59381,7 +59656,7 @@ function parseConfig(text3, path, toml = false) {
   }
 }
 function safe4(path) {
-  if (!isAbsolute23(path) || path.includes("\x00"))
+  if (!isAbsolute24(path) || path.includes("\x00"))
     throw new Error("Expected an absolute native discovery path");
   for (let cursor = path;; cursor = dirname21(cursor)) {
     if (lstatSync26(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
@@ -59401,19 +59676,20 @@ function read2(path, changes) {
     throw new Error(`Unsupported or oversized native discovery input: ${path}`);
   return readFileSync21(path, "utf8");
 }
-function assertReviewedClaudeCacheClosures(home, config, review) {
+function assertReviewedClaudeCacheClosures(home, config, review, canonical8) {
   const enabledIds = Object.entries(config.enabledPlugins ?? {}).filter(([, enabled]) => enabled === true).map(([id]) => id);
   if (enabledIds.length === 0)
     return;
-  const registryPath = join37(home, ".claude/plugins/installed_plugins.json");
-  const cacheRoot = join37(home, ".claude/plugins/cache");
+  const registryPath = canonical8(join37(home, ".claude/plugins/installed_plugins.json"));
+  const cacheAliasRoot = join37(home, ".claude/plugins/cache");
+  const cacheRoot = canonical8(cacheAliasRoot);
   const registryText = read2(registryPath);
   if (registryText === null)
     return;
   const registry = parseConfig(registryText, registryPath);
   if (registry.version !== 2 || !registry.plugins || typeof registry.plugins !== "object" || Array.isArray(registry.plugins))
     throw new Error("Reviewed Claude installed plugin registrations are invalid");
-  const cachePath = (path) => typeof path === "string" && isAbsolute23(path) && resolve22(path) === path && (path === cacheRoot || path.startsWith(cacheRoot + sep8));
+  const cachePath = (path) => typeof path === "string" && isAbsolute24(path) && resolve22(path) === path && [cacheAliasRoot, cacheRoot].some((root2) => path === root2 || path.startsWith(root2 + sep8));
   const activeRoots = new Set;
   for (const id of enabledIds) {
     const rows = registry.plugins[id];
@@ -59425,13 +59701,13 @@ function assertReviewedClaudeCacheClosures(home, config, review) {
       if (!row || typeof row !== "object" || Array.isArray(row) || typeof row.installPath !== "string") {
         throw new Error("Reviewed Claude enabled plugin registration requires an object with an installPath string");
       }
-      if (typeof row.installPath === "string" && (row.installPath === cacheRoot || row.installPath.startsWith(cacheRoot + sep8))) {
+      if ([cacheAliasRoot, cacheRoot].some((root2) => row.installPath === root2 || row.installPath.startsWith(root2 + sep8))) {
         if (!cachePath(row.installPath) || row.installPath.length > AGENT_POLICY_LIMITS.pathCharacters || row.version !== undefined && (typeof row.version !== "string" || basename12(row.installPath) !== row.version)) {
           throw new Error("Reviewed Claude discovery has a malformed active cache registration");
         }
-        if (row.scope === "user" && (row.projectPath === undefined || row.projectPath === null)) {} else if (row.scope === "project" && typeof row.projectPath === "string" && isAbsolute23(row.projectPath) && resolve22(row.projectPath) === row.projectPath && row.projectPath.length <= AGENT_POLICY_LIMITS.pathCharacters) {} else
+        if (row.scope === "user" && (row.projectPath === undefined || row.projectPath === null)) {} else if (row.scope === "project" && typeof row.projectPath === "string" && isAbsolute24(row.projectPath) && resolve22(row.projectPath) === row.projectPath && row.projectPath.length <= AGENT_POLICY_LIMITS.pathCharacters) {} else
           throw new Error("Reviewed Claude discovery has an unsupported active cache registration scope");
-        activeRoots.add(row.installPath);
+        activeRoots.add(canonical8(row.installPath));
       }
     }
   }
@@ -59676,12 +59952,12 @@ function absentRetiredClaudeRoots(binding) {
       if (!row || typeof row !== "object" || Array.isArray(row))
         return null;
       const value = row;
-      if (typeof value.installPath !== "string" || /[\x00-\x1f\x7f]/.test(value.installPath) || !isAbsolute23(value.installPath) || resolve22(value.installPath) !== value.installPath || value.installPath.length > AGENT_POLICY_LIMITS.pathCharacters)
+      if (typeof value.installPath !== "string" || /[\x00-\x1f\x7f]/.test(value.installPath) || !isAbsolute24(value.installPath) || resolve22(value.installPath) !== value.installPath || value.installPath.length > AGENT_POLICY_LIMITS.pathCharacters)
         return null;
       if (value.scope === "user")
         return value.projectPath === undefined || value.projectPath === null ? "user\x00" : null;
       if (value.scope === "project")
-        return typeof value.projectPath === "string" && !/[\x00-\x1f\x7f]/.test(value.projectPath) && value.projectPath.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute23(value.projectPath) && resolve22(value.projectPath) === value.projectPath ? `project\x00${value.projectPath}` : null;
+        return typeof value.projectPath === "string" && !/[\x00-\x1f\x7f]/.test(value.projectPath) && value.projectPath.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute24(value.projectPath) && resolve22(value.projectPath) === value.projectPath ? `project\x00${value.projectPath}` : null;
       return null;
     };
     if (Object.values(installed.plugins).some((value) => !Array.isArray(value) || value.some((row) => !row || typeof row.installPath !== "string" || row.installPath === root2 || row.installPath.startsWith(root2 + sep8) || root2.startsWith(row.installPath + sep8))))
@@ -59945,7 +60221,7 @@ function resolveAgentDiscovery(options) {
     if (config.skills !== undefined && (!Array.isArray(config.skills) || config.skills.some((path) => typeof path !== "string")))
       unresolved("skills must be a string array");
     for (const value of config.skills ?? []) {
-      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute23(value) || value.startsWith("~/")))
+      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute24(value) || value.startsWith("~/")))
         unresolved("remote or relative skill sources need a dedicated discovery adapter");
       roots.add(canonical8(value.startsWith("~/") ? join37(home, value.slice(2)) : value));
     }
@@ -60075,7 +60351,7 @@ function resolveAgentDiscovery(options) {
       return { path: source.path, sha256: manifestSha256, hashMode: "claude-plugin-manifest-v1" };
     });
     if (agent === "claude")
-      assertReviewedClaudeCacheClosures(home, config, review);
+      assertReviewedClaudeCacheClosures(home, config, review, canonical8);
     const combined = [...reviewedSources, ...reviewedSourcesWithManifestProjection];
     const unique = combined.filter((source, index) => combined.findIndex((candidate2) => isDeepStrictEqual11(candidate2, source)) === index);
     return { ...supplied, roots: [...new Set([...roots, ...supplied.roots])].sort(), sources: unique, ...agent === "gemini" ? { builtinNames } : {} };
@@ -60135,7 +60411,7 @@ function resolveAgentDiscovery(options) {
         unresolved("unsupported plugin enablement");
       const split2 = id.lastIndexOf("@"), name = id.slice(0, split2), marketplace = id.slice(split2 + 1);
       const market = config.marketplaces?.[marketplace] ?? (marketplace === "personal" ? { source_type: "local", source: home } : undefined);
-      if (split2 < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute23(market.source))
+      if (split2 < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute24(market.source))
         unresolved("enabled plugin marketplace is not an explicit local source");
       const catalogText = witness(join37(market.source, ".agents/plugins/marketplace.json"));
       if (catalogText === null)
@@ -60151,7 +60427,7 @@ function resolveAgentDiscovery(options) {
     if ((config.plugin?.length ?? 0) > 0 || config.skills?.urls?.length)
       unresolved("external plugin or remote skill source");
     for (const path of config.skills?.paths ?? []) {
-      if (typeof path !== "string" || !isAbsolute23(path))
+      if (typeof path !== "string" || !isAbsolute24(path))
         unresolved("relative or malformed added skill root");
       roots.add(path);
     }
@@ -60336,10 +60612,10 @@ import {
   realpathSync as realpathSync13,
   renameSync as renameSync7,
   rmSync as rmSync5,
-  statSync as statSync12,
+  statSync as statSync13,
   writeFileSync as writeFileSync10
 } from "fs";
-import { basename as basename14, dirname as dirname23, isAbsolute as isAbsolute24, join as join39, normalize as normalize4, relative as relative7, resolve as resolve24, sep as sep10 } from "path";
+import { basename as basename14, dirname as dirname23, isAbsolute as isAbsolute25, join as join39, normalize as normalize4, relative as relative7, resolve as resolve24, sep as sep10 } from "path";
 function getPortableSkillsRoot(options = {}) {
   return resolvePortableSkillsRoot(options, true);
 }
@@ -60367,7 +60643,7 @@ function findPortableSkill(name, options = {}) {
     return null;
   }
   const path = getPortableSkillPath(normalized, options);
-  if (!existsSync19(path) || !statSync12(path).isDirectory())
+  if (!existsSync19(path) || !statSync13(path).isDirectory())
     return null;
   try {
     return summarizePortableSkill(path, normalized);
@@ -60438,7 +60714,7 @@ function scaffoldPortableSkill(name, options = {}) {
 }
 function portPortableSkillDirectory(sourceDir, options = {}) {
   const absoluteSource = normalize4(sourceDir);
-  if (!existsSync19(absoluteSource) || !statSync12(absoluteSource).isDirectory()) {
+  if (!existsSync19(absoluteSource) || !statSync13(absoluteSource).isDirectory()) {
     throw new Error(`Import directory not found: ${sourceDir}`);
   }
   const continueOnError = options.continueOnError ?? true;
@@ -60497,7 +60773,7 @@ function assertDisjointImportPaths(source, destination) {
   const destinationPath = physicalImportPath(destination);
   const contains2 = (parent, child2) => {
     const path = relative7(parent, child2);
-    return path === "" || !isAbsolute24(path) && path !== ".." && !path.startsWith(`..${sep10}`);
+    return path === "" || !isAbsolute25(path) && path !== ".." && !path.startsWith(`..${sep10}`);
   };
   if (contains2(sourcePath, destinationPath) || contains2(destinationPath, sourcePath)) {
     throw new Error("Source and destination skill directories must not overlap");
@@ -60505,7 +60781,7 @@ function assertDisjointImportPaths(source, destination) {
 }
 function portPortableSkill(sourcePath, options = {}) {
   const absoluteSource = normalize4(sourcePath);
-  if (!existsSync19(absoluteSource) || !statSync12(absoluteSource).isDirectory()) {
+  if (!existsSync19(absoluteSource) || !statSync13(absoluteSource).isDirectory()) {
     throw new Error(`Skill source directory not found: ${sourcePath}`);
   }
   const inferred = readPortableSkillManifestForImport(absoluteSource);
@@ -60668,7 +60944,7 @@ function validatePortableSkillDirectory(name, skillPath) {
             const entryPath = join39(skillPath, command.entry);
             if (!existsSync19(entryPath))
               add4(issues, "portable.command_entry_missing", `Command '${command.name}' entry '${command.entry}' is missing`);
-            else if (statSync12(entryPath).isDirectory())
+            else if (statSync13(entryPath).isDirectory())
               add4(issues, "portable.command_entry_directory", `Command '${command.name}' entry '${command.entry}' must be a file`);
           }
         }
@@ -60708,13 +60984,13 @@ function summarizePortableSkill(skillPath, fallbackName) {
 }
 function safeIsDirectory(path) {
   try {
-    return statSync12(path).isDirectory();
+    return statSync13(path).isDirectory();
   } catch {
     return false;
   }
 }
 function isSafeRelativePath2(value) {
-  if (!value.trim() || isAbsolute24(value))
+  if (!value.trim() || isAbsolute25(value))
     return false;
   const normalized = normalize4(value).replace(/\\/g, "/");
   return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
@@ -62721,7 +62997,7 @@ var require_cli_spinners = __commonJS((exports, module) => {
 });
 
 // src/lib/auth-store.ts
-import { chmodSync as chmodSync2, existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync25, renameSync as renameSync8, statSync as statSync13, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync25, renameSync as renameSync8, statSync as statSync14, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
 import { basename as basename15, dirname as dirname24, join as join41 } from "path";
 function getAuthFilePath(env3 = process.env) {
   return skillsCredentialFilePath(env3);
@@ -62935,7 +63211,7 @@ function getApiUrl(action, env3 = process.env, options = {}) {
 }
 function credentialFileMode(env3 = process.env) {
   try {
-    return statSync13(skillsCredentialFilePath(env3)).mode & 511;
+    return statSync14(skillsCredentialFilePath(env3)).mode & 511;
   } catch {
     return null;
   }
@@ -65168,8 +65444,8 @@ var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, extendedDuration, guid, uui
   if (!version)
     return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
   return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
-}, uuid42, uuid6, uuid7, email2, html5Email, rfc5322Email, unicodeEmail, idnEmail, browserEmail, _emoji = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`, ipv4, ipv6, mac = (delimiter2) => {
-  const escapedDelim = escapeRegex(delimiter2 ?? ":");
+}, uuid42, uuid6, uuid7, email2, html5Email, rfc5322Email, unicodeEmail, idnEmail, browserEmail, _emoji = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`, ipv4, ipv6, mac = (delimiter3) => {
+  const escapedDelim = escapeRegex(delimiter3 ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
 }, cidrv4, cidrv6, base64, base64url, hostname2, domain, httpProtocol, e164, creditCard, dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date2, string = (params) => {
   const regex2 = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
@@ -88469,7 +88745,7 @@ var init_init = __esm(() => {
 });
 
 // src/lib/home-adoption.ts
-import { constants as constants17, closeSync as closeSync16, fstatSync as fstatSync16, lstatSync as lstatSync28, openSync as openSync16, readSync as readSync14, existsSync as existsSync25, mkdirSync as mkdirSync15, readdirSync as readdirSync15, readFileSync as readFileSync30, rmSync as rmSync7, statSync as statSync14, writeFileSync as writeFileSync15 } from "fs";
+import { constants as constants18, closeSync as closeSync16, fstatSync as fstatSync16, lstatSync as lstatSync28, openSync as openSync16, readSync as readSync14, existsSync as existsSync25, mkdirSync as mkdirSync15, readdirSync as readdirSync15, readFileSync as readFileSync30, rmSync as rmSync7, statSync as statSync15, writeFileSync as writeFileSync15 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join47 } from "path";
 function indexCanonicalCorpus(corpusRoot) {
@@ -88505,7 +88781,7 @@ function selectedHomeNames(options, index, homeDir2, agents) {
       continue;
     const present = agents.some((agent) => {
       try {
-        return statSync14(join47(agentGlobalSkillsDir(agent, homeDir2), name)).isDirectory();
+        return statSync15(join47(agentGlobalSkillsDir(agent, homeDir2), name)).isDirectory();
       } catch {
         return false;
       }
@@ -88539,7 +88815,7 @@ function scanUnmarkedHomes(options = {}) {
         continue;
       const dir = join47(home, skill);
       try {
-        if (!statSync14(dir).isDirectory())
+        if (!statSync15(dir).isDirectory())
           continue;
       } catch {
         continue;
@@ -88552,7 +88828,7 @@ function scanUnmarkedHomes(options = {}) {
       if (!existsSync25(skillMdPath))
         continue;
       const hash5 = hashSkillMarkdownFile(skillMdPath);
-      const mtime = statSync14(skillMdPath).mtime.toISOString();
+      const mtime = statSync15(skillMdPath).mtime.toISOString();
       const entry = { agent, skill, home, path: dir, hash: hash5, mtime };
       const canonicalHash = index.get(skill);
       if (canonicalHash === undefined) {
@@ -88647,7 +88923,7 @@ function pruneOwnership(dir) {
     const markerPath = join47(dir, SYNC_MARKER_FILE), markerPathBefore = lstatSync28(markerPath);
     if (!markerPathBefore.isFile())
       return;
-    descriptor = openSync16(markerPath, constants17.O_RDONLY | constants17.O_NOFOLLOW | constants17.O_NONBLOCK);
+    descriptor = openSync16(markerPath, constants18.O_RDONLY | constants18.O_NOFOLLOW | constants18.O_NONBLOCK);
     const before2 = fstatSync16(descriptor);
     if (!before2.isFile() || before2.dev !== markerPathBefore.dev || before2.ino !== markerPathBefore.ino || before2.size !== markerPathBefore.size || before2.mtimeMs !== markerPathBefore.mtimeMs || before2.ctimeMs !== markerPathBefore.ctimeMs || before2.size < 1 || before2.size > 65536)
       return;
@@ -88698,7 +88974,7 @@ function pruneStrayHomes(options = {}) {
         continue;
       const dir = join47(home, skill);
       try {
-        if (!statSync14(dir).isDirectory())
+        if (!statSync15(dir).isDirectory())
           continue;
       } catch {
         continue;
@@ -88756,7 +89032,7 @@ var init_home_adoption = __esm(() => {
 });
 
 // src/lib/home-census.ts
-import { existsSync as existsSync26, readFileSync as readFileSync31, readdirSync as readdirSync16, statSync as statSync15 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync31, readdirSync as readdirSync16, statSync as statSync16 } from "fs";
 import { homedir as homedir9 } from "os";
 import { join as join48 } from "path";
 function sortEntries(entries) {
@@ -88801,7 +89077,7 @@ function censusHomeDrift(options = {}) {
         continue;
       const dir = join48(home, skill);
       try {
-        if (!statSync15(dir).isDirectory())
+        if (!statSync16(dir).isDirectory())
           continue;
       } catch {
         continue;
@@ -88872,13 +89148,13 @@ var init_home_census = __esm(() => {
 });
 
 // src/cli/env-assignment.ts
-import { closeSync as closeSync17, constants as constants18, fstatSync as fstatSync17, ftruncateSync as ftruncateSync2, lstatSync as lstatSync29, openSync as openSync17, readFileSync as readFileSync32, writeSync as writeSync4 } from "fs";
+import { closeSync as closeSync17, constants as constants19, fstatSync as fstatSync17, ftruncateSync as ftruncateSync2, lstatSync as lstatSync29, openSync as openSync17, readFileSync as readFileSync32, writeSync as writeSync4 } from "fs";
 function serializeValue(value) {
   if (controls.test(value))
     throw new EnvAssignmentError("Environment values cannot contain control characters or newlines.");
   if (/^[A-Za-z0-9_./:@+=,-]*$/.test(value))
     return value;
-  const quote3 = ["'", "`", '"'].find((delimiter2) => !value.includes(delimiter2) && (delimiter2 !== '"' || !value.includes("\\")));
+  const quote3 = ["'", "`", '"'].find((delimiter3) => !value.includes(delimiter3) && (delimiter3 !== '"' || !value.includes("\\")));
   const trailingSlashes = value.match(/\\+$/)?.[0].length ?? 0;
   if (!quote3 || trailingSlashes % 2 !== 0 || value.endsWith("\\$")) {
     throw new EnvAssignmentError("Cannot safely encode this environment value; incompatible quote/backslash combinations require manual editing.");
@@ -88960,7 +89236,7 @@ function setEnvAssignment(path, assignment) {
     })();
     if (previous && !previous.isFile())
       throw new EnvAssignmentError("The project .env must be a regular file, not a symlink or special file.");
-    descriptor = openSync17(path, previous ? constants18.O_RDWR | constants18.O_NOFOLLOW | constants18.O_NONBLOCK : constants18.O_WRONLY | constants18.O_CREAT | constants18.O_EXCL | constants18.O_NOFOLLOW, 384);
+    descriptor = openSync17(path, previous ? constants19.O_RDWR | constants19.O_NOFOLLOW | constants19.O_NONBLOCK : constants19.O_WRONLY | constants19.O_CREAT | constants19.O_EXCL | constants19.O_NOFOLLOW, 384);
     const opened = fstatSync17(descriptor);
     if (!opened.isFile() || previous && (opened.ino !== previous.ino || opened.dev !== previous.dev)) {
       throw new EnvAssignmentError("The project .env changed while opening it; retry with a regular file.");
@@ -89054,7 +89330,7 @@ var exports_diagnostic = {};
 __export(exports_diagnostic, {
   registerDiagnostic: () => registerDiagnostic
 });
-import { existsSync as existsSync27, readFileSync as readFileSync33, readdirSync as readdirSync17, statSync as statSync16 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync33, readdirSync as readdirSync17, statSync as statSync17 } from "fs";
 import { join as join49 } from "path";
 import { execSync as execSync2 } from "child_process";
 function registerDiagnostic(parent) {
@@ -89247,7 +89523,7 @@ function handleWhoami(options) {
     let skillCount = 0;
     if (exists)
       try {
-        skillCount = readdirSync17(agentSkillsPath).filter((f) => !f.startsWith(".") && statSync16(join49(agentSkillsPath, f)).isDirectory()).length;
+        skillCount = readdirSync17(agentSkillsPath).filter((f) => !f.startsWith(".") && statSync17(join49(agentSkillsPath, f)).isDirectory()).length;
       } catch {}
     agentConfigs.push({ agent, label: AGENT_LABELS[agent], path: agentSkillsPath, exists, skillCount });
   }
@@ -89505,12 +89781,12 @@ var init_cloud_executions = __esm(() => {
 
 // node_modules/@hasna/secrets/dist/sdk.js
 import { isIP as isIP3 } from "net";
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import { closeSync as closeSync18, fstatSync as fstatSync18, openSync as openSync18, readFileSync as readFileSync34 } from "fs";
 import { O_NOFOLLOW as O_NOFOLLOW3, O_NONBLOCK as O_NONBLOCK3, O_RDONLY as O_RDONLY3 } from "constants";
 import { createRequire as createRequire2 } from "module";
 import { hostname as osHostname2 } from "os";
-import { isAbsolute as isAbsolute25, join as join50 } from "path";
+import { isAbsolute as isAbsolute26, join as join50 } from "path";
 import { createRequire as createRequire22 } from "module";
 function envToken2(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -89534,7 +89810,7 @@ function homeDir2(env3) {
 }
 function absoluteOverride2(env3, key) {
   const value = env3[key]?.trim();
-  return value && isAbsolute25(value) ? value : null;
+  return value && isAbsolute26(value) ? value : null;
 }
 function hasnaHomeDir2(env3) {
   const override = absoluteOverride2(env3, HASNA_HOME_ENV_KEY2);
@@ -89780,7 +90056,7 @@ function isAmbientEnvironment2(env3) {
   return env3 === process.env || env3[AMBIENT_ENVIRONMENT2] === true;
 }
 function defaultKeychainRunner2(argv) {
-  const result2 = spawnSync3(KEYCHAIN_SECURITY_BIN2, [...argv], {
+  const result2 = spawnSync4(KEYCHAIN_SECURITY_BIN2, [...argv], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: KEYCHAIN_SPAWN_TIMEOUT_MS2
@@ -90806,7 +91082,7 @@ var init_sdk = __esm(() => {
 });
 
 // src/lib/execution-secrets.ts
-import { constants as constants19, closeSync as closeSync19, fstatSync as fstatSync19, openSync as openSync19, readSync as readSync15, realpathSync as realpathSync14 } from "fs";
+import { constants as constants20, closeSync as closeSync19, fstatSync as fstatSync19, openSync as openSync19, readSync as readSync15, realpathSync as realpathSync14 } from "fs";
 import { hostname as stationHostname } from "os";
 function selectedSecretBindingsTemplate(scope, names, createClient2 = createSecretsClientFromEnv) {
   let secretsAuthority;
@@ -90850,7 +91126,7 @@ function declaredSecretNames(value) {
 function readSelectedSecretBindings(path) {
   let fd;
   try {
-    fd = openSync19(path, constants19.O_RDONLY | constants19.O_NOFOLLOW | constants19.O_NONBLOCK);
+    fd = openSync19(path, constants20.O_RDONLY | constants20.O_NOFOLLOW | constants20.O_NONBLOCK);
     const stat2 = fstatSync19(fd);
     if (!stat2.isFile() || stat2.size > 65536)
       throw new Error;
@@ -95499,7 +95775,7 @@ var init_runs = __esm(() => {
 
 // src/lib/run-state.ts
 import { createHash as createHash33, randomBytes } from "crypto";
-import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync35, readdirSync as readdirSync18, statSync as statSync17, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync35, readdirSync as readdirSync18, statSync as statSync18, writeFileSync as writeFileSync17 } from "fs";
 import { extname, join as join52, relative as relative8 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now3 = new Date;
@@ -95581,7 +95857,7 @@ function listSkillRuns(targetDir = process.cwd(), limit = 50) {
   const records = [];
   for (const day of readdirSync18(runsRoot).sort().reverse()) {
     const dayDir = join52(runsRoot, day);
-    if (!statSync17(dayDir).isDirectory())
+    if (!statSync18(dayDir).isDirectory())
       continue;
     for (const runId2 of readdirSync18(dayDir).sort().reverse()) {
       const record11 = readRunRecord(join52(dayDir, runId2));
@@ -95630,7 +95906,7 @@ function collectRunArtifacts(context) {
     return [];
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
-    const stat2 = statSync17(path);
+    const stat2 = statSync18(path);
     const bytes = readFileSync35(path);
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
@@ -95655,7 +95931,7 @@ function walkFiles(dir) {
   const files = [];
   for (const entry of readdirSync18(dir)) {
     const full = join52(dir, entry);
-    if (statSync17(full).isDirectory())
+    if (statSync18(full).isDirectory())
       files.push(...walkFiles(full));
     else
       files.push(full);
@@ -99592,11 +99868,11 @@ var require_codegen = __commonJS((exports) => {
       const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`;
       return `${varKind} ${this.name}${rhs};` + _n;
     }
-    optimizeNames(names, constants20) {
+    optimizeNames(names, constants21) {
       if (!names[this.name.str])
         return;
       if (this.rhs)
-        this.rhs = optimizeExpr(this.rhs, names, constants20);
+        this.rhs = optimizeExpr(this.rhs, names, constants21);
       return this;
     }
     get names() {
@@ -99614,10 +99890,10 @@ var require_codegen = __commonJS((exports) => {
     render({ _n }) {
       return `${this.lhs} = ${this.rhs};` + _n;
     }
-    optimizeNames(names, constants20) {
+    optimizeNames(names, constants21) {
       if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
         return;
-      this.rhs = optimizeExpr(this.rhs, names, constants20);
+      this.rhs = optimizeExpr(this.rhs, names, constants21);
       return this;
     }
     get names() {
@@ -99683,8 +99959,8 @@ var require_codegen = __commonJS((exports) => {
     optimizeNodes() {
       return `${this.code}` ? this : undefined;
     }
-    optimizeNames(names, constants20) {
-      this.code = optimizeExpr(this.code, names, constants20);
+    optimizeNames(names, constants21) {
+      this.code = optimizeExpr(this.code, names, constants21);
       return this;
     }
     get names() {
@@ -99714,12 +99990,12 @@ var require_codegen = __commonJS((exports) => {
       }
       return nodes.length > 0 ? this : undefined;
     }
-    optimizeNames(names, constants20) {
+    optimizeNames(names, constants21) {
       const { nodes } = this;
       let i = nodes.length;
       while (i--) {
         const n2 = nodes[i];
-        if (n2.optimizeNames(names, constants20))
+        if (n2.optimizeNames(names, constants21))
           continue;
         subtractNames(names, n2.names);
         nodes.splice(i, 1);
@@ -99776,12 +100052,12 @@ var require_codegen = __commonJS((exports) => {
         return;
       return this;
     }
-    optimizeNames(names, constants20) {
+    optimizeNames(names, constants21) {
       var _a3;
-      this.else = (_a3 = this.else) === null || _a3 === undefined ? undefined : _a3.optimizeNames(names, constants20);
-      if (!(super.optimizeNames(names, constants20) || this.else))
+      this.else = (_a3 = this.else) === null || _a3 === undefined ? undefined : _a3.optimizeNames(names, constants21);
+      if (!(super.optimizeNames(names, constants21) || this.else))
         return;
-      this.condition = optimizeExpr(this.condition, names, constants20);
+      this.condition = optimizeExpr(this.condition, names, constants21);
       return this;
     }
     get names() {
@@ -99806,10 +100082,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.iteration})` + super.render(opts);
     }
-    optimizeNames(names, constants20) {
-      if (!super.optimizeNames(names, constants20))
+    optimizeNames(names, constants21) {
+      if (!super.optimizeNames(names, constants21))
         return;
-      this.iteration = optimizeExpr(this.iteration, names, constants20);
+      this.iteration = optimizeExpr(this.iteration, names, constants21);
       return this;
     }
     get names() {
@@ -99847,10 +100123,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
     }
-    optimizeNames(names, constants20) {
-      if (!super.optimizeNames(names, constants20))
+    optimizeNames(names, constants21) {
+      if (!super.optimizeNames(names, constants21))
         return;
-      this.iterable = optimizeExpr(this.iterable, names, constants20);
+      this.iterable = optimizeExpr(this.iterable, names, constants21);
       return this;
     }
     get names() {
@@ -99895,11 +100171,11 @@ var require_codegen = __commonJS((exports) => {
       (_b = this.finally) === null || _b === undefined || _b.optimizeNodes();
       return this;
     }
-    optimizeNames(names, constants20) {
+    optimizeNames(names, constants21) {
       var _a3, _b;
-      super.optimizeNames(names, constants20);
-      (_a3 = this.catch) === null || _a3 === undefined || _a3.optimizeNames(names, constants20);
-      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants20);
+      super.optimizeNames(names, constants21);
+      (_a3 = this.catch) === null || _a3 === undefined || _a3.optimizeNames(names, constants21);
+      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants21);
       return this;
     }
     get names() {
@@ -100173,7 +100449,7 @@ var require_codegen = __commonJS((exports) => {
   function addExprNames(names, from) {
     return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
   }
-  function optimizeExpr(expr, names, constants20) {
+  function optimizeExpr(expr, names, constants21) {
     if (expr instanceof code_1.Name)
       return replaceName(expr);
     if (!canOptimize(expr))
@@ -100188,14 +100464,14 @@ var require_codegen = __commonJS((exports) => {
       return items;
     }, []));
     function replaceName(n2) {
-      const c = constants20[n2.str];
+      const c = constants21[n2.str];
       if (c === undefined || names[n2.str] !== 1)
         return n2;
       delete names[n2.str];
       return c;
     }
     function canOptimize(e2) {
-      return e2 instanceof code_1._Code && e2._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants20[c.str] !== undefined);
+      return e2 instanceof code_1._Code && e2._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants21[c.str] !== undefined);
     }
   }
   function subtractNames(names, from) {
@@ -107671,7 +107947,7 @@ var init_remote_customer_operations = __esm(() => {
 });
 
 // src/lib/workspace-profile.ts
-import { constants as constants20, closeSync as closeSync20, fstatSync as fstatSync20, lstatSync as lstatSync30, mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync5, openSync as openSync20, readFileSync as readFileSync36, renameSync as renameSync11, rmSync as rmSync8, writeFileSync as writeFileSync18 } from "fs";
+import { constants as constants21, closeSync as closeSync20, fstatSync as fstatSync20, lstatSync as lstatSync30, mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync5, openSync as openSync20, readFileSync as readFileSync36, renameSync as renameSync11, rmSync as rmSync8, writeFileSync as writeFileSync18 } from "fs";
 import { dirname as dirname28, join as join53 } from "path";
 function stat2(path) {
   try {
@@ -107685,7 +107961,7 @@ function stat2(path) {
 function safeText(file2) {
   if (stat2(file2) === null)
     return null;
-  const fd = openSync20(file2, constants20.O_RDONLY | constants20.O_NOFOLLOW | constants20.O_NONBLOCK);
+  const fd = openSync20(file2, constants21.O_RDONLY | constants21.O_NOFOLLOW | constants21.O_NONBLOCK);
   try {
     const s = fstatSync20(fd);
     if (!s.isFile() || s.size > 65536 || ![256, 384].includes(s.mode & 4095) || process.getuid && s.uid !== process.getuid())
@@ -108039,8 +108315,8 @@ var init_recurring_customer = __esm(() => {
 });
 
 // src/lib/recurring-recovery.ts
-import { constants as constants21, closeSync as closeSync21, fsyncSync as fsyncSync7, fstatSync as fstatSync21, lstatSync as lstatSync31, mkdirSync as mkdirSync19, openSync as openSync21, readSync as readSync16, realpathSync as realpathSync16, renameSync as renameSync12, unlinkSync as unlinkSync8, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname29, isAbsolute as isAbsolute26, join as join54, resolve as resolve27 } from "path";
+import { constants as constants22, closeSync as closeSync21, fsyncSync as fsyncSync7, fstatSync as fstatSync21, lstatSync as lstatSync31, mkdirSync as mkdirSync19, openSync as openSync21, readSync as readSync16, realpathSync as realpathSync16, renameSync as renameSync12, unlinkSync as unlinkSync8, writeFileSync as writeFileSync19 } from "fs";
+import { dirname as dirname29, isAbsolute as isAbsolute27, join as join54, resolve as resolve27 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
 
 class RecoveryOwner {
@@ -108048,7 +108324,7 @@ class RecoveryOwner {
   parents = [];
   constructor(directory) {
     this.directory = directory;
-    if (!isAbsolute26(directory) || resolve27(directory) !== directory || realpathSync16(directory) !== directory)
+    if (!isAbsolute27(directory) || resolve27(directory) !== directory || realpathSync16(directory) !== directory)
       invalid6();
     for (let path = directory;; path = dirname29(path)) {
       const stat3 = lstatSync31(path);
@@ -108074,7 +108350,7 @@ class RecoveryOwner {
   }
   read(name) {
     this.assert();
-    const fd = openSync21(join54(this.directory, name), constants21.O_RDONLY | constants21.O_NOFOLLOW | constants21.O_NONBLOCK);
+    const fd = openSync21(join54(this.directory, name), constants22.O_RDONLY | constants22.O_NOFOLLOW | constants22.O_NONBLOCK);
     try {
       const before2 = fstatSync21(fd);
       if (!before2.isFile() || before2.nlink !== 1 || (before2.mode & 4095) !== 384 || before2.size < 1 || before2.size > 8192 || process.getuid && before2.uid !== process.getuid())
@@ -108100,7 +108376,7 @@ class RecoveryOwner {
     this.assert();
     const bytes = canonicalJson2(value, 8192) + `
 `;
-    const fd = openSync21(join54(this.directory, name), constants21.O_WRONLY | constants21.O_CREAT | constants21.O_EXCL | constants21.O_NOFOLLOW, 384);
+    const fd = openSync21(join54(this.directory, name), constants22.O_WRONLY | constants22.O_CREAT | constants22.O_EXCL | constants22.O_NOFOLLOW, 384);
     try {
       writeFileSync19(fd, bytes);
       fsyncSync7(fd);
@@ -108112,7 +108388,7 @@ class RecoveryOwner {
   }
   sync() {
     this.assert();
-    const fd = openSync21(this.directory, constants21.O_RDONLY | constants21.O_NOFOLLOW);
+    const fd = openSync21(this.directory, constants22.O_RDONLY | constants22.O_NOFOLLOW);
     try {
       fsyncSync7(fd);
     } finally {
@@ -108134,7 +108410,7 @@ class RecoveryOwner {
     this.assert();
     let fd;
     try {
-      fd = openSync21(join54(this.directory, "operation.lock"), constants21.O_WRONLY | constants21.O_CREAT | constants21.O_EXCL | constants21.O_NOFOLLOW, 384);
+      fd = openSync21(join54(this.directory, "operation.lock"), constants22.O_WRONLY | constants22.O_CREAT | constants22.O_EXCL | constants22.O_NOFOLLOW, 384);
     } catch {
       throw new RecurringCustomerError("RECURRING_RECOVERY_BUSY", "Recovery is locked. Confirm the original process has stopped before explicitly reconciling the retained lock; no request was retried.");
     }
@@ -108183,7 +108459,7 @@ function base2(customer, organizationId) {
   };
 }
 function create3(directory, intent) {
-  if (!isAbsolute26(directory) || resolve27(directory) !== directory || realpathSync16(dirname29(directory)) !== dirname29(directory))
+  if (!isAbsolute27(directory) || resolve27(directory) !== directory || realpathSync16(dirname29(directory)) !== dirname29(directory))
     invalid6();
   mkdirSync19(directory, { mode: 448 });
   const owner2 = new RecoveryOwner(directory), checked = intentSchema.parse(intent), intentSha256 = canonicalJsonSha256(checked);
@@ -108346,7 +108622,7 @@ var init_recurring_recovery = __esm(() => {
 });
 
 // src/lib/recurring-surface.ts
-import { isAbsolute as isAbsolute27 } from "path";
+import { isAbsolute as isAbsolute28 } from "path";
 function recurringMcpSchema(action) {
   return action === "activate" ? recurringSurfaceSchemas.activate.extend({ code, confirm: exports_external.literal(true) }) : recurringSurfaceSchemas[action];
 }
@@ -108451,7 +108727,7 @@ var init_recurring_surface = __esm(() => {
   uuid12 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
   context = { userId: uuid12.optional(), membershipId: uuid12.optional() };
   page2 = { limit: exports_external.number().int().min(1).max(100).optional(), cursor: exports_external.string().min(1).max(2048).optional() };
-  directory = exports_external.string().max(4096).refine(isAbsolute27, "Use an absolute recovery directory");
+  directory = exports_external.string().max(4096).refine(isAbsolute28, "Use an absolute recovery directory");
   email4 = exports_external.string().trim().toLowerCase().email().max(254);
   code = exports_external.string().regex(/^\d{6}$/);
   recurringSurfaceSchemas = {
@@ -109823,7 +110099,7 @@ var init_run_routing = __esm(() => {
 });
 
 // src/mcp/operation-tools.ts
-import { existsSync as existsSync29, readdirSync as readdirSync19, statSync as statSync18 } from "fs";
+import { existsSync as existsSync29, readdirSync as readdirSync19, statSync as statSync19 } from "fs";
 import { join as join55 } from "path";
 function registerOperationTools(server) {
   server.registerTool("cloud_skill_eligibility", {
@@ -110302,7 +110578,7 @@ function registerOperationTools(server) {
         try {
           skillCount = readdirSync19(agentSkillsPath).filter((f) => {
             const full = join55(agentSkillsPath, f);
-            return !f.startsWith(".") && statSync18(full).isDirectory();
+            return !f.startsWith(".") && statSync19(full).isDirectory();
           }).length;
         } catch {}
       }
@@ -110889,7 +111165,7 @@ import {
   mkdirSync as mkdirSync22,
   readFileSync as readFileSync38,
   readdirSync as readdirSync20,
-  statSync as statSync19,
+  statSync as statSync20,
   writeFileSync as writeFileSync21
 } from "fs";
 import { dirname as dirname31, join as join58, normalize as normalize5, relative as relative9, sep as sep11 } from "path";
@@ -111015,7 +111291,7 @@ function walkFiles2(dir) {
   const files = [];
   for (const entry of readdirSync20(dir)) {
     const full = join58(dir, entry);
-    const stats = statSync19(full);
+    const stats = statSync20(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));
     else
@@ -111252,11 +111528,11 @@ var init_private_publication_customer = __esm(() => {
 });
 
 // src/lib/private-publication-recovery.ts
-import { constants as constants22, closeSync as closeSync23, fsyncSync as fsyncSync8, fstatSync as fstatSync23, lstatSync as lstatSync32, mkdirSync as mkdirSync23, openSync as openSync23, readSync as readSync17, realpathSync as realpathSync17, renameSync as renameSync13, unlinkSync as unlinkSync9, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname32, isAbsolute as isAbsolute28, join as join59, resolve as resolve28 } from "path";
+import { constants as constants23, closeSync as closeSync23, fsyncSync as fsyncSync8, fstatSync as fstatSync23, lstatSync as lstatSync32, mkdirSync as mkdirSync23, openSync as openSync23, readSync as readSync17, realpathSync as realpathSync17, renameSync as renameSync13, unlinkSync as unlinkSync9, writeFileSync as writeFileSync22 } from "fs";
+import { dirname as dirname32, isAbsolute as isAbsolute29, join as join59, resolve as resolve28 } from "path";
 import { randomUUID as randomUUID9 } from "crypto";
 function safeDirectory(directory2) {
-  if (!isAbsolute28(directory2) || directory2 !== resolve28(directory2) || realpathSync17(directory2) !== directory2)
+  if (!isAbsolute29(directory2) || directory2 !== resolve28(directory2) || realpathSync17(directory2) !== directory2)
     return fail5();
   for (let path = directory2;; path = dirname32(path)) {
     const stat3 = lstatSync32(path);
@@ -111277,7 +111553,7 @@ function unchangedDirectory(directory2, identity6) {
 }
 function readOwned(directory2, name, max2) {
   const identity6 = safeDirectory(directory2), file2 = join59(directory2, name);
-  const fd = openSync23(file2, constants22.O_RDONLY | constants22.O_NOFOLLOW);
+  const fd = openSync23(file2, constants23.O_RDONLY | constants23.O_NOFOLLOW);
   try {
     const stat3 = fstatSync23(fd);
     if (!stat3.isFile() || stat3.nlink !== 1 || stat3.size > max2 || stat3.size < 1 || (stat3.mode & 63) !== 0 || process.getuid && stat3.uid !== process.getuid())
@@ -111300,7 +111576,7 @@ function readOwned(directory2, name, max2) {
   }
 }
 function writeOwned(directory2, name, bytes) {
-  const fd = openSync23(join59(directory2, name), constants22.O_WRONLY | constants22.O_CREAT | constants22.O_EXCL | constants22.O_NOFOLLOW, 384);
+  const fd = openSync23(join59(directory2, name), constants23.O_WRONLY | constants23.O_CREAT | constants23.O_EXCL | constants23.O_NOFOLLOW, 384);
   try {
     writeFileSync22(fd, bytes);
     fsyncSync8(fd);
@@ -111314,7 +111590,7 @@ function save2(directory2, value) {
 `);
   unchangedDirectory(directory2, identity6);
   renameSync13(join59(directory2, temporary), join59(directory2, "receipt.json"));
-  const fd = openSync23(directory2, constants22.O_RDONLY | constants22.O_NOFOLLOW);
+  const fd = openSync23(directory2, constants23.O_RDONLY | constants23.O_NOFOLLOW);
   try {
     fsyncSync8(fd);
   } finally {
@@ -111329,7 +111605,7 @@ async function locked(directory2, action) {
   const identity6 = safeDirectory(directory2), file2 = join59(directory2, "operation.lock");
   let fd;
   try {
-    fd = openSync23(file2, constants22.O_WRONLY | constants22.O_CREAT | constants22.O_EXCL | constants22.O_NOFOLLOW, 384);
+    fd = openSync23(file2, constants23.O_WRONLY | constants23.O_CREAT | constants23.O_EXCL | constants23.O_NOFOLLOW, 384);
   } catch {
     throw new PrivatePublicationError("PUBLICATION_RECOVERY_BUSY", "Another operation holds this recovery directory. If it crashed, confirm that process has stopped before explicitly removing operation.lock and resuming.");
   }
@@ -111394,11 +111670,11 @@ async function preparePrivatePublication(client2, sourceDirectory, recoveryDirec
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute28(recoveryDirectory) || resolve28(recoveryDirectory) !== recoveryDirectory || realpathSync17(dirname32(recoveryDirectory)) !== dirname32(recoveryDirectory))
+  if (!isAbsolute29(recoveryDirectory) || resolve28(recoveryDirectory) !== recoveryDirectory || realpathSync17(dirname32(recoveryDirectory)) !== dirname32(recoveryDirectory))
     return fail5();
   mkdirSync23(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync23(dirname32(recoveryDirectory), constants22.O_RDONLY | constants22.O_NOFOLLOW);
+  const parent = openSync23(dirname32(recoveryDirectory), constants23.O_RDONLY | constants23.O_NOFOLLOW);
   try {
     fsyncSync8(parent);
   } finally {
@@ -111495,10 +111771,10 @@ var init_private_publication_recovery = __esm(() => {
 });
 
 // src/mcp/private-publication-tools.ts
-import { isAbsolute as isAbsolute29 } from "path";
+import { isAbsolute as isAbsolute30 } from "path";
 function registerPrivatePublicationTools(server) {
   const uuid9 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
-  const directory2 = exports_external.string().max(4096).refine(isAbsolute29, "Use an absolute local directory");
+  const directory2 = exports_external.string().max(4096).refine(isAbsolute30, "Use an absolute local directory");
   const verification2 = { email: exports_external.string().email().max(254), code: exports_external.string().regex(/^\d{6}$/), userId: uuid9, membershipId: uuid9, recoveryDirectory: directory2 };
   const description = "Manage a private source publication using fresh workspace-bound verification and a host-local recovery directory. Publishing requires explicit UUID current-version comparison and upload consent. Resume reuses immutable saved bytes and intent; an uncertain PUT is finalized for server verification, never uploaded twice. Sessions and signed URLs are not returned or persisted. Private execution is unavailable. Host request history may contain the supplied verification code.";
   const handler = (action) => async (value) => {
@@ -112290,44 +112566,50 @@ import {
   renameSync as renameSync14,
   writeFileSync as writeFileSync24
 } from "fs";
-import { basename as basename17, delimiter as delimiter2, dirname as dirname34, isAbsolute as isAbsolute30, join as join61, relative as relative10, resolve as resolve29, sep as sep12 } from "path";
+import { basename as basename17, delimiter as delimiter3, dirname as dirname34, isAbsolute as isAbsolute31, join as join61, relative as relative10, resolve as resolve29, sep as sep12 } from "path";
 function oldLauncherState(item) {
   if (item.oldShape === "pinned")
-    return { shape: "pinned", runtime: item.oldRuntime, cwd: item.oldCwd, target: item.oldTarget, sha256: item.oldSha256 };
+    return { shape: "pinned", runtime: item.oldRuntime, cwd: item.oldCwd, target: item.oldTarget, sha256: item.oldSha256, format: item.oldFormat, profile: item.oldProfile };
   return { shape: "symlink", linkTarget: item.oldLinkTarget, target: item.oldTarget };
 }
 function newLauncherState(item) {
   if (item.newShape === "pinned")
-    return { shape: "pinned", runtime: item.newRuntime, cwd: item.newCwd, target: item.newTarget, sha256: item.newSha256 };
+    return { shape: "pinned", runtime: item.newRuntime, cwd: item.newCwd, target: item.newTarget, sha256: item.newSha256, format: item.newFormat, profile: item.newProfile };
   return { shape: "symlink", linkTarget: item.newTarget, target: item.newTarget };
 }
-function assertLauncherRecordShapes(item) {
+function assertLauncherRecordShapes(item, expectedProfile) {
   const hex3 = /^[a-f0-9]{64}$/;
   for (const side of ["old", "new"]) {
     const shape = item[`${side}Shape`], runtime = item[`${side}Runtime`], cwd2 = item[`${side}Cwd`], sha6 = item[`${side}Sha256`];
+    const format = item[`${side}Format`], profile = item[`${side}Profile`];
     if (shape === undefined) {
-      if (runtime !== undefined || cwd2 !== undefined || sha6 !== undefined)
+      if (runtime !== undefined || cwd2 !== undefined || sha6 !== undefined || format !== undefined || profile !== undefined)
         throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
       continue;
     }
     if (shape === "symlink") {
-      if (runtime !== undefined || cwd2 !== undefined || sha6 !== undefined)
+      if (runtime !== undefined || cwd2 !== undefined || sha6 !== undefined || format !== undefined || profile !== undefined)
         throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
       continue;
     }
-    if (shape !== "pinned" || typeof runtime !== "string" || !isAbsolute30(runtime) || typeof cwd2 !== "string" || !isAbsolute30(cwd2) || typeof sha6 !== "string" || !hex3.test(sha6)) {
+    if (shape !== "pinned" || typeof runtime !== "string" || !isAbsolute31(runtime) || typeof cwd2 !== "string" || !isAbsolute31(cwd2) || typeof sha6 !== "string" || !hex3.test(sha6)) {
       throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
     }
     const target = side === "old" ? item.oldTarget : item.newTarget;
     if (side === "old" && item.oldLinkTarget !== item.oldTarget)
       throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
-    if (pinnedLauncherState(runtime, cwd2, target).sha256 !== sha6)
+    if (format === "v2" && profile !== expectedProfile)
       throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
+    try {
+      pinnedLauncherText({ runtime, cwd: cwd2, target, sha256: sha6, format, profile });
+    } catch {
+      throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
+    }
   }
 }
-function pinnedRecordFields(runtime, cwd2, target) {
-  const state = pinnedLauncherState(runtime, cwd2, target);
-  return { newShape: "pinned", newRuntime: state.runtime, newCwd: state.cwd, newSha256: state.sha256 };
+function pinnedRecordFields(runtime, cwd2, target, profile) {
+  const state = pinnedLauncherState(runtime, cwd2, target, { format: "v2", profile });
+  return { newShape: "pinned", newRuntime: state.runtime, newCwd: state.cwd, newSha256: state.sha256, newFormat: state.format, newProfile: state.profile };
 }
 function object10(value, code2) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -112339,7 +112621,7 @@ function hash5(bytes) {
 }
 function isWithin(parent, child2) {
   const rel = relative10(parent, child2);
-  return rel === "" || !rel.startsWith(`..${sep12}`) && rel !== ".." && !isAbsolute30(rel);
+  return rel === "" || !rel.startsWith(`..${sep12}`) && rel !== ".." && !isAbsolute31(rel);
 }
 function entryExists(path) {
   try {
@@ -112388,7 +112670,7 @@ function packageBins(pkg) {
   const entries = typeof raw === "string" ? [[PACKAGE_NAME.slice(PACKAGE_NAME.lastIndexOf("/") + 1), raw]] : raw && typeof raw === "object" && !Array.isArray(raw) ? Object.entries(raw) : [];
   const output2 = {};
   for (const [name, value] of entries) {
-    if (!/^[a-zA-Z0-9._-]+$/.test(name) || typeof value !== "string" || !value || isAbsolute30(value)) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(name) || typeof value !== "string" || !value || isAbsolute31(value)) {
       throw new Error("PACKAGE_BIN_INVALID");
     }
     const normalized = value.replaceAll("\\", "/");
@@ -112451,7 +112733,7 @@ function resolveRuntimeLayout(homeInput, pathInput) {
   }
   const launchers = [];
   const seenDirectories = new Set;
-  for (const rawDir of pathInput.split(delimiter2).filter(Boolean)) {
+  for (const rawDir of pathInput.split(delimiter3).filter(Boolean)) {
     const dir = resolve29(rawDir);
     if (seenDirectories.has(dir))
       continue;
@@ -112481,7 +112763,7 @@ function resolveRuntimeLayout(homeInput, pathInput) {
           throw new Error("LAUNCHER_SYMLINK_CHAIN_UNSUPPORTED");
         launchers.push({ path, oldTarget: actual, oldLinkTarget: launcher.linkTarget, newTarget, backupPath, oldShape: "symlink" });
       } else {
-        launchers.push({ path, oldTarget: actual, oldLinkTarget: actual, newTarget, backupPath, oldShape: "pinned", oldRuntime: launcher.runtime, oldCwd: launcher.cwd, oldSha256: launcher.sha256 });
+        launchers.push({ path, oldTarget: actual, oldLinkTarget: actual, newTarget, backupPath, oldShape: "pinned", oldRuntime: launcher.runtime, oldCwd: launcher.cwd, oldSha256: launcher.sha256, oldFormat: launcher.format, oldProfile: launcher.profile });
       }
     }
   }
@@ -113110,14 +113392,14 @@ function adoptCopyfileAliases(options = {}) {
         const actual = launcher.target;
         const oldLinkTarget = launcher.kind === "symlink" ? launcher.linkTarget : actual;
         const newTarget = join61(layout.currentPackageRoot, target);
-        if (actual === newTarget && launcher.kind === "pinned")
+        if (actual === newTarget && launcher.kind === "pinned" && launcher.format === "v2" && launcher.profile === launcherProfileForBin(name, target))
           continue;
         const chain = inspectAliasPackageChain(home, path, oldLinkTarget, actual, target);
         const source = validateAliasSource(home, name, actual);
         const backupPath = `${path}.skills-alias-prev-${id2}`;
         if (entryExists(backupPath))
           throw new Error("ALIAS_BACKUP_COLLISION");
-        const oldFields = launcher.kind === "symlink" ? { oldShape: "symlink" } : { oldShape: "pinned", oldRuntime: launcher.runtime, oldCwd: launcher.cwd, oldSha256: launcher.sha256 };
+        const oldFields = launcher.kind === "symlink" ? { oldShape: "symlink" } : { oldShape: "pinned", oldRuntime: launcher.runtime, oldCwd: launcher.cwd, oldSha256: launcher.sha256, oldFormat: launcher.format, oldProfile: launcher.profile };
         aliases.push({
           path,
           oldTarget: actual,
@@ -113127,7 +113409,7 @@ function adoptCopyfileAliases(options = {}) {
           newTarget,
           backupPath,
           ...oldFields,
-          ...pinnedRecordFields(launcherRuntime, currentRuntime, newTarget),
+          ...pinnedRecordFields(launcherRuntime, currentRuntime, newTarget, launcherProfileForBin(name, target)),
           ...chain ? { chain } : {}
         });
       }
@@ -113247,7 +113529,7 @@ function rollbackCopyfileAliases(receiptId, options = {}) {
         throw new Error("ALIAS_RECEIPT_LAUNCHER_INVALID");
       }
       inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, target, item.chain, true);
-      assertLauncherRecordShapes(item);
+      assertLauncherRecordShapes(item, launcherProfileForBin(name, target));
       seen.add(item.path);
       assertOwnedSafePath(dirname34(item.path), home, true);
       const source = validateAliasSource(home, name, item.oldTarget);
@@ -113319,7 +113601,7 @@ async function updateCopyfileRuntime(version2, options = {}) {
       throw new Error("REVIEWED_LOCK_INPUT_PAIR_REQUIRED");
     if (!policy)
       throw new Error("REVIEWED_LOCK_RELEASE_AGE_REQUIRED");
-    if (!isAbsolute30(options.reviewedLock))
+    if (!isAbsolute31(options.reviewedLock))
       throw new Error("REVIEWED_LOCK_ABSOLUTE_PATH_REQUIRED");
     assertNoSymlinkAncestors(dirname34(options.reviewedLock));
     const stat3 = lstatSync33(options.reviewedLock);
@@ -113352,7 +113634,7 @@ async function updateCopyfileRuntime(version2, options = {}) {
   const launcherRuntime = pinnedLauncherRuntime();
   const launchers = layout.launchers.map((item) => {
     const newTarget = join61(finalPath, "node_modules", "@hasna", "skills", layout.bin[basename17(item.path)]);
-    return { ...item, newTarget, ...pinnedRecordFields(launcherRuntime, finalPath, newTarget) };
+    return { ...item, newTarget, ...pinnedRecordFields(launcherRuntime, finalPath, newTarget, launcherProfileForBin(basename17(item.path), layout.bin[basename17(item.path)])) };
   });
   const releaseLock = acquireRuntimeLock(layout.runtimeRoot);
   let switched = [];
@@ -113566,10 +113848,10 @@ function rollbackCopyfileRuntime(receiptId, options = {}) {
     const seen = new Set;
     for (const item of receipt.launchers) {
       const bin = oldBins[basename17(item.path)];
-      if (!bin || !isAbsolute30(item.path) || seen.has(item.path) || item.oldTarget !== join61(receipt.currentPackageRoot, bin) || item.newTarget !== join61(receipt.targetPackageRoot, bin) || !/^.+\.skills-prev-[0-9a-f-]{36}$/.test(item.backupPath) || !item.backupPath.startsWith(`${item.path}.skills-prev-`) || typeof item.oldLinkTarget !== "string" || resolve29(dirname34(item.path), item.oldLinkTarget) !== item.oldTarget)
+      if (!bin || !isAbsolute31(item.path) || seen.has(item.path) || item.oldTarget !== join61(receipt.currentPackageRoot, bin) || item.newTarget !== join61(receipt.targetPackageRoot, bin) || !/^.+\.skills-prev-[0-9a-f-]{36}$/.test(item.backupPath) || !item.backupPath.startsWith(`${item.path}.skills-prev-`) || typeof item.oldLinkTarget !== "string" || resolve29(dirname34(item.path), item.oldLinkTarget) !== item.oldTarget)
         throw new Error("RECEIPT_LAUNCHER_BINDING_INVALID");
       assertNoSymlinkAncestors(dirname34(item.path));
-      assertLauncherRecordShapes(item);
+      assertLauncherRecordShapes(item, launcherProfileForBin(basename17(item.path), bin));
       seen.add(item.path);
       const oldState = oldLauncherState(item), newState = newLauncherState(item);
       let activeTarget;
@@ -113635,7 +113917,7 @@ __export(exports_runtime, {
 });
 import { createHash as createHash37, randomUUID as randomUUID11 } from "crypto";
 import { lstatSync as lstatSync34, mkdirSync as mkdirSync26, readFileSync as readFileSync41, writeFileSync as writeFileSync25 } from "fs";
-import { basename as basename18, isAbsolute as isAbsolute31, join as join62 } from "path";
+import { basename as basename18, isAbsolute as isAbsolute32, join as join62 } from "path";
 import { createInterface } from "readline";
 function registerRuntime(parent) {
   parent.command("run").argument("<skill>", "Skill name").argument("[args...]", "Arguments to pass to the skill; use -- to end Skills options").allowUnknownOption(true).passThroughOptions(true).option("--json", "Output result as JSON", false).option("--remote", "Run on the configured server, using its catalog and quote", false).option("--target <target>", "Execution target: local or cloud").option("--secret-bindings <path>", "Reviewed, exact-selection local execution vault bindings (JSON file)").option("--secret-bindings-template", "Print a scoped bindings template without resolving secrets or running the skill", false).option("--input <json>", "Structured cloud execution input").option("--skill-version <version>", "Exact selected skill version").option("--selection-profile <id>", "Selected Skills profile").option("--session <id>", "Pinned Skills session").option("--cached", "Use the explicit verified selected cache", false).option("--yes", "Approve the server's quoted credit cost for this run", false).option("--idempotency-key <key>", "Reuse this key when retrying the same remote submission").option("--file <path>", "Attach a local input file to a remote run (repeatable)", (value, prior) => [...prior, value], []).option("--wait", "Poll remote runs until a terminal status", false).option("--poll-interval-ms <ms>", "Remote polling interval in milliseconds", "1000").option("--poll-timeout-ms <ms>", "Maximum time to wait for a remote run", "300000").description("Run a skill directly").action(async (name, args2, options, command) => {
@@ -113834,7 +114116,7 @@ Updating ${name}...
 async function readUpdatedVersion(bunExecutable) {
   const output2 = await readUpdateCommand([bunExecutable, "pm", "bin", "-g"]);
   const globalBin = output2.replace(/\r?\n$/, "");
-  if (!globalBin || !isAbsolute31(globalBin) || /[\r\n\0]/.test(globalBin))
+  if (!globalBin || !isAbsolute32(globalBin) || /[\r\n\0]/.test(globalBin))
     throw new Error("Update bin discovery failed");
   const installed = Bun.which("skills", { PATH: globalBin, cwd: globalBin });
   const selected = Bun.which("skills");
@@ -114889,10 +115171,10 @@ var exports_recurring = {};
 __export(exports_recurring, {
   registerRecurringCommands: () => registerRecurringCommands
 });
-import { constants as constants23, closeSync as closeSync25, fstatSync as fstatSync25, lstatSync as lstatSync35, openSync as openSync25, readSync as readSync18 } from "fs";
+import { constants as constants24, closeSync as closeSync25, fstatSync as fstatSync25, lstatSync as lstatSync35, openSync as openSync25, readSync as readSync18 } from "fs";
 import { createInterface as createInterface2 } from "readline";
 function readRequest(path) {
-  const fd = openSync25(path, constants23.O_RDONLY | constants23.O_NOFOLLOW | constants23.O_NONBLOCK);
+  const fd = openSync25(path, constants24.O_RDONLY | constants24.O_NOFOLLOW | constants24.O_NONBLOCK);
   try {
     const before2 = fstatSync25(fd);
     if (!before2.isFile() || before2.size > 1048576 || before2.size < 1)
@@ -115189,7 +115471,7 @@ var init_completion = __esm(() => {
 });
 
 // src/lib/portable-snapshot-filter.ts
-import { readdirSync as readdirSync22, statSync as statSync20 } from "fs";
+import { readdirSync as readdirSync22, statSync as statSync21 } from "fs";
 import { homedir as homedir11 } from "os";
 import { join as join63, sep as sep13 } from "path";
 function isExcludedSkillFileName(fileName) {
@@ -115257,7 +115539,7 @@ function walkEntries(absoluteRoot) {
 }
 function isRegularFile(filePath) {
   try {
-    return statSync20(filePath).isFile();
+    return statSync21(filePath).isFile();
   } catch {
     return false;
   }
@@ -115343,10 +115625,10 @@ import {
   copyFileSync as copyFileSync2,
   mkdirSync as mkdirSync27,
   readFileSync as readFileSync42,
-  statSync as statSync21,
+  statSync as statSync22,
   writeFileSync as writeFileSync26
 } from "fs";
-import { dirname as dirname36, isAbsolute as isAbsolute32, relative as relative11, resolve as resolve30, sep as sep14 } from "path";
+import { dirname as dirname36, isAbsolute as isAbsolute33, relative as relative11, resolve as resolve30, sep as sep14 } from "path";
 function validateStationId(stationId) {
   if (!/^[a-z0-9-]+$/.test(stationId)) {
     throw new StationSnapshotError("INVALID_STATION", `station id must be a slug, got: ${stationId}`);
@@ -115383,7 +115665,7 @@ function scanHome(definition, homesRoot) {
       skipped.push({ relativePath: entry.relativePath, reason: "not-regular-file" });
       continue;
     }
-    const info = statSync21(entry.fullPath);
+    const info = statSync22(entry.fullPath);
     portable.push({
       relativePath: entry.relativePath,
       fullPath: entry.fullPath,
@@ -115452,7 +115734,7 @@ function writeStationSnapshot(options) {
   for (const plan of plans) {
     const destination = resolve30(repoRoot, plan.destination);
     const destinationRelative = relative11(repoRoot, destination);
-    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep14) || isAbsolute32(destinationRelative)) {
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep14) || isAbsolute33(destinationRelative)) {
       throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
     }
     let existingDigest = null;
@@ -115924,6 +116206,50 @@ var init_create_sync_config = __esm(() => {
   init_station_snapshot();
 });
 
+// src/lib/agent-install-selection.ts
+import { lstatSync as lstatSync36 } from "fs";
+import { dirname as dirname37, join as join65, resolve as resolve31 } from "path";
+import { homedir as homedir12 } from "os";
+function detectedIntegrationAgents(options = {}) {
+  const home = options.home ?? homedir12(), env3 = options.env ?? process.env;
+  const policy = readManagedSkillPolicySnapshot(options.dataDir ?? getDataDirReadOnly())?.value;
+  const bridge = policy?.bridge;
+  if (bridge !== undefined && (!bridge || typeof bridge !== "object" || Array.isArray(bridge)))
+    throw new Error("Invalid existing Skills bridge policy");
+  const configured = bridge === undefined ? [] : bridge.agents;
+  if (!Array.isArray(configured) || configured.some((agent) => !INTEGRATION_AGENTS.includes(agent)))
+    throw new Error("Invalid existing bridge agent inventory");
+  const present = (path) => {
+    try {
+      return lstatSync36(path, { throwIfNoEntry: false }) !== undefined;
+    } catch {
+      throw new Error("Agent presence cannot be inspected; review native configuration before hook installation");
+    }
+  };
+  const selected = INTEGRATION_AGENTS.filter((agent) => {
+    if (configured.includes(agent) || Bun.which(agent, { PATH: env3.PATH ?? "" }))
+      return true;
+    if (agent === "sumi") {
+      const xdg = env3.XDG_CONFIG_HOME;
+      const xdgSumi = xdg?.trim() ? resolve31(options.cwd ?? process.cwd(), xdg === "~" ? home : xdg.startsWith("~/") || xdg.startsWith("~\\") ? resolve31(home, xdg.slice(2)) : xdg, "sumi") : null;
+      return ["SUMI_HOME", "SUMI_CONFIG_DIR", "SUMI_CONFIG", "SUMI_CONFIG_CONTENT"].some((key) => env3[key] !== undefined) || Bun.which("sumi-paths", { PATH: env3.PATH ?? "" }) !== null || NATIVE_SKILL_ROOTS.some(([provider, root2]) => provider === "sumi" && present(join65(home, dirname37(root2)))) || present(join65(home, ".config", "sumi")) || xdgSumi !== null && present(xdgSumi);
+    }
+    if (agent === "hermes" && env3.HERMES_HOME !== undefined)
+      return true;
+    const adapter = AGENT_ADAPTERS[agent];
+    return present(join65(home, dirname37(adapter.config))) || NATIVE_SKILL_ROOTS.some(([provider, root2]) => provider === agent && dirname37(root2) === `.${agent}` && present(join65(home, dirname37(root2))));
+  });
+  if (!selected.length)
+    throw new Error(`No configured or detected agents; select --agent <agent> explicitly (${INTEGRATION_AGENTS.join(", ")}).`);
+  return selected;
+}
+var init_agent_install_selection = __esm(() => {
+  init_agent_adapters();
+  init_native_discovery_roots();
+  init_managed_policy();
+  init_config();
+});
+
 // src/lib/codex-native-config.ts
 import { isDeepStrictEqual as isDeepStrictEqual14 } from "util";
 function isRecord8(value) {
@@ -115971,11 +116297,11 @@ var NUMBER_TAG = "$serde_json::private::Number";
 var init_codex_native_config = () => {};
 
 // src/lib/codex-hook-trust-identity.ts
-import { lstatSync as lstatSync36, realpathSync as realpathSync19 } from "fs";
-import { dirname as dirname37, isAbsolute as isAbsolute33, join as join65, resolve as resolve31 } from "path";
+import { lstatSync as lstatSync37, realpathSync as realpathSync19 } from "fs";
+import { dirname as dirname38, isAbsolute as isAbsolute34, join as join66, resolve as resolve32 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual15 } from "util";
 function commandPhysical(command) {
-  need6(typeof command === "string" && isAbsolute33(command) && !command.includes("\x00") && resolve31(command) === command, COMMAND_NOT_CANONICAL);
+  need6(typeof command === "string" && isAbsolute34(command) && !command.includes("\x00") && resolve32(command) === command, COMMAND_NOT_CANONICAL);
   const physical = realpathSync19(command);
   let spelled;
   try {
@@ -115986,7 +116312,7 @@ function commandPhysical(command) {
   safeParents(spelled);
   let direct = false;
   try {
-    const leaf = lstatSync36(spelled);
+    const leaf = lstatSync37(spelled);
     direct = leaf.isSymbolicLink() ? trustedAncestorOwner(leaf.uid) && directAliasTarget(spelled) === physical : spelled === physical;
   } catch {}
   need6(direct, COMMAND_ALIAS_UNSAFE);
@@ -115998,7 +116324,7 @@ function assertPinnedRuntime(runtime) {
   } catch {
     need6(false, "SKILLS_LAUNCHER_UNVERIFIED");
   }
-  need6(resolve31(runtime) === runtime, "SKILLS_LAUNCHER_UNVERIFIED");
+  need6(resolve32(runtime) === runtime, "SKILLS_LAUNCHER_UNVERIFIED");
   safeParents(runtime);
 }
 function skillsCommandTarget(command) {
@@ -116030,12 +116356,12 @@ function targetUnchanged(command, target) {
     assertPinnedRuntime(target.runtime);
 }
 function inspectRecordedSkillsCli(command, expected) {
-  need6(isAbsolute33(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
+  need6(isAbsolute34(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
   const target = skillsCommandTarget(command), resolved = target.entry;
   const cli = snapshot(resolved, false, { readOnlyPackage: true });
-  const manifest = snapshot(join65(dirname37(dirname37(resolved)), "package.json"), false, { readOnlyPackage: true });
+  const manifest = snapshot(join66(dirname38(dirname38(resolved)), "package.json"), false, { readOnlyPackage: true });
   const pkg = JSON.parse(manifest.text);
-  need6(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join65(dirname37(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
+  need6(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join66(dirname38(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
   need6((cli.stat.mode & 0o100n) !== 0n, "SKILLS_COMMAND_NOT_EXECUTABLE");
   const receipt = { path: resolved, version: pkg.version, sha256: cli.sha256, manifestSha256: manifest.sha256 };
   need6(isDeepStrictEqual15(receipt, expected), "RECONCILE_SKILLS_BINDING_CHANGED");
@@ -116049,16 +116375,16 @@ function bindSkillsCli(command, reviewed) {
   const normal = Bun.which("skills", { PATH: process.env.PATH });
   need6(normal, "SKILLS_COMMAND_UNAVAILABLE");
   const normalTarget = skillsCommandTarget(normal), resolved = normalTarget.entry;
-  const bound = isAbsolute33(command) ? command : command === "skills" ? normal : undefined;
+  const bound = isAbsolute34(command) ? command : command === "skills" ? normal : undefined;
   need6(bound, "SKILLS_COMMAND_MISMATCH");
   const boundTarget = skillsCommandTarget(bound);
   need6(boundTarget.entry === resolved, "SKILLS_COMMAND_MISMATCH");
   const entrypoint = reviewed?.path ?? process.argv[1];
   need6(entrypoint && realpathSync19(entrypoint) === resolved, "SKILLS_ENTRYPOINT_MISMATCH");
   const cli = snapshot(resolved, false, { readOnlyPackage: true });
-  const manifest = snapshot(join65(dirname37(dirname37(resolved)), "package.json"), false, { readOnlyPackage: true });
+  const manifest = snapshot(join66(dirname38(dirname38(resolved)), "package.json"), false, { readOnlyPackage: true });
   const pkg = JSON.parse(manifest.text);
-  need6(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join65(dirname37(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
+  need6(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join66(dirname38(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
   if (reviewed)
     need6(/^[a-f0-9]{64}$/.test(reviewed.sha256) && reviewed.sha256 === cli.sha256 && reviewed.version === pkg.version, "SKILLS_RELEASE_MISMATCH");
   need6((cli.stat.mode & 0o100n) !== 0n, "SKILLS_COMMAND_NOT_EXECUTABLE");
@@ -116077,7 +116403,7 @@ function captureSkillsCliProducerIdentity(command) {
   const bound = bindSkillsCli(command);
   const target = skillsCommandTarget(command);
   const cli = snapshot(target.entry, false, { readOnlyPackage: true });
-  const manifest = snapshot(join65(dirname37(dirname37(target.entry)), "package.json"), false, { readOnlyPackage: true });
+  const manifest = snapshot(join66(dirname38(dirname38(target.entry)), "package.json"), false, { readOnlyPackage: true });
   const pkg = JSON.parse(manifest.text);
   need6(pkg.name === "@hasna/skills" && pkg.version === bound.receipt.version && target.entry === bound.receipt.path, "SKILLS_PACKAGE_MISMATCH");
   const launcher = target.launcher ?? cli;
@@ -116131,20 +116457,20 @@ var init_codex_hook_policy_recovery = __esm(() => {
 });
 
 // src/lib/agent-codex-trust.ts
-import { lstatSync as lstatSync37, mkdirSync as mkdirSync28, readdirSync as readdirSync23, readFileSync as readFileSync43, realpathSync as realpathSync20, statSync as statSync22 } from "fs";
+import { lstatSync as lstatSync38, mkdirSync as mkdirSync28, readdirSync as readdirSync23, readFileSync as readFileSync43, realpathSync as realpathSync20, statSync as statSync23 } from "fs";
 import { createHash as createHash39, randomUUID as randomUUID12 } from "crypto";
 import { execFileSync as execFileSync2 } from "child_process";
-import { dirname as dirname38, isAbsolute as isAbsolute34, join as join66, resolve as resolve32 } from "path";
-import { homedir as homedir12 } from "os";
+import { dirname as dirname39, isAbsolute as isAbsolute35, join as join67, resolve as resolve33 } from "path";
+import { homedir as homedir13 } from "os";
 import { isDeepStrictEqual as isDeepStrictEqual17 } from "util";
 function verifyReleaseArtifact(proof, skillsCli) {
-  need6(isAbsolute34(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
+  need6(isAbsolute35(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
   const tarPath = realpathSync20(proof.packageTarPath);
-  need6(statSync22(tarPath).isFile(), "RECONCILE_RELEASE_PROVENANCE_PATH");
+  need6(statSync23(tarPath).isFile(), "RECONCILE_RELEASE_PROVENANCE_PATH");
   const tarBytes = readFileSync43(tarPath);
   need6(tarBytes.byteLength === proof.packageTarBytes && createHash39("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
-  const packageRoot = dirname38(dirname38(realpathSync20(skillsCli.receipt.path)));
-  const manifest = readFileSync43(join66(packageRoot, "package.json"));
+  const packageRoot = dirname39(dirname39(realpathSync20(skillsCli.receipt.path)));
+  const manifest = readFileSync43(join67(packageRoot, "package.json"));
   need6(createHash39("sha256").update(manifest).digest("hex") === skillsCli.receipt.manifestSha256 && skillsCli.receipt.manifestSha256 === proof.manifestSha256, "RECONCILE_RELEASE_MANIFEST_CHANGED");
   need6(createHash39("sha256").update(readFileSync43(skillsCli.receipt.path)).digest("hex") === proof.executableSha256 && skillsCli.receipt.sha256 === proof.executableSha256, "RECONCILE_RELEASE_EXECUTABLE_CHANGED");
   const members2 = [["package/package.json", manifest], ["package/bin/index.js", readFileSync43(skillsCli.receipt.path)]];
@@ -116161,26 +116487,26 @@ function verifyReleaseArtifact(proof, skillsCli) {
 async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc) {
   let rpc;
   try {
-    const home = resolve32(options.home ?? homedir12()), dataDir3 = resolve32(options.dataDir ?? getDataDirReadOnly());
-    const parent = resolve32(join66(dataDir3, "native-hook-trust")), journal = resolve32(options.journal);
+    const home = resolve33(options.home ?? homedir13()), dataDir3 = resolve33(options.dataDir ?? getDataDirReadOnly());
+    const parent = resolve33(join67(dataDir3, "native-hook-trust")), journal = resolve33(options.journal);
     need6(journal.startsWith(parent + "/") && /^[a-f0-9-]{36}$/.test(journal.slice(parent.length + 1)), "RECONCILE_JOURNAL_PATH");
-    const dir = lstatSync37(journal, { throwIfNoEntry: false });
+    const dir = lstatSync38(journal, { throwIfNoEntry: false });
     need6(!!dir && dir.isDirectory() && !dir.isSymbolicLink() && dir.uid === process.getuid() && (dir.mode & 511) === 448, "UNSAFE_JOURNAL");
-    need6(!lstatSync37(join66(journal, "receipt.json"), { throwIfNoEntry: false }), "RECONCILE_ALREADY_COMPLETE");
-    need6(lstatSync37(join66(journal, "stopped.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_JOURNAL_INCOMPLETE");
-    const stoppedFile = snapshot(join66(journal, "stopped.json"), true);
-    const intentFile = snapshot(join66(journal, "intent.json"), true), intent = JSON.parse(intentFile.text);
-    const configBefore = snapshot(join66(journal, "config.before.toml"), true), hooksBefore = snapshot(join66(journal, "hooks.before.json"), true), policyBefore = snapshot(join66(journal, "policy.before.json"), true);
+    need6(!lstatSync38(join67(journal, "receipt.json"), { throwIfNoEntry: false }), "RECONCILE_ALREADY_COMPLETE");
+    need6(lstatSync38(join67(journal, "stopped.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_JOURNAL_INCOMPLETE");
+    const stoppedFile = snapshot(join67(journal, "stopped.json"), true);
+    const intentFile = snapshot(join67(journal, "intent.json"), true), intent = JSON.parse(intentFile.text);
+    const configBefore = snapshot(join67(journal, "config.before.toml"), true), hooksBefore = snapshot(join67(journal, "hooks.before.json"), true), policyBefore = snapshot(join67(journal, "policy.before.json"), true);
     const legacyIntent = intent.home === undefined && intent.configSha256 === undefined && intent.configVersion === undefined && intent.declarations === undefined && intent.admitted === undefined && intent.nativeHooks === undefined;
     need6(intent.version === 1 && /^[a-f0-9]{64}$/.test(intent.planDigest) && typeof intent.configPath === "string" && /^[a-f0-9]{64}$/.test(intent.policySha256) && /^[a-f0-9]{64}$/.test(intent.hooksSha256) && Array.isArray(intent.hooks) && intent.hooks.length > 0 && intent.hooks.length <= 100 && (legacyIntent || typeof intent.home === "string" && intent.home === home && /^[a-f0-9]{64}$/.test(intent.configSha256) && typeof intent.configVersion === "string" && Array.isArray(intent.declarations) && Array.isArray(intent.admitted) && Array.isArray(intent.nativeHooks)), "RECONCILE_INTENT_INVALID");
-    const declarations = intent.declarations ?? intent.hooks.map((hook) => ({ event: hook.event, key: `${join66(home, ".codex/hooks.json")}${hook.key.slice(hook.key.indexOf(".codex/hooks.json") + ".codex/hooks.json".length)}`, command: hook.command }));
+    const declarations = intent.declarations ?? intent.hooks.map((hook) => ({ event: hook.event, key: `${join67(home, ".codex/hooks.json")}${hook.key.slice(hook.key.indexOf(".codex/hooks.json") + ".codex/hooks.json".length)}`, command: hook.command }));
     const admitted = intent.admitted ?? intent.hooks;
     const configSha256 = intent.configSha256 ?? configBefore.sha256, configVersion = intent.configVersion ?? intent.expectedVersion;
     const digestInput = { version: 1, home: intent.home ?? home, configPath: intent.configPath, ...intent.nativeConfigPath !== undefined ? { nativeConfigPath: intent.nativeConfigPath } : {}, configSha256, configVersion, policySha256: intent.policySha256, hooksSha256: intent.hooksSha256, skillsCli: intent.skillsCli, nativeVersion: intent.nativeVersion, declarations, admitted };
     need6(makePlanDigest(digestInput) === intent.planDigest, "RECONCILE_PLAN_CHANGED");
     need6(isDeepStrictEqual17(intent.hooks, admitted.filter((hook) => !hook.enabled || hook.trustStatus !== "trusted")), "RECONCILE_INTENT_HOOKS_CHANGED");
     need6(configBefore.sha256 === (intent.beforeSha256 ?? intent.configSha256) && hooksBefore.sha256 === intent.hooksSha256 && policyBefore.sha256 === intent.policySha256, "RECONCILE_JOURNAL_CHANGED");
-    const policyCurrent = snapshot(join66(dataDir3, "agent-policy.json"), true);
+    const policyCurrent = snapshot(join67(dataDir3, "agent-policy.json"), true);
     const { claudeDiscoveryRecovery: claudeRecovery, nativeHookAdditionsRecovery: additionsRecovery } = options;
     const recovery = claudeRecovery ?? additionsRecovery;
     need6(!recovery || !options.supersedeBinding, "RECONCILE_RECOVERY_MODE_CONFLICT");
@@ -116197,17 +116523,17 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     if (supersededBinding || recovery) {
       need6(Array.isArray(intent.nativeHooks) && intent.nativeHooks.length > 0, "RECONCILE_NATIVE_INVENTORY_REQUIRED");
       const proof = options.releaseProof;
-      need6(!!proof && isAbsolute34(proof.packageTarPath) && /^[a-f0-9]{64}$/.test(proof.packageTarSha256) && Number.isInteger(proof.packageTarBytes) && proof.packageTarBytes > 0 && /^[a-f0-9]{64}$/.test(proof.manifestSha256) && /^[a-f0-9]{64}$/.test(proof.executableSha256), "RECONCILE_RELEASE_PROVENANCE_REQUIRED");
+      need6(!!proof && isAbsolute35(proof.packageTarPath) && /^[a-f0-9]{64}$/.test(proof.packageTarSha256) && Number.isInteger(proof.packageTarBytes) && proof.packageTarBytes > 0 && /^[a-f0-9]{64}$/.test(proof.manifestSha256) && /^[a-f0-9]{64}$/.test(proof.executableSha256), "RECONCILE_RELEASE_PROVENANCE_REQUIRED");
     }
     const currentConfig = snapshot(intent.configPath, true);
     const policy = parseManagedSkillPolicy(policyCurrent.text), binding = policy.bridge;
-    const alias = binding.rootAliases?.find((item) => item.agent === "codex"), physicalRoot = alias?.target ?? join66(home, ".codex"), hooksPath = join66(physicalRoot, "hooks.json");
-    need6(resolve32(intent.configPath) === resolve32(join66(physicalRoot, "config.toml")), "RECONCILE_CONFIG_PATH_CHANGED");
+    const alias = binding.rootAliases?.find((item) => item.agent === "codex"), physicalRoot = alias?.target ?? join67(home, ".codex"), hooksPath = join67(physicalRoot, "hooks.json");
+    need6(resolve33(intent.configPath) === resolve33(join67(physicalRoot, "config.toml")), "RECONCILE_CONFIG_PATH_CHANGED");
     const nativeConfigPath = intent.nativeConfigPath ?? intent.configPath;
-    need6([join66(home, ".codex/config.toml"), join66(physicalRoot, "config.toml")].includes(nativeConfigPath), "RECONCILE_NATIVE_CONFIG_PATH_CHANGED");
-    const codexHome = nativeConfigPath !== intent.configPath ? undefined : dirname38(nativeConfigPath);
+    need6([join67(home, ".codex/config.toml"), join67(physicalRoot, "config.toml")].includes(nativeConfigPath), "RECONCILE_NATIVE_CONFIG_PATH_CHANGED");
+    const codexHome = nativeConfigPath !== intent.configPath ? undefined : dirname39(nativeConfigPath);
     const hooksCurrent = snapshot(hooksPath);
-    const additions = additionsRecovery ? reviewNativeHookAdditions({ path: additionsRecovery.path, intent: intentFile, policy: policyCurrent, configBefore, configCurrent: currentConfig, hooksBefore, hooksCurrent, nativeHooksPath: join66(dirname38(nativeConfigPath), "hooks.json"), journalHooks: intent.hooks, recordedNativeHooks: intent.nativeHooks }) : undefined;
+    const additions = additionsRecovery ? reviewNativeHookAdditions({ path: additionsRecovery.path, intent: intentFile, policy: policyCurrent, configBefore, configCurrent: currentConfig, hooksBefore, hooksCurrent, nativeHooksPath: join67(dirname39(nativeConfigPath), "hooks.json"), journalHooks: intent.hooks, recordedNativeHooks: intent.nativeHooks }) : undefined;
     const managedHooks = [...intent.hooks, ...additions?.hooks ?? []];
     const managedKeys = managedHooks.map((h) => h.key);
     const witnessSame = codexTrustReconcileWitness(configBefore.text, managedKeys) === codexTrustReconcileWitness(currentConfig.text, managedKeys);
@@ -116271,7 +116597,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
         need6(isDeepStrictEqual17(actual, expected), "RECONCILE_UNRELATED_HOOK_CHANGED");
     }
     for (const wanted of intent.hooks) {
-      const matches2 = nativeHooks.filter((h2) => h2.key === wanted.key || h2.key === wanted.key.replace(join66(home, ".codex/hooks.json"), hooksPath));
+      const matches2 = nativeHooks.filter((h2) => h2.key === wanted.key || h2.key === wanted.key.replace(join67(home, ".codex/hooks.json"), hooksPath));
       need6(matches2.length === 1, "RECONCILE_NATIVE_IDENTITY_CHANGED");
       const h = matches2[0];
       const trusted = h.trustStatus === "trusted";
@@ -116320,7 +116646,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     const receipt = { version: 1, status: preview2 ? "recovery-review-required" : supersededBinding ? "superseded" : "reconciled", reconciled: !preview2, supersededBinding, automaticRollback: false, journal, planDigest: intent.planDigest, nativeVersion: rpc.version, nativeStateVerified: !nativeTrustPending, nativeTrustPending, bindingRefreshRequired: !!configDiscoveryRecovery, nativeExecutionVerified: false, configSha256: currentConfig.sha256, hooksSha256: hooksCurrent.sha256, policySha256: policyBefore.sha256, policyBeforeSha256: policyBefore.sha256, policyCurrentSha256: policyCurrent.sha256, previousSkillsCli: intent.skillsCli, skillsCli: skillsCli.receipt, releaseProof: options.releaseProof, nativeInventoryScope: recordedNativeHooks ? "complete" : "declared-managed-hooks-only", unrelatedNativeHooksPreserved: !!recordedNativeHooks, unrelatedSettingsAndCommentsPreserved: true, ...recoveryPlan ? { recoveryPlan, recoveryPlanDigest } : {} };
     if (preview2)
       return receipt;
-    save(join66(journal, "receipt.json"), json2(receipt));
+    save(join67(journal, "receipt.json"), json2(receipt));
     return receipt;
   } catch (error61) {
     const message = error61 instanceof Error && error61.message.startsWith("CODEX_HOOK_TRUST_") ? error61.message : "CODEX_HOOK_TRUST_RECONCILE_REFUSED";
@@ -116330,21 +116656,21 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
   }
 }
 async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRpc) {
-  const home = resolve32(options.home ?? homedir12());
-  return withCodexCorpusWriteAsync([join66(home, ".codex")], () => enrollCodexNativeHooksUnlocked(options, connect), options);
+  const home = resolve33(options.home ?? homedir13());
+  return withCodexCorpusWriteAsync([join67(home, ".codex")], () => enrollCodexNativeHooksUnlocked(options, connect), options);
 }
 async function enrollCodexNativeHooksUnlocked(options, connect) {
   let rpc, journal;
   try {
-    const home = resolve32(options.home ?? homedir12()), dataDir3 = resolve32(options.dataDir ?? getDataDirReadOnly());
+    const home = resolve33(options.home ?? homedir13()), dataDir3 = resolve33(options.dataDir ?? getDataDirReadOnly());
     assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home });
-    const policyFile = snapshot(join66(dataDir3, "agent-policy.json"), true), policy = parseManagedSkillPolicy(policyFile.text);
+    const policyFile = snapshot(join67(dataDir3, "agent-policy.json"), true), policy = parseManagedSkillPolicy(policyFile.text);
     const binding = policy.bridge, alias = binding.rootAliases?.find((item) => item.agent === "codex");
     const skillsCli = bindSkillsCli(binding.commands.codex, options.reviewedSkillsCli);
-    const physicalRoot = alias?.target ?? join66(home, ".codex"), hooksPath = join66(physicalRoot, "hooks.json"), configPath = join66(physicalRoot, "config.toml");
-    need6(options.codexHome === undefined || isAbsolute34(options.codexHome) && [join66(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
+    const physicalRoot = alias?.target ?? join67(home, ".codex"), hooksPath = join67(physicalRoot, "hooks.json"), configPath = join67(physicalRoot, "config.toml");
+    need6(options.codexHome === undefined || isAbsolute35(options.codexHome) && [join67(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
     const codexHome = options.codexHome === undefined ? undefined : physicalRoot;
-    const nativeConfigPath = join66(codexHome ?? join66(home, ".codex"), "config.toml");
+    const nativeConfigPath = join67(codexHome ?? join67(home, ".codex"), "config.toml");
     const hooksFile = snapshot(hooksPath), configFile = snapshot(configPath, true), original = structure3(configFile.text);
     const declarations = JSON.parse(hooksFile.text).hooks, expected = [];
     for (const [event, [nativeEvent, label]] of Object.entries(eventNames)) {
@@ -116353,25 +116679,25 @@ async function enrollCodexNativeHooksUnlocked(options, connect) {
       need6(Array.isArray(groups), "DECLARATION_CHANGED");
       const matches2 = groups.flatMap((group, gi) => (group.hooks ?? []).flatMap((entry, hi) => entry.command === command ? [{ group, entry, gi, hi }] : []));
       need6(matches2.length === 1 && isDeepStrictEqual17(matches2[0].group, { hooks: [{ type: "command", command, timeout: 15 }] }), "DECLARATION_CHANGED");
-      expected.push({ event: nativeEvent, key: `${join66(home, ".codex/hooks.json")}:${label}:${matches2[0].gi}:${matches2[0].hi}`, command });
+      expected.push({ event: nativeEvent, key: `${join67(home, ".codex/hooks.json")}:${label}:${matches2[0].gi}:${matches2[0].hi}`, command });
     }
     codexTrustTextWitness(configFile.text, expected.map((h) => h.key));
     rpc = await connect({ command: options.codexCommand ?? "codex", home, codexHome });
     need6(SUPPORTED_CODEX_HOOK_VERSIONS.includes(rpc.version), "NATIVE_UNSUPPORTED_VERSION");
     const list2 = async () => {
       const response = await rpc.request("hooks/list", { cwds: [home] });
-      const nativeRoots = [...new Set([physicalRoot, join66(home, ".codex")])];
-      const coexistenceWarnings = nativeRoots.flatMap((hooksRoot) => nativeRoots.map((configRoot) => `loading hooks from both ${join66(hooksRoot, "hooks.json")} and ${join66(configRoot, "config.toml")}; prefer a single representation for this layer`));
+      const nativeRoots = [...new Set([physicalRoot, join67(home, ".codex")])];
+      const coexistenceWarnings = nativeRoots.flatMap((hooksRoot) => nativeRoots.map((configRoot) => `loading hooks from both ${join67(hooksRoot, "hooks.json")} and ${join67(configRoot, "config.toml")}; prefer a single representation for this layer`));
       const entry = response?.data?.[0];
       need6(Array.isArray(response?.data) && response.data.length === 1 && entry.cwd === home && Array.isArray(entry.hooks) && entry.hooks.length <= 1e4 && Array.isArray(entry.errors) && entry.errors.length === 0 && Array.isArray(entry.warnings) && entry.warnings.length <= 1 && entry.warnings.every((warning) => typeof warning === "string" && coexistenceWarnings.includes(warning)), "NATIVE_DISCOVERY_REFUSED");
       return response.data[0].hooks;
     };
     const admit = (hooks) => expected.map((wanted) => {
-      const canonicalKey = wanted.key.replace(join66(home, ".codex/hooks.json"), hooksPath);
+      const canonicalKey = wanted.key.replace(join67(home, ".codex/hooks.json"), hooksPath);
       const matches2 = hooks.filter((h2) => h2.key === wanted.key || h2.key === canonicalKey);
       need6(matches2.length === 1, "AMBIGUOUS_IDENTITY");
       const h = matches2[0];
-      need6(h.eventName === wanted.event && h.handlerType === "command" && h.command === wanted.command && h.matcher === null && h.timeoutSec === 15 && h.async === false && h.statusMessage === null && h.additionalContextLimit === null && [hooksPath, join66(home, ".codex/hooks.json")].includes(h.sourcePath) && h.source === "user" && h.pluginId === null && h.isManaged === false && /^sha256:[a-f0-9]{64}$/.test(h.currentHash) && typeof h.enabled === "boolean", "NATIVE_IDENTITY_CHANGED");
+      need6(h.eventName === wanted.event && h.handlerType === "command" && h.command === wanted.command && h.matcher === null && h.timeoutSec === 15 && h.async === false && h.statusMessage === null && h.additionalContextLimit === null && [hooksPath, join67(home, ".codex/hooks.json")].includes(h.sourcePath) && h.source === "user" && h.pluginId === null && h.isManaged === false && /^sha256:[a-f0-9]{64}$/.test(h.currentHash) && typeof h.enabled === "boolean", "NATIVE_IDENTITY_CHANGED");
       need6(hooks.filter((other) => other.command === wanted.command).length === 1, "AMBIGUOUS_IDENTITY");
       need6(["trusted", "untrusted", "modified"].includes(h.trustStatus), "UNKNOWN_TRUST_STATUS");
       return { key: h.key, event: wanted.event, command: wanted.command, handlerType: h.handlerType, timeoutSec: h.timeoutSec, sourcePath: h.sourcePath, currentHash: h.currentHash, enabled: h.enabled, trustStatus: h.trustStatus };
@@ -116397,27 +116723,27 @@ async function enrollCodexNativeHooksUnlocked(options, connect) {
     const baseReceipt = { planDigest, skillsCli: skillsCli.receipt, nativeVersion: rpc.version, nativeConfigPath, ownedNativeProcessId: rpc.processId, agent: "codex", applied: false, planned, nativeEligible: planned.length === 0, bindingRefreshRequired: false, transport: "owned-stdio-process", existingSessionsReloaded: false, nativeExecutionVerified: false };
     if (options.apply)
       need6(options.reviewedPlanDigest === planDigest, "PLAN_CHANGED: run the dry-run again and pass its reviewed --plan-digest with --apply");
-    const parent = join66(dataDir3, "native-hook-trust");
-    const st = lstatSync37(parent, { throwIfNoEntry: false });
+    const parent = join67(dataDir3, "native-hook-trust");
+    const st = lstatSync38(parent, { throwIfNoEntry: false });
     if (st) {
       need6(st.isDirectory() && !st.isSymbolicLink() && st.uid === process.getuid() && (st.mode & 511) === 448, "UNSAFE_JOURNAL");
       const priorJournals = readdirSync23(parent);
       need6(priorJournals.length < 1000, "JOURNAL_BOUND");
       for (const name of priorJournals) {
         need6(/^[a-f0-9-]{36}$/.test(name), "UNSAFE_JOURNAL");
-        need6(lstatSync37(join66(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
+        need6(lstatSync38(join67(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
       }
     }
     if (!options.apply || !planned.length)
       return baseReceipt;
     if (!st)
       mkdirSync28(parent, { mode: 448 });
-    journal = join66(parent, randomUUID12());
+    journal = join67(parent, randomUUID12());
     mkdirSync28(journal, { mode: 448 });
-    save(join66(journal, "config.before.toml"), configFile.bytes);
-    save(join66(journal, "hooks.before.json"), hooksFile.bytes);
-    save(join66(journal, "policy.before.json"), policyFile.bytes);
-    save(join66(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook) }));
+    save(join67(journal, "config.before.toml"), configFile.bytes);
+    save(join67(journal, "hooks.before.json"), hooksFile.bytes);
+    save(join67(journal, "policy.before.json"), policyFile.bytes);
+    save(join67(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook) }));
     need6(isDeepStrictEqual17(admit(await list2()), admitted), "NATIVE_DISCOVERY_CHANGED");
     checkInputs();
     let result2;
@@ -116433,7 +116759,7 @@ async function enrollCodexNativeHooksUnlocked(options, connect) {
     for (const h of planned)
       expectedConfig.hooks.state[h.key] = { ...expectedConfig.hooks.state[h.key], enabled: true, trusted_hash: h.currentHash };
     need6(isDeepStrictEqual17(structure3(after2.text), expectedConfig) && codexTrustTextWitness(after2.text, keys3) === preservationText, "PRESERVATION_FAILED");
-    const savedConfig = snapshot(join66(journal, "config.before.toml"), true);
+    const savedConfig = snapshot(join67(journal, "config.before.toml"), true);
     need6(savedConfig.sha256 === configFile.sha256, "JOURNAL_CHANGED");
     const discoveryTransition = binding.discovery?.codex ? createCodexHookDiscoveryRecovery(binding.discovery.codex, savedConfig, after2, planned) : undefined;
     unchanged2(policyFile);
@@ -116449,13 +116775,13 @@ async function enrollCodexNativeHooksUnlocked(options, connect) {
     skillsCli.recheck();
     assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home, codexDiscoveryRecovery: discoveryTransition });
     const receipt = { ...baseReceipt, applied: true, nativeEligible: true, bindingRefreshRequired: !!discoveryTransition, ...discoveryTransition ? { discoveryTransition } : {}, nativeConfigVersion: result2.version, journal, beforeSha256: configFile.sha256, afterSha256: after2.sha256, unrelatedSettingsAndCommentsPreserved: true };
-    save(join66(journal, "receipt.json"), json2(receipt));
+    save(join67(journal, "receipt.json"), json2(receipt));
     return receipt;
   } catch (error61) {
     const message = error61 instanceof Error && error61.message.startsWith("CODEX_HOOK_TRUST_") ? error61.message : "CODEX_HOOK_TRUST_REFUSED: verify managed bridge installation and native Codex support";
     if (journal) {
       try {
-        save(join66(journal, "stopped.json"), json2({ error: message.split(":")[0], automaticRollback: false, reconcileBeforeRetry: true }));
+        save(join67(journal, "stopped.json"), json2({ error: message.split(":")[0], automaticRollback: false, reconcileBeforeRetry: true }));
       } catch {}
     }
     throw new Error(message);
@@ -116490,7 +116816,7 @@ var init_agent_codex_trust = __esm(() => {
 // src/lib/codex-native-trust.ts
 import { createHash as createHash40 } from "crypto";
 import { readFileSync as readFileSync44 } from "fs";
-import { join as join67, resolve as resolve33 } from "path";
+import { join as join68, resolve as resolve34 } from "path";
 function refuse5(detail) {
   throw new Error(`NATIVE_SKILL_POLICY_TRUST_REFUSED: ${detail}`);
 }
@@ -116509,7 +116835,7 @@ function planCodexNativeTrust(options) {
     refuse5("digests must be unique");
   if (typeof expectedPolicySha256 !== "string" || !HEX_DIGEST2.test(expectedPolicySha256))
     refuse5("--expected-policy-sha256 must be lowercase SHA-256 hex");
-  const dataDir3 = resolve33(options.dataDir ?? getDataDirReadOnly()), policyPath = join67(dataDir3, "agent-policy.json");
+  const dataDir3 = resolve34(options.dataDir ?? getDataDirReadOnly()), policyPath = join68(dataDir3, "agent-policy.json");
   assertOperatorTrustRoot(dataDir3);
   const snapshot2 = readManagedSkillPolicySnapshot(dataDir3);
   if (!snapshot2)
@@ -116692,8 +117018,8 @@ var init_hook_diagnostics = __esm(() => {
 
 // src/lib/claude-prospective-review.ts
 import { createHash as createHash41 } from "crypto";
-import { lstatSync as lstatSync38, readFileSync as readFileSync45, readdirSync as readdirSync24, realpathSync as realpathSync21 } from "fs";
-import { basename as basename19, dirname as dirname39, isAbsolute as isAbsolute35, join as join68, relative as relative12, resolve as resolve34, sep as sep15 } from "path";
+import { lstatSync as lstatSync39, readFileSync as readFileSync45, readdirSync as readdirSync24, realpathSync as realpathSync21 } from "fs";
+import { basename as basename19, dirname as dirname40, isAbsolute as isAbsolute36, join as join69, relative as relative12, resolve as resolve35, sep as sep15 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual18 } from "util";
 function hashClaudeDiscoveryBinding(binding) {
   return sha7(JSON.stringify(binding));
@@ -116744,7 +117070,7 @@ function keys3(value, expected, name) {
     refuse6(`${name} has an unsupported shape`);
 }
 function abs(path, name) {
-  if (typeof path !== "string" || !path || path.length > 4096 || /[\x00-\x1f\x7f]/.test(path) || !isAbsolute35(path) || resolve34(path) !== path)
+  if (typeof path !== "string" || !path || path.length > 4096 || /[\x00-\x1f\x7f]/.test(path) || !isAbsolute36(path) || resolve35(path) !== path)
     refuse6(`${name} must be a normalized absolute path`);
 }
 function validUtcTimestamp(value) {
@@ -116752,27 +117078,27 @@ function validUtcTimestamp(value) {
 }
 function safeFile(path, name) {
   abs(path, name);
-  for (let at2 = dirname39(path);; at2 = dirname39(at2)) {
-    const stat4 = lstatSync38(at2, { throwIfNoEntry: false });
+  for (let at2 = dirname40(path);; at2 = dirname40(at2)) {
+    const stat4 = lstatSync39(at2, { throwIfNoEntry: false });
     if (!stat4?.isDirectory() || stat4.isSymbolicLink())
       refuse6(`${name} traverses a symlink or non-directory`);
-    if (at2 === dirname39(at2))
+    if (at2 === dirname40(at2))
       break;
   }
-  const stat3 = lstatSync38(path, { throwIfNoEntry: false });
+  const stat3 = lstatSync39(path, { throwIfNoEntry: false });
   if (!stat3?.isFile() || stat3.isSymbolicLink() || stat3.size > MAX_CANDIDATE_BYTES)
     refuse6(`${name} is not a bounded regular file`);
   return readFileSync45(path);
 }
 function canonicalDir(path, name) {
   abs(path, name);
-  if (realpathSync21(path) !== path || !lstatSync38(path).isDirectory())
+  if (realpathSync21(path) !== path || !lstatSync39(path).isDirectory())
     refuse6(`${name} is not a canonical directory`);
-  for (let at2 = path;; at2 = dirname39(at2)) {
-    const stat3 = lstatSync38(at2);
+  for (let at2 = path;; at2 = dirname40(at2)) {
+    const stat3 = lstatSync39(at2);
     if (!stat3.isDirectory() || stat3.isSymbolicLink())
       refuse6(`${name} traverses a symlink`);
-    if (at2 === dirname39(at2))
+    if (at2 === dirname40(at2))
       break;
   }
 }
@@ -116781,17 +117107,17 @@ function captureClaudeProspectiveCandidateClosure(root2) {
   const entries = [];
   let bytes = 0;
   const walk2 = (directory2) => {
-    const beforeDirectory = lstatSync38(directory2);
+    const beforeDirectory = lstatSync39(directory2);
     const names = readdirSync24(directory2).sort();
     if (new Set(names).size !== names.length)
       refuse6("candidate contains ambiguous directory entries");
     for (const name of names) {
       if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\\") || /[\x00-\x1f\x7f]/.test(name))
         refuse6("candidate contains an unsupported path member");
-      const path = join68(directory2, name), rel = relative12(root2, path).split(sep15).join("/");
+      const path = join69(directory2, name), rel = relative12(root2, path).split(sep15).join("/");
       if (entries.length >= MAX_CANDIDATE_FILES)
         refuse6("candidate closure exceeds its member limit");
-      const stat3 = lstatSync38(path);
+      const stat3 = lstatSync39(path);
       if (stat3.isSymbolicLink())
         refuse6("candidate closure contains a symlink");
       if (stat3.isDirectory()) {
@@ -116801,14 +117127,14 @@ function captureClaudeProspectiveCandidateClosure(root2) {
         bytes += stat3.size;
         if (bytes > MAX_CANDIDATE_BYTES)
           refuse6("candidate closure exceeds its byte limit");
-        const content = safeFile(path, "candidate member"), after2 = lstatSync38(path);
+        const content = safeFile(path, "candidate member"), after2 = lstatSync39(path);
         if (!after2.isFile() || after2.dev !== stat3.dev || after2.ino !== stat3.ino || after2.size !== stat3.size || after2.mtimeMs !== stat3.mtimeMs || after2.ctimeMs !== stat3.ctimeMs)
           refuse6("candidate member changed while being read");
         entries.push([rel, "file", sha7(content)]);
       } else
         refuse6("candidate closure contains a special file");
     }
-    const afterDirectory = lstatSync38(directory2);
+    const afterDirectory = lstatSync39(directory2);
     if (!afterDirectory.isDirectory() || afterDirectory.dev !== beforeDirectory.dev || afterDirectory.ino !== beforeDirectory.ino || afterDirectory.mtimeMs !== beforeDirectory.mtimeMs || afterDirectory.ctimeMs !== beforeDirectory.ctimeMs)
       refuse6("candidate directory changed while being read");
   };
@@ -116819,9 +117145,9 @@ function captureClaudeProspectiveCandidateClosure(root2) {
 function captureClaudeInstallerCandidate(root2, policyPath) {
   const closureSha256 = captureClaudeProspectiveCandidateClosure(root2);
   const dataDir3 = getDataDirReadOnly();
-  if (policyPath !== join68(dataDir3, "agent-policy.json"))
+  if (policyPath !== join69(dataDir3, "agent-policy.json"))
     refuse6("Skills policy path differs from the package-owned resolver");
-  const catalogPath = join68(root2, ".claude-plugin/marketplace.json");
+  const catalogPath = join69(root2, ".claude-plugin/marketplace.json");
   const catalog = jsonFile(catalogPath, "candidate catalog");
   if (!catalog || !Array.isArray(catalog.plugins))
     refuse6("candidate catalog is invalid");
@@ -116832,13 +117158,13 @@ function captureClaudeInstallerCandidate(root2, policyPath) {
     if (names.has(row2.name))
       refuse6("candidate catalog repeats a plugin name");
     names.add(row2.name);
-    if (typeof row2.source !== "string" || isAbsolute35(row2.source) || /[\\\x00-\x1f\x7f]/.test(row2.source))
+    if (typeof row2.source !== "string" || isAbsolute36(row2.source) || /[\\\x00-\x1f\x7f]/.test(row2.source))
       refuse6("candidate catalog plugin source is invalid");
-    const pluginRoot = resolve34(root2, row2.source);
+    const pluginRoot = resolve35(root2, row2.source);
     const relativeRoot = relative12(root2, pluginRoot);
-    if (!relativeRoot || relativeRoot === "." || relativeRoot === ".." || relativeRoot.startsWith(`..${sep15}`) || isAbsolute35(relativeRoot))
+    if (!relativeRoot || relativeRoot === "." || relativeRoot === ".." || relativeRoot.startsWith(`..${sep15}`) || isAbsolute36(relativeRoot))
       refuse6("candidate plugin source escapes the candidate root");
-    const path = join68(pluginRoot, ".claude-plugin/plugin.json");
+    const path = join69(pluginRoot, ".claude-plugin/plugin.json");
     return { plugin: row2.name, ...captureClaudePluginManifestFile(path) };
   });
   const policy = readManagedSkillPolicySnapshot(dataDir3);
@@ -116855,7 +117181,7 @@ function captureClaudeInstallerCandidate(root2, policyPath) {
 }
 function readWitness(path, expected, name) {
   abs(path, `${name} path`);
-  const stat3 = lstatSync38(path, { throwIfNoEntry: false });
+  const stat3 = lstatSync39(path, { throwIfNoEntry: false });
   if (expected === null) {
     if (stat3)
       refuse6(`${name} was absent at review but is now present`);
@@ -116867,7 +117193,7 @@ function readWitness(path, expected, name) {
     refuse6(`${name} preimage changed`);
 }
 function jsonFile(path, name) {
-  const stat3 = lstatSync38(path, { throwIfNoEntry: false });
+  const stat3 = lstatSync39(path, { throwIfNoEntry: false });
   if (!stat3)
     return null;
   let value;
@@ -116898,8 +117224,8 @@ function assertNoUnprojectedSkillPayload(root2, catalogPath, marketplace, plugin
     refuse6("candidate marketplace entry declares native skill or command payloads");
   const walk2 = (directory2) => {
     for (const name of readdirSync24(directory2).sort()) {
-      const path = join68(directory2, name), rel = relative12(root2, path).split(sep15).join("/");
-      const stat3 = lstatSync38(path);
+      const path = join69(directory2, name), rel = relative12(root2, path).split(sep15).join("/");
+      const stat3 = lstatSync39(path);
       if (stat3.isDirectory())
         walk2(path);
       else if (stat3.isFile()) {
@@ -116956,16 +117282,16 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     refuse6("Skills policy root alias changed or is invalid");
   }
   const canonical8 = (path) => canonicalAgentPath(path, aliases);
-  const configRoot = canonical8(join68(request2.native.home, ".claude"));
+  const configRoot = canonical8(join69(request2.native.home, ".claude"));
   canonicalDir(configRoot, "Claude config root");
   if (request2.native.configRoot !== configRoot)
     refuse6("Claude config root differs from the current resolver and reviewed root alias");
-  const pluginRoot = join68(configRoot, "plugins");
+  const pluginRoot = join69(configRoot, "plugins");
   if (process.env.CLAUDE_CODE_PLUGIN_CACHE_DIR)
     refuse6("CLAUDE_CODE_PLUGIN_CACHE_DIR overrides are unsupported by this prospective schema; bind and review the actual cache root first");
   if (request2.native.pluginRoot !== pluginRoot)
     refuse6("Claude plugin root differs from the supported standard plugins directory; Cowork and custom cache roots require a separately bound schema");
-  const pluginRootStat = lstatSync38(pluginRoot, { throwIfNoEntry: false });
+  const pluginRootStat = lstatSync39(pluginRoot, { throwIfNoEntry: false });
   if (pluginRootStat && (!pluginRootStat.isDirectory() || pluginRootStat.isSymbolicLink()))
     refuse6("Claude plugin root is not a regular directory");
   keys3(request2.candidate, ["marketplace", "root", "catalogPath", "catalogSha256", "closureSha256", "plugins", ...hasOwn2(request2.candidate, "releaseManifest") ? ["releaseManifest"] : [], ...hasOwn2(request2.candidate, "functionHooksEnv") ? ["functionHooksEnv"] : [], ...hasOwn2(request2.candidate, "settingsMarketplaceSource") ? ["settingsMarketplaceSource"] : []], "candidate");
@@ -116982,7 +117308,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
   abs(candidate2.catalogPath, "catalog path");
   if (!candidate2.catalogPath.startsWith(candidate2.root + sep15))
     refuse6("catalog must be inside the frozen candidate root");
-  if (candidate2.catalogPath !== join68(candidate2.root, ".claude-plugin", "marketplace.json"))
+  if (candidate2.catalogPath !== join69(candidate2.root, ".claude-plugin", "marketplace.json"))
     refuse6("marketplace catalog must be at the frozen root's .claude-plugin/marketplace.json path");
   if (!SHA256.test(candidate2.catalogSha256) || !SHA256.test(candidate2.closureSha256))
     refuse6("candidate digests must be lowercase SHA-256");
@@ -117024,11 +117350,11 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     if (Buffer.byteLength(canonicalJson3(selected.optionsPatch), "utf8") > 16 * 1024)
       refuse6("selected plugin optionsPatch exceeds its byte bound");
     abs(selected.manifestPath, "manifest path");
-    if (!selected.manifestPath.startsWith(candidate2.root + sep15) || basename19(dirname39(selected.manifestPath)) !== ".claude-plugin" || selected.manifestPath !== join68(dirname39(dirname39(selected.manifestPath)), ".claude-plugin", "plugin.json"))
+    if (!selected.manifestPath.startsWith(candidate2.root + sep15) || basename19(dirname40(selected.manifestPath)) !== ".claude-plugin" || selected.manifestPath !== join69(dirname40(dirname40(selected.manifestPath)), ".claude-plugin", "plugin.json"))
       refuse6("plugin manifest must be under a plugin root inside the frozen marketplace closure");
-    const pluginRoot2 = dirname39(dirname39(selected.manifestPath));
+    const pluginRoot2 = dirname40(dirname40(selected.manifestPath));
     const relativePluginRoot = relative12(candidate2.root, pluginRoot2);
-    if (!relativePluginRoot || relativePluginRoot === "." || relativePluginRoot === ".." || relativePluginRoot.startsWith(`..${sep15}`) || isAbsolute35(relativePluginRoot))
+    if (!relativePluginRoot || relativePluginRoot === "." || relativePluginRoot === ".." || relativePluginRoot.startsWith(`..${sep15}`) || isAbsolute36(relativePluginRoot))
       refuse6("plugin root must be a child of the frozen marketplace root");
     canonicalDir(pluginRoot2, "candidate plugin root");
     if (!SHA256.test(selected.manifestSha256))
@@ -117062,7 +117388,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     const sourcePath = selectedEntry.source;
     const sourceRelativePath = relative12(candidate2.root, pluginRoot2).split(sep15).join("/");
     const expectedSourcePath = sourceRelativePath === "." ? "./" : `./${sourceRelativePath}`;
-    if (typeof sourcePath !== "string" || isAbsolute35(sourcePath) || sourcePath !== expectedSourcePath || resolve34(dirname39(dirname39(candidate2.catalogPath)), sourcePath) !== pluginRoot2)
+    if (typeof sourcePath !== "string" || isAbsolute36(sourcePath) || sourcePath !== expectedSourcePath || resolve35(dirname40(dirname40(candidate2.catalogPath)), sourcePath) !== pluginRoot2)
       refuse6("marketplace source does not resolve to the frozen plugin closure; external source mapping is not supported by this schema");
     const entry = captureClaudeMarketplaceEntry(candidate2.catalogPath, candidate2.marketplace, selected.plugin);
     if (entry.sha256.length !== 64)
@@ -117082,12 +117408,12 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
   for (const name of ["settings", "projectSettings", "projectSettingsLocal", "marketplaces", "installedPlugins"])
     keys3(request2.preimages[name], ["path", "sha256"], `${name} preimage`);
   const expectedPaths = {
-    settings: request2.scope.kind === "project" ? canonical8(join68(request2.scope.projectPath, ".claude/settings.json")) : canonical8(join68(request2.native.home, ".claude/settings.json")),
-    userSettings: canonical8(join68(request2.native.home, ".claude/settings.json")),
-    projectSettings: canonical8(join68(request2.scope.projectPath, ".claude/settings.json")),
-    projectSettingsLocal: canonical8(join68(request2.scope.projectPath, ".claude/settings.local.json")),
-    marketplaces: canonical8(join68(request2.native.home, ".claude/plugins/known_marketplaces.json")),
-    installedPlugins: canonical8(join68(request2.native.home, ".claude/plugins/installed_plugins.json"))
+    settings: request2.scope.kind === "project" ? canonical8(join69(request2.scope.projectPath, ".claude/settings.json")) : canonical8(join69(request2.native.home, ".claude/settings.json")),
+    userSettings: canonical8(join69(request2.native.home, ".claude/settings.json")),
+    projectSettings: canonical8(join69(request2.scope.projectPath, ".claude/settings.json")),
+    projectSettingsLocal: canonical8(join69(request2.scope.projectPath, ".claude/settings.local.json")),
+    marketplaces: canonical8(join69(request2.native.home, ".claude/plugins/known_marketplaces.json")),
+    installedPlugins: canonical8(join69(request2.native.home, ".claude/plugins/installed_plugins.json"))
   };
   for (const name of Object.keys(expectedPaths)) {
     const witness = request2.preimages[name];
@@ -117205,7 +117531,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     const manifestVersion = manifest.version;
     const sanitizeComponent = (value) => value.replace(/[^A-Za-z0-9_-]/g, "-");
     const sanitizedVersion = manifestVersion === "." || manifestVersion === ".." ? "-" : manifestVersion.replace(/[^A-Za-z0-9._-]/g, "-");
-    const expectedInstallPath = join68(pluginRoot, "cache", sanitizeComponent(candidate2.marketplace), sanitizeComponent(plugin), sanitizedVersion);
+    const expectedInstallPath = join69(pluginRoot, "cache", sanitizeComponent(candidate2.marketplace), sanitizeComponent(plugin), sanitizedVersion);
     if (expectedInstallPath.length > 4096)
       refuse6("candidate native cache path exceeds its bound");
     const targetRegistration = {
@@ -117343,7 +117669,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
       { name: "project-settings-local", path: expectedPaths.projectSettingsLocal, sha256: request2.preimages.projectSettingsLocal.sha256 },
       { name: "known-marketplaces", path: expectedPaths.marketplaces, sha256: request2.preimages.marketplaces.sha256 },
       { name: "installed-plugins", path: expectedPaths.installedPlugins, sha256: request2.preimages.installedPlugins.sha256 },
-      { name: "skills-policy", path: join68(request2.skills.dataDir, "agent-policy.json"), sha256: request2.skills.policySha256 }
+      { name: "skills-policy", path: join69(request2.skills.dataDir, "agent-policy.json"), sha256: request2.skills.policySha256 }
     ],
     ownedDelta: { settingsEnabledPlugins: selectedPluginIds, selectedPluginOptions: selectedOptionPaths, functionHooksEnv: candidate2.functionHooksEnv ?? null, knownMarketplace: candidate2.marketplace, installedPlugins: selectedPluginIds, unrelatedGraph: "preserved-by-complete-semantic-documents" },
     identityPrecondition: "Harnesses must resolve the installed Claude home/config/plugin roots and executable path/version/hash plus the installed Skills data directory through their package-owned consumers, then compare every value before trusting this receipt; this validator checks supplied paths and current bytes only and does not establish actual consumer identity",
@@ -117369,10 +117695,10 @@ var init_claude_prospective_review = __esm(() => {
 
 // src/lib/self-spawn.ts
 import { realpathSync as realpathSync22 } from "fs";
-import { dirname as dirname40, isAbsolute as isAbsolute36, sep as sep16 } from "path";
+import { dirname as dirname41, isAbsolute as isAbsolute37, sep as sep16 } from "path";
 function selfSpawnRoot(entry) {
   const index = entry.indexOf(INSTALLED_PACKAGE);
-  const root2 = index > 0 ? entry.slice(0, index) : dirname40(entry);
+  const root2 = index > 0 ? entry.slice(0, index) : dirname41(entry);
   try {
     return realpathSync22(root2);
   } catch {
@@ -117382,12 +117708,12 @@ function selfSpawnRoot(entry) {
 function selfSpawnCommand(args2, options = {}) {
   const runtime = options.runtime ?? process.execPath;
   const entry = options.entry ?? process.argv[1];
-  if (!runtime || !isAbsolute36(runtime) || !entry || !isAbsolute36(entry))
+  if (!runtime || !isAbsolute37(runtime) || !entry || !isAbsolute37(entry))
     throw new Error("SKILLS_SELF_SPAWN_ENTRY_UNRESOLVED");
   const root2 = selfSpawnRoot(entry);
   const env3 = pinnedLauncherEnvironment(options.env ?? process.env);
   env3[LAUNCH_CWD_VARIABLE] = options.callerCwd ?? process.cwd();
-  return { command: [runtime, ...PINNED_LAUNCHER_BUN_FLAGS, `--cwd=${root2}`, entry, ...args2], cwd: root2, env: env3 };
+  return { command: [runtime, ...PINNED_LAUNCHER_BUN_FLAGS2, `--cwd=${root2}`, entry, ...args2], cwd: root2, env: env3 };
 }
 var INSTALLED_PACKAGE;
 var init_self_spawn = __esm(() => {
@@ -117396,8 +117722,8 @@ var init_self_spawn = __esm(() => {
 });
 
 // src/cli/commands/claude-installer-capture.ts
-import { closeSync as closeSync26, constants as constants24, fstatSync as fstatSync26, lstatSync as lstatSync39, openSync as openSync26, readSync as readSync19 } from "fs";
-import { isAbsolute as isAbsolute37, resolve as resolve35 } from "path";
+import { closeSync as closeSync26, constants as constants25, fstatSync as fstatSync26, lstatSync as lstatSync40, openSync as openSync26, readSync as readSync19 } from "fs";
+import { isAbsolute as isAbsolute38, resolve as resolve36 } from "path";
 function need8(condition, code2) {
   if (!condition)
     throw new CaptureRefusal(code2);
@@ -117411,14 +117737,14 @@ function exactKeys4(value, expected, operation) {
   }
 }
 function canonicalPath2(value) {
-  need8(typeof value === "string" && isAbsolute37(value) && resolve35(value) === value && !/[\x00-\x1f\x7f]/.test(value), "INVALID_PATH: path fields must be normalized absolute paths without control characters");
+  need8(typeof value === "string" && isAbsolute38(value) && resolve36(value) === value && !/[\x00-\x1f\x7f]/.test(value), "INVALID_PATH: path fields must be normalized absolute paths without control characters");
 }
 function readRequest2(path) {
   canonicalPath2(path);
-  const before2 = lstatSync39(path, { throwIfNoEntry: false });
+  const before2 = lstatSync40(path, { throwIfNoEntry: false });
   if (!before2?.isFile() || before2.isSymbolicLink() || before2.size > MAX_REQUEST_BYTES)
     throw new CaptureRefusal("INVALID_REQUEST_FILE: --request must name a regular non-symlink JSON file no larger than 64 KiB");
-  const fd = openSync26(path, constants24.O_RDONLY | (constants24.O_NOFOLLOW ?? 0) | constants24.O_NONBLOCK);
+  const fd = openSync26(path, constants25.O_RDONLY | (constants25.O_NOFOLLOW ?? 0) | constants25.O_NONBLOCK);
   try {
     const opened = fstatSync26(fd);
     need8(opened.isFile() && opened.dev === before2.dev && opened.ino === before2.ino && opened.size === before2.size, "INVALID_REQUEST_FILE: --request must remain the same regular file while read");
@@ -117430,7 +117756,7 @@ function readRequest2(path) {
         break;
       length += count;
     }
-    const after2 = fstatSync26(fd), current = lstatSync39(path);
+    const after2 = fstatSync26(fd), current = lstatSync40(path);
     need8(length <= MAX_REQUEST_BYTES && length === opened.size && after2.size === opened.size && after2.mtimeMs === opened.mtimeMs && after2.ctimeMs === opened.ctimeMs && current.dev === opened.dev && current.ino === opened.ino && current.mtimeMs === opened.mtimeMs && current.ctimeMs === opened.ctimeMs, "INVALID_REQUEST_FILE: --request must remain unchanged while read");
     try {
       return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length)));
@@ -117562,10 +117888,10 @@ var exports_agent_integration = {};
 __export(exports_agent_integration, {
   registerAgentIntegration: () => registerAgentIntegration
 });
-import { existsSync as existsSync36, lstatSync as lstatSync40, readFileSync as readFileSync46, readSync as readSync20, writeFileSync as writeFileSync27 } from "fs";
+import { existsSync as existsSync36, lstatSync as lstatSync41, readFileSync as readFileSync46, readSync as readSync20, writeFileSync as writeFileSync27 } from "fs";
 import { createHash as createHash42 } from "crypto";
-import { homedir as homedir13 } from "os";
-import { isAbsolute as isAbsolute38 } from "path";
+import { homedir as homedir14 } from "os";
+import { isAbsolute as isAbsolute39 } from "path";
 function pinnedHookProfile(input3, configuredProfile) {
   try {
     const parsed = parseSkillContextInput(JSON.stringify(input3));
@@ -117661,13 +117987,13 @@ function registerAgentIntegration(parent) {
   });
   hook.command("native-catalog").requiredOption("--cwd <path>", "Absolute project directory observed by native Codex skills/list").requiredOption("--output <file>", "New private file for the projected native catalog").option("--codex-command <path>", "Installed Codex executable used by the native client", "codex").option("--json", "Output bounded capture metadata as JSON", false).description("Capture a reviewed Codex native skill catalog for exact hook enrollment").action(async (options) => {
     try {
-      if (!isAbsolute38(options.cwd) || !isAbsolute38(options.output))
+      if (!isAbsolute39(options.cwd) || !isAbsolute39(options.output))
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_ABSOLUTE_PATH_REQUIRED");
       if (existsSync36(options.output))
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_OUTPUT_EXISTS");
       const catalog = await captureCodexNativeSkillCatalog({
         command: options.codexCommand,
-        home: homedir13(),
+        home: homedir14(),
         ...process.env.CODEX_HOME === undefined ? {} : { codexHome: process.env.CODEX_HOME },
         cwd: options.cwd
       });
@@ -117680,7 +118006,7 @@ function registerAgentIntegration(parent) {
           throw new Error("CODEX_NATIVE_SKILL_CATALOG_OUTPUT_EXISTS");
         throw error61;
       }
-      const written = lstatSync40(options.output);
+      const written = lstatSync41(options.output);
       if (!written.isFile() || written.isSymbolicLink() || (written.mode & 63) !== 0 || readFileSync46(options.output, "utf8") !== bytes)
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_READBACK_FAILED");
       const receipt = {
@@ -117728,9 +118054,9 @@ function registerAgentIntegration(parent) {
   });
   hook.command("review-claude-candidate").requiredOption("--request <file>", "Frozen skills.claude-plugin-prospective-review/v1 JSON request").option("--json", "Return the validation-only receipt as JSON", false).description("Validate a prospective Claude plugin candidate and current preimages without changing native state; Harnesses must compare native and Skills paths against installed package-owned resolvers before trusting the receipt").action(async (options) => {
     try {
-      if (!isAbsolute38(options.request))
+      if (!isAbsolute39(options.request))
         throw new Error("CLAUDE_CANDIDATE_REVIEW_REFUSED: --request must be an absolute path");
-      const stat3 = lstatSync40(options.request);
+      const stat3 = lstatSync41(options.request);
       if (!stat3.isFile() || stat3.isSymbolicLink() || stat3.size > 1024 * 1024)
         throw new Error("CLAUDE_CANDIDATE_REVIEW_REFUSED: request must be a regular file no larger than 1 MiB");
       const requestBytes = readFileSync46(options.request);
@@ -117775,10 +118101,10 @@ function registerAgentIntegration(parent) {
   hook.command("agents").option("--json", "Output the adapter capability inventory", false).description("Show maintained native adapters and explicit coverage limits").action(async () => {
     await writeCliOutput(JSON.stringify({ agents: INTEGRATION_AGENTS.map((agent) => ({ agent, bridge: true, ...AGENT_ADAPTERS[agent] })), inventoryOnly: ["codewith", "windsurf", "pi", "amp", "cline", "roo", "copilot"], limitations: ["Cursor prompt hooks gate submission; selected context is injected at session start only.", "Native discovery checks cover known home roots and current project ancestors. External plugin hook injection and arbitrary added directories require separate review.", "Hermes injects selected prompt context, but native pre_llm_call fails open. Exact native hook trust, bundled reseeding opt-out, native payload retirement and a supervised pre-tool guard are required. Child failures block explicitly; native host/supervisor death is not a universal fail-closed guarantee.", "Restart agents and use their normal hook trust controls after installation."] }, null, 2));
   });
-  hook.command("install").option("--agent <agent>", `Agent to configure: ${INTEGRATION_AGENTS.join(", ")}, all`, "all").option("--command <path>", "Skills executable used by the hook (preserves existing binding; new agents use skills)").option("--selection-profile <id>", "Selection profile (preserves existing binding; new agents use default)").option("--include-vendor", "Retained for compatibility; vendor system skills are always inventoried and disabled", false).option("--discovery-inputs <file>", "Advanced reviewed active plugin roots and source hashes for unsupported registrations").option("--codex-skill-denials <file>", "Explicit reviewed remote skill denials: array of exact name, path and document sha256; requires fresh catalog and discovery inputs").option("--codex-native-catalog <file>", "Reviewed supported Codex skill and installed-plugin receipt for exact qualified-name disables").option("--reviewed-cache-alias <path>", "Exact skill-containing vendor cache alias reviewed for this hook plan").option("--allow-root-aliases", "Allow home .claude/.codex aliases to existing directories within this home", false).option("--apply", "Apply the plan, preserving prior configuration in private backups", false).option("--json", "Output a receipt as JSON", false).description("Plan or install one Skills CLI bridge plus native prompt hooks").action(async (options) => {
+  hook.command("install").option("--agent <agent>", `Agent to configure: ${INTEGRATION_AGENTS.join(", ")}, all (default: configured or detected agents; explicit all requires every adapter)`).option("--command <path>", "Skills executable used by the hook (preserves existing binding; new agents use skills)").option("--selection-profile <id>", "Selection profile (preserves existing binding; new agents use default)").option("--include-vendor", "Retained for compatibility; vendor system skills are always inventoried and disabled", false).option("--discovery-inputs <file>", "Advanced reviewed active plugin roots and source hashes for unsupported registrations").option("--codex-skill-denials <file>", "Explicit reviewed remote skill denials: array of exact name, path and document sha256; requires fresh catalog and discovery inputs").option("--codex-native-catalog <file>", "Reviewed supported Codex skill and installed-plugin receipt for exact qualified-name disables").option("--reviewed-cache-alias <path>", "Exact skill-containing vendor cache alias reviewed for this hook plan").option("--allow-root-aliases", "Allow home .claude/.codex aliases to existing directories within this home", false).option("--apply", "Apply the plan, preserving prior configuration in private backups", false).option("--json", "Output a receipt as JSON", false).description("Plan or install one Skills CLI bridge plus native prompt hooks").action(async (options) => {
     try {
       const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync46(options.discoveryInputs, "utf8")) : undefined;
-      const plan = planAgentIntegration({ projectDir: process.cwd(), agents: agents(options.agent), command: options.command, profileId: options.selectionProfile, includeVendor: options.includeVendor, discoveryInputs, allowRootAliases: options.allowRootAliases, reviewedCacheAlias: options.reviewedCacheAlias, codexSkillDenials: options.codexSkillDenials ? JSON.parse(readFileSync46(options.codexSkillDenials, "utf8")) : undefined, codexNativeCatalog: options.codexNativeCatalog ? JSON.parse(readFileSync46(options.codexNativeCatalog, "utf8")) : undefined });
+      const plan = planAgentIntegration({ projectDir: process.cwd(), agents: options.agent === undefined ? detectedIntegrationAgents() : agents(options.agent), command: options.command, profileId: options.selectionProfile, includeVendor: options.includeVendor, discoveryInputs, allowRootAliases: options.allowRootAliases, reviewedCacheAlias: options.reviewedCacheAlias, codexSkillDenials: options.codexSkillDenials ? JSON.parse(readFileSync46(options.codexSkillDenials, "utf8")) : undefined, codexNativeCatalog: options.codexNativeCatalog ? JSON.parse(readFileSync46(options.codexNativeCatalog, "utf8")) : undefined });
       const result2 = options.apply ? applyAgentIntegration(plan) : { changed: [], backups: [] };
       const receipt = { codexPluginSkillReview: plan.codexPluginSkillReview, codexPluginSkills: plan.changes.filter((change) => change.path.endsWith("agent-policy.json")).map((change) => JSON.parse(change.after).bridge?.codexPluginSkills ?? []).flat(), applied: options.apply, planned: plan.changes.map((change) => change.path), ...result2, rootAliases: plan.rootAliases ?? [], discovery: plan.discoveryAfter, nativeSkills: plan.nativeSkills.map((entry) => ({ agent: entry.agent, path: entry.path, managed: entry.managed, vendor: entry.vendor, system: entry.system === true, bridge: entry.bridge === true })), requiresNativeRetirement: plan.nativeSkills.some((entry) => !entry.bridge && !entry.system) };
       if (options.json)
@@ -117850,12 +118176,12 @@ function registerAgentIntegration(parent) {
       input3.hook_event_name = event;
       const projects = [process.cwd()];
       if (input3.cwd !== undefined) {
-        if (typeof input3.cwd !== "string" || !isAbsolute38(input3.cwd) || input3.cwd.includes("\x00"))
+        if (typeof input3.cwd !== "string" || !isAbsolute39(input3.cwd) || input3.cwd.includes("\x00"))
           throw new Error("Invalid native hook working directory");
         projects.push(input3.cwd);
       }
       if (options.agent === "cursor") {
-        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path) => typeof path !== "string" || !isAbsolute38(path) || path.includes("\x00")))
+        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path) => typeof path !== "string" || !isAbsolute39(path) || path.includes("\x00")))
           throw new Error("Invalid Cursor workspace roots");
         projects.push(...input3.workspace_roots);
         input3.cwd ??= input3.workspace_roots[0] ?? process.cwd();
@@ -117981,6 +118307,7 @@ var init_agent_integration2 = __esm(() => {
   init_agent_hermes();
   init_context();
   init_agent_adapters();
+  init_agent_install_selection();
   init_agent_integration();
   init_agent_codex_trust();
   init_codex_native_skill_policy();
@@ -118133,9 +118460,9 @@ var exports_profiles = {};
 __export(exports_profiles, {
   registerProfiles: () => registerProfiles
 });
-import { closeSync as closeSync27, constants as constants25, fstatSync as fstatSync27, openSync as openSync27, readSync as readSync21, writeFileSync as writeFileSync28 } from "fs";
+import { closeSync as closeSync27, constants as constants26, fstatSync as fstatSync27, openSync as openSync27, readSync as readSync21, writeFileSync as writeFileSync28 } from "fs";
 function readProfileInput(path) {
-  const fd = openSync27(path, constants25.O_RDONLY | constants25.O_NONBLOCK);
+  const fd = openSync27(path, constants26.O_RDONLY | constants26.O_NONBLOCK);
   try {
     const stat3 = fstatSync27(fd);
     if (!stat3.isFile() || stat3.size > MAX_PROFILE_DOCUMENT_BYTES)
@@ -118203,7 +118530,7 @@ __export(exports_grants, {
   registerGrants: () => registerGrants
 });
 import {
-  constants as constants26,
+  constants as constants27,
   closeSync as closeSync28,
   fstatSync as fstatSync28,
   openSync as openSync28,
@@ -118211,7 +118538,7 @@ import {
   writeFileSync as writeFileSync29
 } from "fs";
 function readInput(path) {
-  const fd = openSync28(path, constants26.O_RDONLY | constants26.O_NONBLOCK);
+  const fd = openSync28(path, constants27.O_RDONLY | constants27.O_NONBLOCK);
   try {
     const stat3 = fstatSync28(fd);
     if (!stat3.isFile() || stat3.size > MAX_EXECUTION_GRANT_BYTES)
@@ -118274,19 +118601,19 @@ import {
   mkdirSync as mkdirSync29,
   readdirSync as readdirSync25,
   readFileSync as readFileSync47,
-  statSync as statSync23,
+  statSync as statSync24,
   writeFileSync as writeFileSync30
 } from "fs";
-import { dirname as dirname41, join as join69, resolve as resolve36, sep as sep17 } from "path";
+import { dirname as dirname42, join as join70, resolve as resolve37, sep as sep17 } from "path";
 function fail6(code2, message, detail = []) {
   throw new StationSnapshotError(code2, message, detail);
 }
 function snapshotRootFor(repoRoot, stationId) {
-  return join69(repoRoot, "resources", stationId, "skills");
+  return join70(repoRoot, "resources", stationId, "skills");
 }
 function readSnapshotManifest(repoRoot, stationId) {
   const snapshotRoot = snapshotRootFor(repoRoot, stationId);
-  const manifestPath = join69(snapshotRoot, "sync-manifest.json");
+  const manifestPath = join70(snapshotRoot, "sync-manifest.json");
   let manifest;
   try {
     manifest = JSON.parse(readFileSync47(manifestPath, "utf8"));
@@ -118313,7 +118640,7 @@ function planStationHydration(stationId, repoRoot) {
   const hashMismatches = [];
   const skippedByRule = [];
   for (const agent of SYNC_AGENTS) {
-    const agentRoot = join69(snapshotRoot, "agent-homes", agent);
+    const agentRoot = join70(snapshotRoot, "agent-homes", agent);
     let identEntries;
     try {
       identEntries = readdirSync25(agentRoot, { withFileTypes: true });
@@ -118324,7 +118651,7 @@ function planStationHydration(stationId, repoRoot) {
       if (!identEntry.isDirectory() || identEntry.name.startsWith(".")) {
         continue;
       }
-      const identRoot = join69(agentRoot, identEntry.name);
+      const identRoot = join70(agentRoot, identEntry.name);
       const entries = walkEntries(identRoot);
       for (const entry of entries) {
         const relativeParts = [identEntry.name, ...entry.relativePath.split(sep17)];
@@ -118371,7 +118698,7 @@ function planStationHydration(stationId, repoRoot) {
           });
           continue;
         }
-        const info = statSync23(entry.fullPath);
+        const info = statSync24(entry.fullPath);
         const manifestHash = manifestHashes.get(`${agent}${MANIFEST_HASH_KEY_SEP}${homeRelative}`) ?? null;
         let verified = false;
         if (manifestHash !== null) {
@@ -118475,8 +118802,8 @@ function skillSha256(skill) {
 `)).digest("hex");
 }
 function writeStationHydration(options) {
-  const repoRoot = resolve36(options.repoRoot ?? process.cwd());
-  const cacheRoot = resolve36(options.cacheRoot ?? resolveCorpusRoot());
+  const repoRoot = resolve37(options.repoRoot ?? process.cwd());
+  const cacheRoot = resolve37(options.cacheRoot ?? resolveCorpusRoot());
   const plan = planStationHydration(options.stationId, repoRoot);
   const resultSkills = plan.winners.map((skill) => ({
     ident: skill.ident,
@@ -118509,7 +118836,7 @@ function writeStationHydration(options) {
   const toWrite = [];
   for (const skill of plan.winners) {
     for (const file2 of skill.files) {
-      const destination = join69(cacheRoot, skill.ident, file2.withinIdent);
+      const destination = join70(cacheRoot, skill.ident, file2.withinIdent);
       const digest4 = sha256File(file2.winner.fullPath);
       let existingDigest = null;
       try {
@@ -118530,7 +118857,7 @@ function writeStationHydration(options) {
   }
   let written = 0;
   for (const entry of toWrite) {
-    mkdirSync29(dirname41(entry.destination), { recursive: true });
+    mkdirSync29(dirname42(entry.destination), { recursive: true });
     copyFileSync3(entry.fullPath, entry.destination);
     written += 1;
   }
@@ -118551,8 +118878,8 @@ function writeStationHydration(options) {
     },
     skills: resultSkills
   };
-  const hydrationManifestPath = join69(dirname41(cacheRoot), `hydration-${options.stationId}.json`);
-  mkdirSync29(dirname41(hydrationManifestPath), { recursive: true });
+  const hydrationManifestPath = join70(dirname42(cacheRoot), `hydration-${options.stationId}.json`);
+  mkdirSync29(dirname42(hydrationManifestPath), { recursive: true });
   writeFileSync30(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
 `);
   return {
@@ -118629,14 +118956,14 @@ var init_hydrate = __esm(() => {
 
 // src/lib/prepare-skill.ts
 import { createHash as createHash44, randomUUID as randomUUID13 } from "crypto";
-import { chmodSync as chmodSync5, existsSync as existsSync37, lstatSync as lstatSync41, mkdirSync as mkdirSync30, mkdtempSync as mkdtempSync6, readFileSync as readFileSync48, readdirSync as readdirSync26, renameSync as renameSync15, rmSync as rmSync9, writeFileSync as writeFileSync31 } from "fs";
+import { chmodSync as chmodSync5, existsSync as existsSync37, lstatSync as lstatSync42, mkdirSync as mkdirSync30, mkdtempSync as mkdtempSync6, readFileSync as readFileSync48, readdirSync as readdirSync26, renameSync as renameSync15, rmSync as rmSync9, writeFileSync as writeFileSync31 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname42, isAbsolute as isAbsolute39, join as join70, relative as relative13, resolve as resolve37, sep as sep18 } from "path";
+import { dirname as dirname43, isAbsolute as isAbsolute40, join as join71, relative as relative13, resolve as resolve38, sep as sep18 } from "path";
 function prepareSkill(name, options) {
   const normalized = normalizePortableSkillName(name);
   if (!new RegExp(SEMVER_PATTERN).test(options.version))
     throw new Error("--version must be a semantic version, for example 0.2.0.");
-  const path = join70(getPortableSkillsRootReadOnly(options), normalized);
+  const path = join71(getPortableSkillsRootReadOnly(options), normalized);
   assertPortableAuthoringPath(path, options);
   const before2 = snapshot2(path);
   const manifestFile = before2.files.find((file2) => file2.path === "skill.json");
@@ -118671,16 +118998,16 @@ function prepareSkill(name, options) {
     throw new Error("skill.json provenance must be an object.");
   const provenance = manifest.provenance;
   const candidate2 = { ...manifest, version: options.version, kind, provenance: { ...provenance } };
-  const staging = mkdtempSync6(join70(tmpdir2(), "skills-prepare-"));
+  const staging = mkdtempSync6(join71(tmpdir2(), "skills-prepare-"));
   try {
     for (const directory2 of before2.directories)
-      mkdirSync30(join70(staging, directory2), { recursive: true });
+      mkdirSync30(join71(staging, directory2), { recursive: true });
     for (const file2 of before2.files) {
-      const destination = join70(staging, file2.path);
-      mkdirSync30(dirname42(destination), { recursive: true });
+      const destination = join71(staging, file2.path);
+      mkdirSync30(dirname43(destination), { recursive: true });
       writeFileSync31(destination, file2.bytes, { mode: file2.mode });
     }
-    const stagedManifest = join70(staging, "skill.json");
+    const stagedManifest = join71(staging, "skill.json");
     writeFileSync31(stagedManifest, `${JSON.stringify(candidate2, null, 2)}
 `);
     const contentHash = computeContentHash(staging);
@@ -118703,11 +119030,11 @@ ${validation.issues.map((issue2) => `${issue2.code}: ${issue2.message}`).join(`
     if (snapshot2(path).identity !== before2.identity)
       throw new Error("Skill changed during preparation; review the draft and run prepare again.");
     if (changed3 && !options.dryRun) {
-      const temporary = join70(path, `.skill-prepare-${randomUUID13()}.tmp`);
+      const temporary = join71(path, `.skill-prepare-${randomUUID13()}.tmp`);
       try {
         writeFileSync31(temporary, candidateBytes, { flag: "wx", mode: manifestFile.mode });
         chmodSync5(temporary, manifestFile.mode);
-        renameSync15(temporary, join70(path, "skill.json"));
+        renameSync15(temporary, join71(path, "skill.json"));
       } finally {
         rmSync9(temporary, { force: true });
       }
@@ -118737,8 +119064,8 @@ function validateRuntimeEntrypoint(candidate2, root2) {
   const entry = candidate2.runtime.entrypoint;
   if (typeof entry !== "string")
     return;
-  const target = resolve37(root2, entry), rel = relative13(root2, target);
-  if (isAbsolute39(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep18}`) || isAbsolute39(rel) || !existsSync37(target) || !lstatSync41(target).isFile()) {
+  const target = resolve38(root2, entry), rel = relative13(root2, target);
+  if (isAbsolute40(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep18}`) || isAbsolute40(rel) || !existsSync37(target) || !lstatSync42(target).isFile()) {
     throw new Error("Executable runtime.entrypoint must name an existing regular file inside the skill directory.");
   }
 }
@@ -118823,20 +119150,20 @@ function compareVersions(left, right) {
   return 0;
 }
 function snapshot2(root2) {
-  const rootStat = lstatSync41(root2);
+  const rootStat = lstatSync42(root2);
   if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
     throw new Error("Skill root must be a real directory, not a symlink.");
   const files = [], directories = [];
   const hash6 = createHash44("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
   let count = 0, bytes = 0;
   const walk2 = (relative14) => {
-    for (const name of readdirSync26(join70(root2, relative14)).sort()) {
+    for (const name of readdirSync26(join71(root2, relative14)).sort()) {
       if (IGNORED.has(name.toLowerCase()) || !relative14 && ROOT_IGNORED.has(name.toLowerCase()))
         continue;
       const path = relative14 ? `${relative14}/${name}` : name;
       if (++count > 20000)
         throw new Error("Skill exceeds the preparation entry limit (20000).");
-      const absolute = join70(root2, path), stat3 = lstatSync41(absolute);
+      const absolute = join71(root2, path), stat3 = lstatSync42(absolute);
       if (stat3.isSymbolicLink())
         throw new Error(`Skill contains a symlink: ${path}. No files were changed.`);
       if (stat3.isDirectory() && name === "node_modules")
@@ -119252,7 +119579,7 @@ var init_schedule = __esm(() => {
 
 // src/lib/registry-sync.ts
 import { mkdirSync as mkdirSync31, writeFileSync as writeFileSync32 } from "fs";
-import { dirname as dirname43, relative as relative14 } from "path";
+import { dirname as dirname44, relative as relative14 } from "path";
 function createRegistrySyncArtifact(options = {}) {
   const profile = options.profile ?? "all";
   const includeDocs = options.includeDocs ?? true;
@@ -119309,7 +119636,7 @@ function createRegistrySyncArtifact(options = {}) {
   };
 }
 function writeRegistrySyncArtifact(path, artifact) {
-  mkdirSync31(dirname43(path), { recursive: true });
+  mkdirSync31(dirname44(path), { recursive: true });
   writeFileSync32(path, `${JSON.stringify(artifact, null, 2)}
 `);
 }
@@ -119329,8 +119656,8 @@ var init_registry_sync = __esm(() => {
 });
 
 // src/lib/review-export.ts
-import { constants as constants27, closeSync as closeSync29, existsSync as existsSync38, fstatSync as fstatSync29, fsyncSync as fsyncSync9, lstatSync as lstatSync42, openSync as openSync29, realpathSync as realpathSync23, statSync as statSync24, writeFileSync as writeFileSync33 } from "fs";
-import { basename as basename20, dirname as dirname44, isAbsolute as isAbsolute40, join as join71, parse as parse13, resolve as resolve38, sep as sep19 } from "path";
+import { constants as constants28, closeSync as closeSync29, existsSync as existsSync38, fstatSync as fstatSync29, fsyncSync as fsyncSync9, lstatSync as lstatSync43, openSync as openSync29, realpathSync as realpathSync23, statSync as statSync25, writeFileSync as writeFileSync33 } from "fs";
+import { basename as basename20, dirname as dirname45, isAbsolute as isAbsolute41, join as join72, parse as parse13, resolve as resolve39, sep as sep19 } from "path";
 function exactVersion(spec) {
   const at2 = spec.indexOf("@");
   const slug2 = spec.slice(0, at2);
@@ -119341,14 +119668,14 @@ function exactVersion(spec) {
   return { slug: slug2, version: version2 };
 }
 function assertPrivateDestination(output2) {
-  if (!isAbsolute40(output2) || resolve38(output2) !== output2 || !basename20(output2).endsWith(".tar.gz")) {
+  if (!isAbsolute41(output2) || resolve39(output2) !== output2 || !basename20(output2).endsWith(".tar.gz")) {
     throw new Error("Review output must be an absolute, normalized .tar.gz path.");
   }
-  const parent = dirname44(output2);
-  if (realpathSync23(parent) !== parent || lstatSync42(parent).isSymbolicLink()) {
+  const parent = dirname45(output2);
+  if (realpathSync23(parent) !== parent || lstatSync43(parent).isSymbolicLink()) {
     throw new Error("Review output parent must be a real directory, not a symlink.");
   }
-  const parentStat = statSync24(parent);
+  const parentStat = statSync25(parent);
   if (!parentStat.isDirectory() || (parentStat.mode & 63) !== 0 || process.getuid && parentStat.uid !== process.getuid()) {
     throw new Error("Review output parent must be an owner-only directory (mode 0700).");
   }
@@ -119356,8 +119683,8 @@ function assertPrivateDestination(output2) {
   if (segments.some((segment) => NATIVE_CONTAINERS.has(segment)) || segments.some((segment, index) => segment === ".config" && segments[index + 1] === "opencode") || segments.some((segment, index) => segment === ".hasna" && segments[index + 1] === "skills")) {
     throw new Error("Review output cannot be placed in agent-native discovery or Skills installation paths.");
   }
-  for (let current = parent;; current = dirname44(current)) {
-    if (existsSync38(join71(current, ".git"))) {
+  for (let current = parent;; current = dirname45(current)) {
+    if (existsSync38(join72(current, ".git"))) {
       throw new Error("Review output cannot be placed inside a Git worktree.");
     }
     if (current === parse13(current).root)
@@ -119393,7 +119720,7 @@ async function exportSkillVersionForReview(spec, output2, client2) {
   if (bytes.byteLength !== metadata2.bundleByteSize || sha256Hex(bytes) !== metadata2.bundleSha256.toLowerCase()) {
     throw new Error("Published bundle bytes do not match the exact version metadata.");
   }
-  const fd = openSync29(target, constants27.O_WRONLY | constants27.O_CREAT | constants27.O_EXCL | constants27.O_NOFOLLOW, 384);
+  const fd = openSync29(target, constants28.O_WRONLY | constants28.O_CREAT | constants28.O_EXCL | constants28.O_NOFOLLOW, 384);
   try {
     writeFileSync33(fd, bytes);
     fsyncSync9(fd);
@@ -119433,12 +119760,12 @@ function registerRegistry(parent) {
 async function writeJson2(value, space) {
   const text4 = `${JSON.stringify(value, null, space)}
 `;
-  await new Promise((resolve39, reject2) => {
+  await new Promise((resolve40, reject2) => {
     process.stdout.write(text4, (error61) => {
       if (error61)
         reject2(error61);
       else
-        resolve39();
+        resolve40();
     });
   });
 }
@@ -119644,7 +119971,7 @@ __export(exports_publish, {
 import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync39, readFileSync as readFileSync49 } from "fs";
 import { hostname as hostname5 } from "os";
-import { join as join72 } from "path";
+import { join as join73 } from "path";
 function registerPublish(parent) {
   parent.command("push").argument("<name>", "Name of a skill in the local corpus (~/.hasna/skills/installed or the migrated ~/.hasna/skills/skills)").option("--version <version>", "Override the version recorded on the instance").option("--force-new-version", "If name@version already exists with different content, publish as the next patch version", false).option("--dry-run", "Pack and validate without uploading", false).option("--json", "Output result as JSON", false).description("Publish a local skill to the configured skills instance").action(async (name, options) => {
     try {
@@ -119696,7 +120023,7 @@ async function pushSkill(name, options = {}) {
   const packed = packSkillBundle(skill.path, { maxUnpackedBytes: MAX_UNPACKED_BYTES });
   await verifyPackedCanonicalHash(skill.name, packed);
   const versionManifest = buildVersionManifest(skill.path, packed);
-  const skillMdPath = join72(skill.path, "SKILL.md");
+  const skillMdPath = join73(skill.path, "SKILL.md");
   const skillMd = existsSync39(skillMdPath) ? readFileSync49(skillMdPath, "utf-8") : undefined;
   const base3 = {
     slug: skill.name,
@@ -119935,7 +120262,7 @@ var exports_private_publications = {};
 __export(exports_private_publications, {
   registerPrivatePublications: () => registerPrivatePublications
 });
-import { resolve as resolve39 } from "path";
+import { resolve as resolve40 } from "path";
 function verifyOptions(options, action) {
   if (options.userId === undefined !== (options.membershipId === undefined) || options.userId !== undefined && (!publicationUuid(options.userId) || !publicationUuid(options.membershipId)))
     throw new PrivatePublicationError("PUBLICATION_CONTEXT_REQUIRED", "Provide both observed --user-id and --membership-id UUIDs.");
@@ -119980,9 +120307,9 @@ function registerPrivatePublications(parent) {
         if (code2 === null)
           return;
         const context2 = options.userId ? { userId: options.userId, membershipId: options.membershipId } : undefined;
-        const client2 = await privatePublicationSession(options.email, code2, context2), directory2 = resolve39(options.recoveryDir);
+        const client2 = await privatePublicationSession(options.email, code2, context2), directory2 = resolve40(options.recoveryDir);
         if (action === "publish")
-          await preparePrivatePublication(client2, resolve39(args2[0]), directory2, { skillId: options.skillId, expectedCurrentVersionId: options.expectedCurrentVersion ?? null, idempotencyKey: options.idempotencyKey });
+          await preparePrivatePublication(client2, resolve40(args2[0]), directory2, { skillId: options.skillId, expectedCurrentVersionId: options.expectedCurrentVersion ?? null, idempotencyKey: options.idempotencyKey });
         const result2 = action === "publish" || action === "resume" ? await continuePrivatePublication(client2, directory2, { confirm: true, waitMs: Number(options.waitSeconds) * 1000 }) : await inspectPrivatePublication(client2, directory2, action === "cancel");
         print2(result2, options.json);
       } catch (error61) {
@@ -120084,7 +120411,7 @@ __export(exports_auth, {
 import { createInterface as createInterface3 } from "readline";
 function prompt(question) {
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve40) => {
+  return new Promise((resolve41) => {
     let settled = false;
     const finish = (answer) => {
       if (settled)
@@ -120093,7 +120420,7 @@ function prompt(question) {
       rl.close();
       if (answer === null)
         process.exitCode = 130;
-      resolve40(answer);
+      resolve41(answer);
     };
     rl.once("SIGINT", () => finish(null));
     rl.once("close", () => finish(null));
@@ -120271,7 +120598,7 @@ Skipped. Run it any time: skills setup agents`));
 function promptHidden(question) {
   const stdin = process.stdin;
   process.stdout.write(question);
-  return new Promise((resolve40) => {
+  return new Promise((resolve41) => {
     let value = "";
     const done = (answer) => {
       stdin.off("data", onData);
@@ -120281,7 +120608,7 @@ function promptHidden(question) {
 `);
       if (answer === null)
         process.exitCode = 130;
-      resolve40(answer);
+      resolve41(answer);
     };
     const onData = (chunk2) => {
       for (const character of chunk2.toString()) {
@@ -120837,7 +121164,7 @@ function promptInvitationProof(kind) {
   const label = kind === "token" ? "invitation token" : "recovery code";
   const character = kind === "token" ? /^[A-Za-z0-9_-]$/ : /^\d$/;
   const { stdin, stderr: output2 } = process, wasRaw = stdin.isRaw, wasFlowing = stdin.readableFlowing;
-  return new Promise((resolve40) => {
+  return new Promise((resolve41) => {
     let value = "", settled = false, overflow = false;
     const finish = (answer) => {
       if (settled)
@@ -120854,7 +121181,7 @@ function promptInvitationProof(kind) {
 `);
       if (answer === null)
         process.exitCode = 130;
-      resolve40(answer);
+      resolve41(answer);
     };
     const cancel = () => finish(null);
     const keypress = (text4, key) => {
@@ -121426,11 +121753,11 @@ var init_storage2 = __esm(() => {
 });
 
 // src/lib/registry-reconcile.ts
-import { existsSync as existsSync40, readFileSync as readFileSync50, statSync as statSync25, writeFileSync as writeFileSync34 } from "fs";
-import { join as join73 } from "path";
+import { existsSync as existsSync40, readFileSync as readFileSync50, statSync as statSync26, writeFileSync as writeFileSync34 } from "fs";
+import { join as join74 } from "path";
 function isDirectory2(path) {
   try {
-    return statSync25(path).isDirectory();
+    return statSync26(path).isDirectory();
   } catch {
     return false;
   }
@@ -121438,11 +121765,11 @@ function isDirectory2(path) {
 function migrationNeeded(options) {
   if (options.rootDir)
     return false;
-  const appDir = options.homeDir ? join73(options.homeDir, ".hasna", "skills") : getDataDir();
-  return !(isOwnerLayoutMigrated(appDir) && isDirectory2(join73(appDir, SKILLS_CACHE_DIRNAME)));
+  const appDir = options.homeDir ? join74(options.homeDir, ".hasna", "skills") : getDataDir();
+  return !(isOwnerLayoutMigrated(appDir) && isDirectory2(join74(appDir, SKILLS_CACHE_DIRNAME)));
 }
 function readBaseline(skillDir) {
-  const markerPath = join73(skillDir, PULL_MARKER_FILE);
+  const markerPath = join74(skillDir, PULL_MARKER_FILE);
   if (!existsSync40(markerPath))
     return;
   try {
@@ -121458,7 +121785,7 @@ function readBaseline(skillDir) {
   }
 }
 function readCursor(root2) {
-  const path = join73(root2, SYNC_CURSOR_FILE);
+  const path = join74(root2, SYNC_CURSOR_FILE);
   if (!existsSync40(path))
     return { runCount: 0 };
   try {
@@ -121471,12 +121798,12 @@ function readCursor(root2) {
 function resolveCorpusRootReadOnly(options) {
   if (options.rootDir)
     return { root: options.rootDir, migrationPending: false };
-  const appDir = options.homeDir ? join73(options.homeDir, ".hasna", "skills") : getDataDirReadOnly();
-  const cache3 = join73(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join74(options.homeDir, ".hasna", "skills") : getDataDirReadOnly();
+  const cache3 = join74(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && isDirectory2(cache3)) {
     return { root: cache3, migrationPending: false };
   }
-  return { root: join73(appDir, INSTALLED_SKILLS_DIRNAME), migrationPending: true };
+  return { root: join74(appDir, INSTALLED_SKILLS_DIRNAME), migrationPending: true };
 }
 function remoteRowToSkill(record12) {
   const slug2 = typeof record12.slug === "string" ? record12.slug : typeof record12.name === "string" ? record12.name : undefined;
@@ -121610,7 +121937,7 @@ async function reconcileRegistry(options = {}) {
   for (const slug2 of allSlugs) {
     const local = locals.get(slug2);
     const remote = remotes.get(slug2);
-    const baseline = local ? readBaseline(join73(root2, slug2)) : undefined;
+    const baseline = local ? readBaseline(join74(root2, slug2)) : undefined;
     const { state, reason: reason2 } = classifySkill(local, remote, baseline);
     let { action, reason: actionReason } = resolveAction(state, direction, conflict);
     if (state === "remote-only" && isDigestless(remote)) {
@@ -121669,7 +121996,7 @@ async function reconcileRegistry(options = {}) {
       try {
         await pushSkill(slug2, { rootDir: root2, client: client2 });
         const pushed = locals.get(slug2);
-        writePullMarker(join73(root2, slug2), {
+        writePullMarker(join74(root2, slug2), {
           skill: slug2,
           ...pushed?.version ? { version: pushed.version } : {},
           ...pushed?.sha256 ? { contentHash: pushed.sha256 } : {},
@@ -121741,7 +122068,7 @@ async function reconcileRegistry(options = {}) {
         runCount: readCursor(root2).runCount + 1,
         summary
       };
-      writeFileSync34(join73(root2, SYNC_CURSOR_FILE), `${JSON.stringify(cursor2, null, 2)}
+      writeFileSync34(join74(root2, SYNC_CURSOR_FILE), `${JSON.stringify(cursor2, null, 2)}
 `);
       return {
         corpusRoot: root2,