@hasna/skills 0.9.10 → 0.9.11

package/bin/index.js

@@ -36868,7 +36868,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.9.10",
+    version: "0.9.11",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -54737,10 +54737,252 @@ var init_claude_settings_witness = __esm(() => {
   ]);
 });
 
-// src/lib/agent-discovery.ts
+// src/lib/codex-hook-trust-files.ts
+import { closeSync as closeSync11, constants as constants11, fstatSync as fstatSync11, fsyncSync as fsyncSync3, lstatSync as lstatSync17, openSync as openSync11, readSync as readSync9, writeFileSync as writeFileSync5 } from "fs";
 import { createHash as createHash13 } from "crypto";
-import { lstatSync as lstatSync17, readFileSync as readFileSync14, readdirSync as readdirSync9, realpathSync as realpathSync4 } from "fs";
-import { basename as basename8, dirname as dirname14, isAbsolute as isAbsolute14, join as join28, resolve as resolve15, sep as sep5 } from "path";
+import { dirname as dirname14 } from "path";
+function need4(value, code) {
+  if (!value)
+    throw new Error(`CODEX_HOOK_TRUST_${code}`);
+}
+function safeParents(file) {
+  for (let p = dirname14(file);; p = dirname14(p)) {
+    const s = lstatSync17(p);
+    need4(s.isDirectory() && !s.isSymbolicLink(), "UNSAFE_PARENT");
+    need4((s.mode & 18) === 0 || s.uid === 0 && (s.mode & 512) !== 0, "UNSAFE_PARENT");
+    if (dirname14(p) === p)
+      break;
+  }
+}
+function snapshot(file, privateFile = false, options = {}) {
+  const readOnlyPackage = options.readOnlyPackage === true && !privateFile;
+  safeParents(file);
+  const initial2 = lstatSync17(file, { bigint: true });
+  need4(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");
+  need4(initial2.size <= 8n * 1024n * 1024n, "FILE_BOUND");
+  const fd = openSync11(file, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
+  try {
+    const before2 = fstatSync11(fd, { bigint: true });
+    need4(sameStat(initial2, before2), "INPUT_CHANGED");
+    const bytes = Buffer.alloc(Number(before2.size) + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const n2 = readSync9(fd, bytes, length, bytes.length - length, null);
+      if (!n2)
+        break;
+      length += n2;
+    }
+    need4(length === Number(before2.size) && sameStat(before2, fstatSync11(fd, { bigint: true })) && sameStat(before2, lstatSync17(file, { bigint: true })), "INPUT_CHANGED");
+    const content = bytes.subarray(0, length), text2 = new TextDecoder("utf-8", { fatal: true }).decode(content);
+    return { file, privateFile, readOnlyPackage, text: text2, bytes: content, stat: before2, sha256: createHash13("sha256").update(content).digest("hex") };
+  } finally {
+    closeSync11(fd);
+  }
+}
+function unchanged2(before2) {
+  const after2 = snapshot(before2.file, before2.privateFile, before2.readOnlyPackage ? { readOnlyPackage: true } : {});
+  need4(sameStat(before2.stat, after2.stat) && after2.sha256 === before2.sha256, "INPUT_CHANGED");
+}
+function save(file, content) {
+  safeParents(file);
+  const fd = openSync11(file, constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW, 384);
+  try {
+    writeFileSync5(fd, content);
+    fsyncSync3(fd);
+  } finally {
+    closeSync11(fd);
+  }
+}
+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/lib/codex-hook-trust-layout.ts
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
+function codexTrustTextWitness(text2, keys2, canonicalize = true) {
+  const parsed = Bun.TOML.parse(text2), wanted = new Set(keys2);
+  const headers = [...text2.matchAll(/^[ \t]*(\[[^\r\n]+\])[ \t]*(#[^\r\n]*)?(?:\r?\n|$)/gm)];
+  if (headers.length > 512)
+    throw fail2();
+  let root2 = parsed;
+  for (const header of headers) {
+    try {
+      root2 = Bun.TOML.parse(text2.slice(0, header.index));
+      break;
+    } catch {}
+  }
+  if (root2.hooks !== undefined)
+    throw fail2();
+  const replacements2 = [];
+  const stateSections = [];
+  for (const [index, header] of headers.entries()) {
+    let shape;
+    try {
+      shape = Bun.TOML.parse(header[1]);
+    } catch {
+      continue;
+    }
+    const state = shape.hooks?.state;
+    if (!state || Object.keys(shape).length !== 1 || Object.keys(shape.hooks).length !== 1)
+      continue;
+    const names = Object.keys(state), start = header.index, end = headers[index + 1]?.index ?? text2.length;
+    if (names.length === 0) {
+      replacements2.push({ start, end: start + header[0].length, comments: header[2] ? header[2] + `
+` : "" });
+      stateSections.push({ start, end: start + header[0].length });
+    } else if (names.length === 1 && !Object.keys(state[names[0]]).length) {
+      stateSections.push({ start, end });
+      if (!wanted.has(names[0])) {
+        replacements2.push({ start, end: start + header[0].length, comments: `[hooks.state.${JSON.stringify(names[0])}]${header[2] ? " " + header[2] : ""}
+` });
+        continue;
+      }
+      const comments = header[2] ? [header[2]] : [];
+      for (const line of text2.slice(start + header[0].length, end).split(/\r?\n/)) {
+        if (!line.trim())
+          continue;
+        if (/^[ \t]*#/.test(line)) {
+          comments.push(line);
+          continue;
+        }
+        const field2 = /^[ \t]*(?:enabled|trusted_hash)[ \t]*=[ \t]*(?:true|false|"(?:[^"\\]|\\.)*"|'[^']*')[ \t]*(#[^\r\n]*)?$/.exec(line);
+        if (!field2)
+          throw fail2();
+        if (field2[1])
+          comments.push(field2[1]);
+      }
+      replacements2.push({ start, end, comments: comments.join(`
+`) + `
+` });
+    }
+  }
+  let noState = text2;
+  for (const span of [...stateSections].reverse())
+    noState = noState.slice(0, span.start) + noState.slice(span.end);
+  const expected = structuredClone(parsed);
+  if (expected.hooks)
+    delete expected.hooks.state;
+  try {
+    if (!isDeepStrictEqual3(prune(Bun.TOML.parse(noState)), prune(expected)))
+      throw fail2();
+  } catch {
+    throw fail2();
+  }
+  let result2 = text2;
+  for (const span of replacements2.reverse())
+    result2 = result2.slice(0, span.start) + span.comments + result2.slice(span.end);
+  return (canonicalize ? canonicalizeTableOrder(result2) : result2).split(/\r?\n/).filter((line) => line.trim()).join(`
+`);
+}
+function codexTrustReconcileWitness(text2, keys2) {
+  return codexTrustTextWitness(text2, keys2, false).replace(/[ \t]+$/gm, "");
+}
+function codexTrustUnmanagedSemantic(text2, keys2) {
+  const parsed = structuredClone(Bun.TOML.parse(text2));
+  for (const key of keys2)
+    if (parsed.hooks?.state?.[key] !== undefined)
+      delete parsed.hooks.state[key];
+  return JSON.stringify(stableSemantic(prune(parsed)));
+}
+var fail2 = () => new Error('CODEX_HOOK_TRUST_UNSUPPORTED_LAYOUT: preserve and convert hook trust to ordinary [hooks.state."<key>"] tables before enrollment'), prune = (value) => {
+  if (value.hooks?.state && !Object.keys(value.hooks.state).length)
+    delete value.hooks.state;
+  if (value.hooks && !Object.keys(value.hooks).length)
+    delete value.hooks;
+  return value;
+}, canonicalizeTableOrder = (text2) => {
+  const headers = [...text2.matchAll(/^[ \t]*(\[\[?[^\r\n]+\]\]?)[ \t]*(#[^\r\n]*)?(?:\r?\n|$)/gm)];
+  if (!headers.length)
+    return text2;
+  const keys2 = headers.map((header) => header[1].trim());
+  const repeated = keys2.filter((key) => !key.startsWith("[[")).filter((key, index, simple2) => simple2.indexOf(key) !== index);
+  const arrayKeys = keys2.filter((key) => key.startsWith("[["));
+  const plain = keys2.map((key) => key.replace(/^\[\[?/, "").replace(/\]\]?$/, "").trim());
+  const parentChild = plain.some((key, index) => plain.some((other, otherIndex) => index !== otherIndex && (other.startsWith(`${key}.`) || key.startsWith(`${other}.`))));
+  if (repeated.length || parentChild)
+    return text2;
+  if (!arrayKeys.length) {
+    const first2 = headers[0].index;
+    const prefix2 = text2.slice(0, first2);
+    const blocks2 = headers.map((header, index) => ({
+      key: header[1],
+      order: index,
+      text: text2.slice(header.index, headers[index + 1]?.index ?? text2.length)
+    }));
+    blocks2.sort((a, b) => a.key.localeCompare(b.key) || a.order - b.order);
+    return prefix2 + blocks2.map((block) => block.text).join("");
+  }
+  const first = headers[0].index;
+  const prefix = text2.slice(0, first);
+  const blocks = headers.map((header, index) => ({
+    key: header[1],
+    order: index,
+    text: text2.slice(header.index, headers[index + 1]?.index ?? text2.length)
+  }));
+  const simple = blocks.filter((block) => !block.key.startsWith("[["));
+  const arrays = blocks.filter((block) => block.key.startsWith("[["));
+  return prefix + [...simple, ...arrays].map((block) => block.text).join("");
+}, stableSemantic = (value) => {
+  if (Array.isArray(value))
+    return value.map(stableSemantic);
+  if (value && typeof value === "object")
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stableSemantic(value[key])]));
+  return value;
+};
+var init_codex_hook_trust_layout = () => {};
+
+// src/lib/codex-hook-discovery-recovery.ts
+import { createHash as createHash14 } from "crypto";
+import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
+function createCodexHookDiscoveryRecovery(binding, before2, current, hooks) {
+  const raw = binding.sources.filter((source) => source.path === current.file && source.hashMode === "bytes");
+  if (!raw.some((source) => source.sha256 !== current.sha256))
+    return;
+  need4(binding.agent === "codex" && binding.method === "reviewed" && raw.length === 1 && raw[0].sha256 === before2.sha256 && before2.sha256 !== current.sha256, "RECONCILE_DISCOVERY_CONFIG_WITNESS");
+  need4(raw[0].format === undefined && raw[0].fields === undefined && raw[0].managedPlugins === undefined, "RECONCILE_DISCOVERY_CONFIG_WITNESS");
+  const typed = binding.sources.filter((source) => source.path === current.file && source.format === "toml");
+  need4(typed.length === 1 && typed[0].hashMode === undefined && isDeepStrictEqual4(typed[0].fields, fields), "RECONCILE_DISCOVERY_TYPED_WITNESS");
+  const original = structure(before2.text), actual = structure(current.text);
+  const project = (value) => Object.fromEntries(fields.map((field2) => [field2, value[field2] ?? null]));
+  const projection = sha(JSON.stringify(project(original)));
+  need4(typed[0].sha256 === projection && sha(JSON.stringify(project(actual))) === projection && isDeepStrictEqual4(project(original), project(actual)), "RECONCILE_DISCOVERY_TYPED_WITNESS");
+  need4(hooks.length > 0 && hooks.length <= 100 && new Set(hooks.map((hook) => hook.key)).size === hooks.length && hooks.every((hook) => typeof hook.key === "string" && /^sha256:[a-f0-9]{64}$/.test(hook.currentHash)), "RECONCILE_DISCOVERY_TRUST_WITNESS");
+  const keys2 = hooks.map((hook) => hook.key), expected = structuredClone(original);
+  expected.hooks ??= {};
+  expected.hooks.state ??= {};
+  for (const hook of hooks)
+    expected.hooks.state[hook.key] = { ...expected.hooks.state[hook.key], enabled: true, trusted_hash: hook.currentHash };
+  need4(isDeepStrictEqual4(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: sha(JSON.stringify(binding)), typedProjectionSha256: projection });
+  proofs.set(witness, { before: before2, current });
+  return witness;
+}
+function assertCodexHookDiscoveryRecovery(binding, witness) {
+  const proof = proofs.get(witness);
+  need4(!!proof && binding.agent === "codex" && witness.discoverySha256 === sha(JSON.stringify(binding)), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
+  unchanged2(proof.before);
+  unchanged2(proof.current);
+}
+function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witness) {
+  if (!witness || source.path !== witness.configPath || source.hashMode !== "bytes")
+    return false;
+  assertCodexHookDiscoveryRecovery(binding, witness);
+  need4(source.sha256 === witness.beforeSha256 && currentDigest === witness.currentSha256, "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
+  return true;
+}
+var sha = (text2) => createHash14("sha256").update(text2).digest("hex"), fields, structure = (text2) => JSON.parse(JSON.stringify(Bun.TOML.parse(text2))), proofs;
+var init_codex_hook_discovery_recovery = __esm(() => {
+  init_codex_hook_trust_files();
+  init_codex_hook_trust_layout();
+  fields = ["plugins", "marketplaces", "skills"];
+  proofs = new WeakMap;
+});
+
+// src/lib/agent-discovery.ts
+import { createHash as createHash15 } from "crypto";
+import { lstatSync as lstatSync18, readFileSync as readFileSync14, readdirSync as readdirSync9, realpathSync as realpathSync4 } from "fs";
+import { basename as basename8, dirname as dirname15, isAbsolute as isAbsolute14, join as join28, resolve as resolve15, sep as sep5 } from "path";
 function parseConfig(text2, path, toml = false) {
   try {
     const value = toml ? Bun.TOML.parse(text2) : JSON.parse(text2);
@@ -54754,10 +54996,10 @@ function parseConfig(text2, path, toml = false) {
 function safe4(path) {
   if (!isAbsolute14(path) || path.includes("\x00"))
     throw new Error("Expected an absolute native discovery path");
-  for (let cursor = path;; cursor = dirname14(cursor)) {
-    if (lstatSync17(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+  for (let cursor = path;; cursor = dirname15(cursor)) {
+    if (lstatSync18(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink native discovery input: ${cursor}`);
-    if (dirname14(cursor) === cursor)
+    if (dirname15(cursor) === cursor)
       break;
   }
 }
@@ -54765,7 +55007,7 @@ function read2(path, changes) {
   safe4(path);
   if (changes?.has(path))
     return changes.get(path);
-  const stat2 = lstatSync17(path, { throwIfNoEntry: false });
+  const stat2 = lstatSync18(path, { throwIfNoEntry: false });
   if (!stat2)
     return null;
   if (!stat2.isFile() || stat2.size > 16 * 1024 * 1024)
@@ -54815,7 +55057,9 @@ function projected(source, changes, budget = discoveryByteBudget()) {
     throw new Error("Expected native discovery configuration object");
   return digest(JSON.stringify(Object.fromEntries((source.fields ?? []).map((field2) => [field2, object4[field2] ?? null]))));
 }
-function verifyAgentDiscovery(binding) {
+function verifyAgentDiscovery(binding, codexRecovery) {
+  if (codexRecovery)
+    assertCodexHookDiscoveryRecovery(binding, codexRecovery);
   if (!binding || !Array.isArray(binding.sources) || !Array.isArray(binding.roots) || binding.sources.length > AGENT_POLICY_LIMITS.discoverySources || binding.roots.length > AGENT_POLICY_LIMITS.discoveryRoots)
     throw new Error("Invalid native discovery binding");
   if (binding.agent === "hermes" && !binding.directories?.length)
@@ -54831,7 +55075,8 @@ function verifyAgentDiscovery(binding) {
       throw new Error("Invalid native discovery projection");
     if (source.sha256 !== null && !/^[a-f0-9]{64}$/.test(source.sha256))
       throw new Error("Invalid native discovery digest");
-    if (projected(source, undefined, budget) !== source.sha256)
+    const current = projected(source, undefined, budget);
+    if (current !== source.sha256 && !verifiesCodexHookDiscoverySource(binding, source, current, codexRecovery))
       throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
   }
   for (const root2 of binding.roots)
@@ -54883,7 +55128,7 @@ function assertProjectDiscovery(agent, directories, home, canonical4 = resolve15
     if (agent === "claude") {
       const commands = canonical4(join28(directory, ".claude/commands"));
       safe4(commands);
-      if (lstatSync17(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length)
+      if (lstatSync18(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length)
         throw new Error("NATIVE_SKILL_DRIFT: legacy project command discovery requires a dedicated format adapter");
     }
   }
@@ -54891,8 +55136,8 @@ function assertProjectDiscovery(agent, directories, home, canonical4 = resolve15
 function resolveAgentDiscovery(options) {
   const canonical4 = options.canonical ?? resolve15, home = resolve15(options.home), agent = options.agent;
   const sources = [], roots = new Set, builtinNames = [];
-  const witness = (path, format, fields) => {
-    const source = { path: canonical4(path), sha256: null, ...format ? { format, fields } : {} };
+  const witness = (path, format, fields2) => {
+    const source = { path: canonical4(path), sha256: null, ...format ? { format, fields: fields2 } : {} };
     source.sha256 = projected(source);
     sources.push(source);
     return read2(source.path);
@@ -54929,21 +55174,21 @@ function resolveAgentDiscovery(options) {
     const executable = Bun.which("gemini");
     if (executable) {
       let packageRoot;
-      for (let directory = dirname14(realpathSync4(executable)), depth = 0;depth < 8; directory = dirname14(directory), depth++) {
+      for (let directory = dirname15(realpathSync4(executable)), depth = 0;depth < 8; directory = dirname15(directory), depth++) {
         const path = join28(directory, "package.json"), raw = read2(path);
         if (raw !== null && parseConfig(raw, path).name === "@google/gemini-cli") {
           packageRoot = directory;
           witness(path);
           break;
         }
-        if (dirname14(directory) === directory)
+        if (dirname15(directory) === directory)
           break;
       }
       if (!packageRoot)
         unresolved("installed Gemini package layout is not recognized");
       const builtinRoot = join28(packageRoot, "bundle/builtin");
       safe4(builtinRoot);
-      if (!lstatSync17(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
+      if (!lstatSync18(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
         unresolved("installed Gemini builtin root is missing");
       for (const name of readdirSync9(builtinRoot).sort()) {
         const text2 = witness(join28(builtinRoot, name, "SKILL.md"));
@@ -54983,7 +55228,7 @@ function resolveAgentDiscovery(options) {
       unresolved("plugin hooks require a separate no-skill-injection review");
     const commands = join28(root2, "commands");
     safe4(commands);
-    if (agent === "claude" && (manifest.commands !== undefined || lstatSync17(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length))
+    if (agent === "claude" && (manifest.commands !== undefined || lstatSync18(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length))
       unresolved("legacy command discovery requires retirement or a dedicated format adapter");
     const rootSkill = witness(join28(root2, "SKILL.md"));
     if (rootSkill !== null)
@@ -54997,7 +55242,7 @@ function resolveAgentDiscovery(options) {
       const path = resolve15(root2, value);
       if (path !== root2 && !path.startsWith(root2 + sep5))
         unresolved("plugin skill path escapes its root");
-      roots.add(path.endsWith(`${sep5}SKILL.md`) ? dirname14(path) : path);
+      roots.add(path.endsWith(`${sep5}SKILL.md`) ? dirname15(path) : path);
     }
   }
   if (agent === "claude") {
@@ -55005,7 +55250,7 @@ function resolveAgentDiscovery(options) {
     const installed = registrations === null ? {} : parseConfig(registrations, join28(home, ".claude/plugins/installed_plugins.json")).plugins;
     const commands = canonical4(join28(home, ".claude/commands"));
     safe4(commands);
-    if (lstatSync17(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length)
+    if (lstatSync18(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length)
       unresolved("legacy home command discovery requires a dedicated format adapter");
     for (const [id, enabled] of Object.entries(config.enabledPlugins ?? {})) {
       if (enabled === false)
@@ -55047,12 +55292,12 @@ function resolveAgentDiscovery(options) {
     }
     const localPlugins = join28(home, ".config/opencode/plugins");
     safe4(localPlugins);
-    if (lstatSync17(localPlugins, { throwIfNoEntry: false }) && readdirSync9(localPlugins).some((name) => name !== "skills-cli.js"))
+    if (lstatSync18(localPlugins, { throwIfNoEntry: false }) && readdirSync9(localPlugins).some((name) => name !== "skills-cli.js"))
       unresolved("additional local plugin hooks require review");
   } else if (agent === "hermes") {
     for (const directory of [join28(home, ".hermes/plugins"), join28(home, ".hermes/hermes-agent")]) {
       safe4(directory);
-      if (lstatSync17(directory, { throwIfNoEntry: false }))
+      if (lstatSync18(directory, { throwIfNoEntry: false }))
         unresolved("installed runtime/plugin discovery requires reviewed source bindings");
     }
     if (Bun.which("hermes") || Object.keys(config.plugins ?? {}).length)
@@ -55062,11 +55307,11 @@ function resolveAgentDiscovery(options) {
       unresolved("custom extension or skill paths");
     const directory = join28(home, ".gemini/extensions");
     safe4(directory);
-    if (lstatSync17(directory, { throwIfNoEntry: false }))
+    if (lstatSync18(directory, { throwIfNoEntry: false }))
       for (const name of readdirSync9(directory)) {
         const root2 = join28(directory, name);
         safe4(root2);
-        if (!lstatSync17(root2)?.isDirectory())
+        if (!lstatSync18(root2)?.isDirectory())
           continue;
         const raw = witness(join28(root2, "gemini-extension.json"));
         if (raw === null)
@@ -55079,7 +55324,7 @@ function resolveAgentDiscovery(options) {
   }
   return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join28(home, ".hermes/plugins"), join28(home, ".hermes/hermes-agent")].map((path) => canonical4(path))) } : {} };
 }
-var digest = (text2) => createHash13("sha256").update(text2).digest("hex");
+var digest = (text2) => createHash15("sha256").update(text2).digest("hex");
 var init_agent_discovery = __esm(() => {
   init_agent_policy_limits();
   init_agent_hermes();
@@ -55090,6 +55335,7 @@ var init_agent_discovery = __esm(() => {
   init_plugin_admission();
   init_claude_marketplace_registry();
   init_claude_settings_witness();
+  init_codex_hook_discovery_recovery();
   init_agent_discovery_directories();
 });
 
@@ -55174,7 +55420,7 @@ var init_agent_adapters = __esm(() => {
 });
 
 // src/lib/agent-codex.ts
-import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual5 } from "util";
 function assertCodexPathConfigEditable(text2) {
   const before2 = Bun.TOML.parse(text2);
   if (before2.skills?.config === undefined)
@@ -55183,7 +55429,7 @@ function assertCodexPathConfigEditable(text2) {
   delete expected.skills.config;
   try {
     const withoutSections = Bun.TOML.parse(text2.replace(CODEX_SKILL_CONFIG_SECTIONS, ""));
-    if (isDeepStrictEqual3(withoutSections, expected))
+    if (isDeepStrictEqual5(withoutSections, expected))
       return;
   } catch {}
   throw new Error("Codex skill path controls require ordinary [[skills.config]] TOML tables; preserve and convert inline or dotted config arrays before running skills hook install");
@@ -55221,7 +55467,7 @@ function disableCodexBundledSkills(text2) {
   const candidates = new Set;
   const consider = (candidate2) => {
     try {
-      if (isDeepStrictEqual3(Bun.TOML.parse(candidate2), expected))
+      if (isDeepStrictEqual5(Bun.TOML.parse(candidate2), expected))
         candidates.add(candidate2);
     } catch {}
   };
@@ -55251,16 +55497,16 @@ var init_agent_codex = __esm(() => {
 });
 
 // src/lib/agent-integration.ts
-import { createHash as createHash14, randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync15, lstatSync as lstatSync18, statSync as statSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync15, readdirSync as readdirSync10, opendirSync as opendirSync5, readlinkSync as readlinkSync2, realpathSync as realpathSync5, renameSync as renameSync4, rmdirSync as rmdirSync3, writeFileSync as writeFileSync5, unlinkSync as unlinkSync4, chmodSync, openSync as openSync11, closeSync as closeSync11, fsyncSync as fsyncSync3, fstatSync as fstatSync11, readSync as readSync9, constants as constants11, linkSync as linkSync2 } from "fs";
-import { dirname as dirname15, join as join29, resolve as resolve16, relative as relative5, isAbsolute as isAbsolute15, sep as sep6 } from "path";
+import { createHash as createHash16, randomUUID as randomUUID6 } from "crypto";
+import { existsSync as existsSync15, lstatSync as lstatSync19, statSync as statSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync15, readdirSync as readdirSync10, opendirSync as opendirSync5, readlinkSync as readlinkSync2, realpathSync as realpathSync5, renameSync as renameSync4, rmdirSync as rmdirSync3, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4, chmodSync, openSync as openSync12, closeSync as closeSync12, fsyncSync as fsyncSync4, fstatSync as fstatSync12, readSync as readSync10, constants as constants12, linkSync as linkSync2 } from "fs";
+import { dirname as dirname16, join as join29, resolve as resolve16, relative as relative5, isAbsolute as isAbsolute15, sep as sep6 } from "path";
 import { homedir as homedir4 } from "os";
 function assertSafePath(path) {
   let cursor = resolve16(path);
   while (true) {
-    if (lstatSync18(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync19(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink path: ${cursor}`);
-    const parent = dirname15(cursor);
+    const parent = dirname16(cursor);
     if (parent === cursor)
       return;
     cursor = parent;
@@ -55269,12 +55515,12 @@ function assertSafePath(path) {
 function readRootAlias(home, agent) {
   assertSafePath(home);
   const realHome = realpathSync5(home), alias = join29(realHome, `.${agent}`);
-  const stat2 = lstatSync18(alias, { throwIfNoEntry: false, bigint: true });
+  const stat2 = lstatSync19(alias, { throwIfNoEntry: false, bigint: true });
   if (!stat2?.isSymbolicLink())
     throw new Error(`Agent root alias changed after planning: ${alias}`);
-  const link2 = readlinkSync2(alias), targetPath = resolve16(dirname15(alias), link2);
+  const link2 = readlinkSync2(alias), targetPath = resolve16(dirname16(alias), link2);
   assertSafePath(targetPath);
-  const targetStat = lstatSync18(targetPath, { throwIfNoEntry: false });
+  const targetStat = lstatSync19(targetPath, { throwIfNoEntry: false });
   if (!targetStat?.isDirectory())
     throw new Error(`Agent root alias must target an existing directory: ${alias}`);
   const target = realpathSync5(targetPath), inside = relative5(realHome, target);
@@ -55287,7 +55533,7 @@ function rootAliases(home, allowed = false) {
     return [];
   const result2 = [];
   for (const agent of ["claude", "codex"])
-    if (lstatSync18(join29(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync19(join29(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
       result2.push(readRootAlias(home, agent));
   if (result2.some((item, index) => result2.slice(index + 1).some((other) => item.target === other.target || item.target.startsWith(other.target + sep6) || other.target.startsWith(item.target + sep6))))
     throw new Error("Agent root alias targets must not overlap");
@@ -55308,35 +55554,35 @@ function recheckRootAliases(aliases) {
 }
 function readNativeBytes(path, maximum = 64 * 1024 * 1024) {
   assertSafePath(path);
-  const before2 = lstatSync18(path);
+  const before2 = lstatSync19(path);
   if (!before2.isFile() || before2.size > maximum)
     throw new Error("Unsupported or oversized native skill file");
-  const descriptor = openSync11(path, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
+  const descriptor = openSync12(path, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
   try {
-    const opened = fstatSync11(descriptor);
+    const opened = fstatSync12(descriptor);
     if (!opened.isFile() || opened.dev !== before2.dev || opened.ino !== before2.ino || opened.size !== before2.size)
       throw new Error("Native skill file changed while reading");
     const bytes = Buffer.allocUnsafe(before2.size + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync9(descriptor, bytes, length, bytes.length - length, null);
+      const count = readSync10(descriptor, bytes, length, bytes.length - length, null);
       if (!count)
         break;
       length += count;
     }
-    const after2 = fstatSync11(descriptor);
+    const after2 = fstatSync12(descriptor);
     if (length !== before2.size || after2.size !== before2.size || after2.mtimeMs !== opened.mtimeMs || after2.ctimeMs !== opened.ctimeMs)
       throw new Error("Native skill file changed while reading");
     return bytes.subarray(0, length);
   } finally {
-    closeSync11(descriptor);
+    closeSync12(descriptor);
   }
 }
 function treeHash(root2) {
-  const hash2 = createHash14("sha256");
+  const hash2 = createHash16("sha256");
   let bytes = 0, files = 0;
   function visit2(path) {
-    const stat2 = lstatSync18(path);
+    const stat2 = lstatSync19(path);
     if (stat2.isSymbolicLink())
       throw new Error(`Refusing symlink in skill: ${path}`);
     const rel = relative5(root2, path);
@@ -55360,7 +55606,7 @@ function treeHash(root2) {
   return hash2.digest("hex");
 }
 function parseNativeMigrationTargetManifest(input) {
-  const digest2 = sha(input);
+  const digest2 = sha2(input);
   let value;
   try {
     value = JSON.parse(input.toString());
@@ -55385,7 +55631,7 @@ function parseNativeMigrationTargetManifest(input) {
     if (!INTEGRATION_AGENTS.includes(item.agent))
       throw new Error(`Unsupported native migration target agent: ${item.agent}`);
     const projectRoot = resolve16(item.projectRoot);
-    if (!isAbsolute15(item.projectRoot) || projectRoot !== item.projectRoot || !existsSync15(projectRoot) || !lstatSync18(projectRoot).isDirectory())
+    if (!isAbsolute15(item.projectRoot) || projectRoot !== item.projectRoot || !existsSync15(projectRoot) || !lstatSync19(projectRoot).isDirectory())
       throw new Error(`Native migration target project root must be an existing absolute directory: ${item.projectRoot}`);
     assertSafePath(projectRoot);
     if (isAbsolute15(item.path) || item.path.includes("\\") || item.path.length === 0 || item.path.includes("\x00"))
@@ -55413,7 +55659,7 @@ function selectNativeMigrationTargets(inventory, manifest) {
   const selected = [];
   for (const target of manifest.targets) {
     const projectRoot = resolve16(target.projectRoot), normalized = relative5(projectRoot, resolve16(projectRoot, target.path));
-    if (!isAbsolute15(target.projectRoot) || projectRoot !== target.projectRoot || !existsSync15(projectRoot) || !lstatSync18(projectRoot).isDirectory())
+    if (!isAbsolute15(target.projectRoot) || projectRoot !== target.projectRoot || !existsSync15(projectRoot) || !lstatSync19(projectRoot).isDirectory())
       throw new Error(`Native migration target project root must be an existing absolute directory: ${target.projectRoot}`);
     assertSafePath(projectRoot);
     if (isAbsolute15(target.path) || target.path.includes("\\") || target.path.includes("\x00") || !normalized || normalized === ".." || normalized.startsWith(`..${sep6}`) || normalized !== target.path || !/^[0-9a-f]{64}$/.test(target.treeSha256))
@@ -55442,7 +55688,7 @@ function projectAncestorDirectories(projects) {
       if (depth >= 100)
         throw new Error("NATIVE_SKILL_DRIFT: project ancestor discovery limit exceeded");
       directories.add(path);
-      const parent = dirname15(path);
+      const parent = dirname16(path);
       if (parent === path)
         break;
       path = parent;
@@ -55473,9 +55719,9 @@ function inventoryNativeSkills(home = homedir4(), options = {}) {
   }
   function emptySiblingCacheAlias(path, parent) {
     const link2 = readlinkSync2(path), target = resolve16(parent, link2);
-    if (dirname15(target) !== parent || (isAbsolute15(link2) ? link2 !== target : dirname15(link2) !== "."))
+    if (dirname16(target) !== parent || (isAbsolute15(link2) ? link2 !== target : dirname16(link2) !== "."))
       return false;
-    if (!lstatSync18(target, { throwIfNoEntry: false })?.isDirectory())
+    if (!lstatSync19(target, { throwIfNoEntry: false })?.isDirectory())
       return false;
     const scan = cacheScans.get(target);
     return Boolean(scan?.complete && !scan.hasSkills && scan.entries <= maxAliasProofEntries);
@@ -55487,7 +55733,7 @@ function inventoryNativeSkills(home = homedir4(), options = {}) {
     assertSafePath(path);
     if (!existsSync15(path))
       return scan;
-    const stat2 = lstatSync18(path);
+    const stat2 = lstatSync19(path);
     if (stat2.isFile())
       return scan;
     if (!stat2.isDirectory())
@@ -55533,7 +55779,7 @@ function inventoryNativeSkills(home = homedir4(), options = {}) {
       if (isVendor && !options.includeVendor)
         continue;
       const child = join29(path, name);
-      if (isVendor && lstatSync18(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
+      if (isVendor && lstatSync19(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
         const target = statSync8(child, { throwIfNoEntry: false });
         if (target?.isFile() || pluginCache && target?.isDirectory() && emptySiblingCacheAlias(child, path)) {
           scan.entries++;
@@ -55743,7 +55989,7 @@ function planAgentIntegration(options) {
         throw new Error("Refusing to overwrite an unrecognized Hermes supervisor");
       if (supervisorBefore !== supervisorAfter)
         changes.push({ path: supervisorPath, before: supervisorBefore, after: supervisorAfter });
-      const supervisor = { path: supervisorPath, runtime: process.execPath, sha256: sha(supervisorAfter) };
+      const supervisor = { path: supervisorPath, runtime: process.execPath, sha256: sha2(supervisorAfter) };
       const after3 = configureHermesHooks(before2, supervisor, previous);
       if (before2 !== after3)
         changes.push({ path, before: before2, after: after3 });
@@ -55790,7 +56036,7 @@ function planAgentIntegration(options) {
     agents: [...new Set([...priorAgents, ...options.agents])].sort(),
     home: resolve16(home),
     includeVendor: true,
-    ...options.agents.includes("hermes") ? { supervisors: { ...policy.bridge?.supervisors, hermes: { path: join29(dataDir3, "agent-hooks", "hermes.js"), runtime: process.execPath, sha256: sha(renderHermesSupervisor(bindings.get("hermes").command, bindings.get("hermes").profileId)) } } } : {},
+    ...options.agents.includes("hermes") ? { supervisors: { ...policy.bridge?.supervisors, hermes: { path: join29(dataDir3, "agent-hooks", "hermes.js"), runtime: process.execPath, sha256: sha2(renderHermesSupervisor(bindings.get("hermes").command, bindings.get("hermes").profileId)) } } } : {},
     commands: { ...policy.bridge?.commands, ...Object.fromEntries([...bindings].map(([agent, binding]) => [agent, binding.command])) },
     profiles: Object.fromEntries([...new Set([...priorAgents, ...options.agents])].sort().map((agent) => [agent, bindings.get(agent)?.profileId ?? policy.bridge?.profiles?.[agent] ?? policy.profileId])),
     disabledBuiltins: options.agents.includes("codex") ? nativeSkills.filter((entry) => entry.agent === "codex" && entry.vendor && entry.path.startsWith(canonicalAgentPath(join29(home, ".codex", "skills", ".system"), aliases) + sep6)).map((entry) => ({ path: entry.path, hash: entry.hash })) : policy.bridge?.disabledBuiltins ?? [],
@@ -55805,10 +56051,10 @@ function planAgentIntegration(options) {
 }
 function atomicWrite2(path, content) {
   assertSafePath(path);
-  mkdirSync7(dirname15(path), { recursive: true, mode: 448 });
+  mkdirSync7(dirname16(path), { recursive: true, mode: 448 });
   const temporary = `${path}.skills-${randomUUID6()}`;
   try {
-    writeFileSync5(temporary, content, { mode: 384, flag: "wx" });
+    writeFileSync6(temporary, content, { mode: 384, flag: "wx" });
     renameSync4(temporary, path);
   } finally {
     if (existsSync15(temporary))
@@ -55842,8 +56088,8 @@ function applyAgentIntegration(plan) {
   chmodSync(backupRoot, 448);
   for (const [index, change] of plan.changes.entries())
     if (change.before !== null) {
-      const backup = join29(backupRoot, `${index}-${sha(change.path).slice(0, 12)}.backup`);
-      writeFileSync5(backup, change.before, { mode: 384, flag: "wx" });
+      const backup = join29(backupRoot, `${index}-${sha2(change.path).slice(0, 12)}.backup`);
+      writeFileSync6(backup, change.before, { mode: 384, flag: "wx" });
       backups.push(backup);
     }
   try {
@@ -55851,7 +56097,7 @@ function applyAgentIntegration(plan) {
       recheckRootAliases(aliases);
       if (currentText(change.path) !== change.before)
         throw new Error(`Configuration changed after planning: ${change.path}`);
-      for (let directory = dirname15(change.path);!existsSync15(directory); directory = dirname15(directory))
+      for (let directory = dirname16(change.path);!existsSync15(directory); directory = dirname16(directory))
         createdDirectories.add(directory);
       const after2 = change.after;
       atomicWrite2(change.path, after2);
@@ -55860,7 +56106,7 @@ function applyAgentIntegration(plan) {
     recheckRootAliases(aliases);
     for (const binding of plan.discoveryAfter ?? [])
       verifyAgentDiscovery(binding);
-    atomicWrite2(join29(backupRoot, "receipt.json"), JSON.stringify({ version: 1, changes: written.map((change) => ({ path: change.path, beforeHash: change.before === null ? null : sha(change.before), afterHash: sha(change.after) })), backups, ...aliases.length ? { rootAliases: aliases } : {} }) + `
+    atomicWrite2(join29(backupRoot, "receipt.json"), JSON.stringify({ version: 1, changes: written.map((change) => ({ path: change.path, beforeHash: change.before === null ? null : sha2(change.before), afterHash: sha2(change.after) })), backups, ...aliases.length ? { rootAliases: aliases } : {} }) + `
 `);
   } catch (error) {
     for (const change of written.reverse()) {
@@ -55891,11 +56137,11 @@ function applyAgentIntegration(plan) {
 }
 function syncArchiveDirectory(path) {
   assertSafePath(path);
-  const descriptor = openSync11(path, constants11.O_RDONLY | constants11.O_DIRECTORY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
+  const descriptor = openSync12(path, constants12.O_RDONLY | constants12.O_DIRECTORY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
   try {
-    fsyncSync3(descriptor);
+    fsyncSync4(descriptor);
   } finally {
-    closeSync11(descriptor);
+    closeSync12(descriptor);
   }
 }
 function writeArchiveJournal(path, value) {
@@ -55903,18 +56149,18 @@ function writeArchiveJournal(path, value) {
   const temporary = `${path}.skills-${randomUUID6()}`;
   let descriptor;
   try {
-    descriptor = openSync11(temporary, constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW, 384);
-    writeFileSync5(descriptor, `${JSON.stringify(value)}
+    descriptor = openSync12(temporary, constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW, 384);
+    writeFileSync6(descriptor, `${JSON.stringify(value)}
 `);
-    fsyncSync3(descriptor);
-    closeSync11(descriptor);
+    fsyncSync4(descriptor);
+    closeSync12(descriptor);
     descriptor = undefined;
     renameSync4(temporary, path);
-    syncArchiveDirectory(dirname15(path));
+    syncArchiveDirectory(dirname16(path));
   } finally {
     if (descriptor !== undefined)
-      closeSync11(descriptor);
-    if (lstatSync18(temporary, { throwIfNoEntry: false }))
+      closeSync12(descriptor);
+    if (lstatSync19(temporary, { throwIfNoEntry: false }))
       unlinkSync4(temporary);
   }
 }
@@ -55939,8 +56185,8 @@ function archiveNativeSkills(inventory, options) {
   const operationId = randomUUID6(), archiveRoot = join29(options.dataDir ?? getDataDir(), "migration", operationId, "native"), receiptPath = join29(archiveRoot, "receipt.json");
   const entries = selected.map((entry, index) => ({
     source: entry.vendor ? join29(entry.path, "SKILL.md") : entry.path,
-    archive: join29(archiveRoot, `${index}-${sha(entry.path).slice(0, 12)}`),
-    hash: entry.vendor ? sha(readNativeBytes(join29(entry.path, "SKILL.md"))) : entry.hash,
+    archive: join29(archiveRoot, `${index}-${sha2(entry.path).slice(0, 12)}`),
+    hash: entry.vendor ? sha2(readNativeBytes(join29(entry.path, "SKILL.md"))) : entry.hash,
     ...entry.vendor ? { discoveryOnly: true } : {},
     status: "planned"
   }));
@@ -55948,22 +56194,22 @@ function archiveNativeSkills(inventory, options) {
   const moved = [];
   const verifyArchive = (entry) => {
     assertSafePath(entry.archive);
-    const stat2 = lstatSync18(entry.archive);
+    const stat2 = lstatSync19(entry.archive);
     if (entry.discoveryOnly ? !stat2.isFile() : !stat2.isDirectory())
       throw new Error("Archive type changed");
-    if ((entry.discoveryOnly ? sha(readNativeBytes(entry.archive)) : treeHash(entry.archive)) !== entry.hash)
+    if ((entry.discoveryOnly ? sha2(readNativeBytes(entry.archive)) : treeHash(entry.archive)) !== entry.hash)
       throw new Error("Archive bytes changed");
   };
   assertSafePath(archiveRoot);
   const created = [];
-  for (let path = archiveRoot;!existsSync15(path); path = dirname15(path))
+  for (let path = archiveRoot;!existsSync15(path); path = dirname16(path))
     created.push(path);
   mkdirSync7(archiveRoot, { recursive: true, mode: 448 });
   try {
     for (const directory of created)
       syncArchiveDirectory(directory);
     if (created.length)
-      syncArchiveDirectory(dirname15(created.at(-1)));
+      syncArchiveDirectory(dirname16(created.at(-1)));
     writeArchiveJournal(receiptPath, journal);
     for (const [index, entry] of selected.entries()) {
       recheckRootAliases(aliases);
@@ -55975,7 +56221,7 @@ function archiveNativeSkills(inventory, options) {
       writeArchiveJournal(receiptPath, journal);
       renameSync4(move.source, move.archive);
       moved.push(move);
-      syncArchiveDirectory(dirname15(move.source));
+      syncArchiveDirectory(dirname16(move.source));
       syncArchiveDirectory(archiveRoot);
       verifyArchive(move);
       move.status = "archived";
@@ -55996,7 +56242,7 @@ function archiveNativeSkills(inventory, options) {
         recheckRootAliases(aliases);
         assertSafePath(entry.source);
         assertSafePath(entry.archive);
-        if (lstatSync18(entry.source, { throwIfNoEntry: false })) {
+        if (lstatSync19(entry.source, { throwIfNoEntry: false })) {
           entry.status = "recovery-required";
           entry.conflict = "source-occupied";
           continue;
@@ -56010,10 +56256,10 @@ function archiveNativeSkills(inventory, options) {
         }
         if (entry.discoveryOnly) {
           linkSync2(entry.archive, entry.source);
-          syncArchiveDirectory(dirname15(entry.source));
+          syncArchiveDirectory(dirname16(entry.source));
           unlinkSync4(entry.archive);
         } else {
-          if (lstatSync18(entry.source, { throwIfNoEntry: false })) {
+          if (lstatSync19(entry.source, { throwIfNoEntry: false })) {
             entry.status = "recovery-required";
             entry.conflict = "source-occupied";
             continue;
@@ -56021,7 +56267,7 @@ function archiveNativeSkills(inventory, options) {
           renameSync4(entry.archive, entry.source);
         }
         entry.status = "restored";
-        syncArchiveDirectory(dirname15(entry.source));
+        syncArchiveDirectory(dirname16(entry.source));
         syncArchiveDirectory(archiveRoot);
       } catch {
         entry.status = "recovery-required";
@@ -56043,10 +56289,10 @@ function archiveNativeSkills(inventory, options) {
 function assertManagedAgentBridge(agent, options = {}) {
   const home = resolve16(options.home ?? homedir4()), dataDir3 = options.dataDir ?? getDataDirReadOnly();
   assertSafePath(join29(dataDir3, "agent-policy.json"));
-  const snapshot = readManagedSkillPolicySnapshot(dataDir3);
-  if (!snapshot)
+  const snapshot2 = readManagedSkillPolicySnapshot(dataDir3);
+  if (!snapshot2)
     throw new Error("NATIVE_SKILL_DRIFT: install the Skills bridge with skills hook install");
-  const binding = snapshot.value.bridge;
+  const binding = snapshot2.value.bridge;
   if (!binding || binding.version !== CLI_BRIDGE_VERSION || binding.digest !== CLI_BRIDGE_DIGEST || binding.home !== home || !Array.isArray(binding.agents) || !binding.agents.includes(agent))
     throw new Error("NATIVE_SKILL_DRIFT: the managed Skills bridge binding is missing or incompatible; run skills hook install");
   const aliases = binding.rootAliases ?? [];
@@ -56068,7 +56314,7 @@ function assertManagedAgentBridge(agent, options = {}) {
     throw new Error("NATIVE_SKILL_DRIFT: the hook selection profile differs from its managed binding; restart the native client after reviewing skills hook install");
   if (agent === "hermes") {
     const supervisor = binding.supervisors?.hermes;
-    if (supervisor?.path !== join29(dataDir3, "agent-hooks", "hermes.js") || supervisor?.sha256 !== sha(renderHermesSupervisor(command, profile)))
+    if (supervisor?.path !== join29(dataDir3, "agent-hooks", "hermes.js") || supervisor?.sha256 !== sha2(renderHermesSupervisor(command, profile)))
       throw new Error("NATIVE_SKILL_DRIFT: Hermes supervisor binding changed; run skills hook install");
     assertHermesProtection(home, config, command, profile, supervisor);
   } else if (agent === "opencode") {
@@ -56090,6 +56336,8 @@ function assertManagedAgentBridge(agent, options = {}) {
       throw new Error("NATIVE_SKILL_DRIFT: Gemini bridge or bundled-skill protection changed; run skills hook install");
   }
   const codexPath = canonicalAgentPath(join29(home, ".codex", "config.toml"), aliases);
+  if (options.codexDiscoveryRecovery && (agent !== "codex" || options.codexDiscoveryRecovery.configPath !== codexPath))
+    throw new Error("NATIVE_SKILL_DRIFT: Codex trust recovery names a different configuration root");
   const codexConfig = agent === "codex" ? Bun.TOML.parse(readOptional(codexPath) ?? "") : {};
   if (agent === "codex" && codexConfig.skills?.bundled?.enabled !== false)
     throw new Error("NATIVE_SKILL_DRIFT: Codex bundled skill reseeding is not disabled (skills.bundled.enabled); run skills hook install");
@@ -56108,7 +56356,7 @@ function assertManagedAgentBridge(agent, options = {}) {
   if (agent === "gemini" && !discovery.builtinNames?.every((name) => config.skills.disabled.includes(name)))
     throw new Error("NATIVE_SKILL_DRIFT: an installed Gemini builtin is not disabled");
   try {
-    verifyAgentDiscovery(discovery);
+    verifyAgentDiscovery(discovery, options.codexDiscoveryRecovery);
     if (discovery.method === "automatic") {
       const current = resolveAgentDiscovery({ home, agent, canonical: (path) => canonicalAgentPath(path, aliases) });
       if (JSON.stringify(current) !== JSON.stringify(discovery))
@@ -56164,7 +56412,7 @@ function assertNativeExportAllowed(dataDir3 = getDataDirReadOnly()) {
   if (requiresCliSkillLoading(dataDir3))
     throw new Error("NATIVE_SKILL_EXPORT_DISABLED: this station loads skills through the Skills CLI; use skills sync --selection-profile <id>");
 }
-var sha = (data) => createHash14("sha256").update(data).digest("hex"), HOOK_EVENTS, ROOTS, SKILLS_LOADING_POLICY = "Skills loading policy: discover skills with `skills list` or `skills search`, and read selected instructions with `skills load <slug>`. Use `skills sync` to refresh the shared profile. The only native skill is the owned skills-cli bridge. Create and edit payload skills in the Skills authoring workspace; do not copy payload instructions into native discovery folders. Context loading does not authorize execution; use `skills run` only when the task calls for running a skill.";
+var sha2 = (data) => createHash16("sha256").update(data).digest("hex"), HOOK_EVENTS, ROOTS, SKILLS_LOADING_POLICY = "Skills loading policy: discover skills with `skills list` or `skills search`, and read selected instructions with `skills load <slug>`. Use `skills sync` to refresh the shared profile. The only native skill is the owned skills-cli bridge. Create and edit payload skills in the Skills authoring workspace; do not copy payload instructions into native discovery folders. Context loading does not authorize execution; use `skills run` only when the task calls for running a skill.";
 var init_agent_integration = __esm(() => {
   init_config();
   init_managed_policy();
@@ -56194,7 +56442,7 @@ var init_agent_integration = __esm(() => {
 });
 
 // src/lib/home-migration.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, readdirSync as readdirSync11, renameSync as renameSync5, rmSync as rmSync3, statSync as statSync9, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, readdirSync as readdirSync11, renameSync as renameSync5, rmSync as rmSync3, statSync as statSync9, writeFileSync as writeFileSync7 } from "fs";
 import { join as join30 } from "path";
 function layoutMigrationRecordPath(appDir) {
   return join30(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD);
@@ -56317,7 +56565,7 @@ function migrateOwnerLayout(options = {}) {
     moved,
     note: "installed/ and legacy flat skill dirs moved into skills/; custom/ retained"
   };
-  writeFileSync6(layoutMigrationRecordPath(appDir), `${JSON.stringify(record2, null, 2)}
+  writeFileSync7(layoutMigrationRecordPath(appDir), `${JSON.stringify(record2, null, 2)}
 `);
   return { status: "migrated", moved, created, record: record2 };
 }
@@ -56332,7 +56580,7 @@ var init_home_migration = __esm(() => {
 import {
   cpSync as cpSync2,
   existsSync as existsSync17,
-  lstatSync as lstatSync19,
+  lstatSync as lstatSync20,
   mkdirSync as mkdirSync9,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync16,
@@ -56340,17 +56588,17 @@ import {
   renameSync as renameSync6,
   rmSync as rmSync4,
   statSync as statSync10,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
 import { homedir as homedir5 } from "os";
-import { basename as basename9, dirname as dirname16, join as join31 } from "path";
+import { basename as basename9, dirname as dirname17, join as join31 } from "path";
 function isSkillsOwnershipMarker(marker) {
   return typeof marker === "object" && marker !== null && Object.hasOwn(marker, "managedBy") && marker.managedBy === SYNC_MARKER_MANAGED_BY;
 }
 function hasSkillsOwnershipMarker(dir) {
   const path = join31(dir, SYNC_MARKER_FILE);
   try {
-    if (!lstatSync19(path).isFile())
+    if (!lstatSync20(path).isFile())
       return false;
     const marker = JSON.parse(readFileSync16(path, "utf8"));
     return isSkillsOwnershipMarker(marker);
@@ -56575,7 +56823,7 @@ function writeManagedSkillDir(dir, skillMd, options) {
   const action = dirExists ? "update" : "create";
   if (options.dryRun)
     return { action, path: skillMdPath };
-  const parentDir = dirname16(dir);
+  const parentDir = dirname17(dir);
   mkdirSync9(parentDir, { recursive: true });
   const transactionDir = mkdtempSync2(join31(parentDir, `.hasna-skills-write-${basename9(dir)}-`));
   const candidateDir = join31(transactionDir, "candidate");
@@ -56597,10 +56845,10 @@ function writeManagedSkillDir(dir, skillMd, options) {
     } else {
       mkdirSync9(candidateDir, { recursive: true });
     }
-    writeFileSync7(candidateSkillMdPath, skillMd.endsWith(`
+    writeFileSync8(candidateSkillMdPath, skillMd.endsWith(`
 `) ? skillMd : `${skillMd}
 `);
-    writeFileSync7(candidateMarkerPath, `${JSON.stringify(marker, null, 2)}
+    writeFileSync8(candidateMarkerPath, `${JSON.stringify(marker, null, 2)}
 `);
     if (dirExists) {
       originalMoved = true;
@@ -56665,7 +56913,7 @@ var init_agent_sync = __esm(() => {
 });
 
 // src/lib/project-state.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync17, writeFileSync as writeFileSync9 } from "fs";
 import { join as join32 } from "path";
 function getProjectStateDir(targetDir = process.cwd()) {
   return join32(targetDir, SKILLS_PROJECT_DIR);
@@ -56701,7 +56949,7 @@ function saveProjectConfig(config, targetDir = process.cwd()) {
   const dir = getProjectStateDir(targetDir);
   mkdirSync10(dir, { recursive: true });
   const normalized = normalizeProjectConfig({ ...config, updatedAt: new Date().toISOString() });
-  writeFileSync8(getProjectConfigPath(targetDir), JSON.stringify(normalized, null, 2) + `
+  writeFileSync9(getProjectConfigPath(targetDir), JSON.stringify(normalized, null, 2) + `
 `);
 }
 function pinProjectSkill(name, details = {}, targetDir = process.cwd()) {
@@ -76515,7 +76763,7 @@ var init_v4 = __esm(() => {
 });
 
 // src/lib/canonical-json.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 function canonicalJson2(value, maximumBytes = 2 * 1024 * 1024) {
   return canonicalJsonAtDepth(value, maximumBytes, 64);
 }
@@ -76559,7 +76807,7 @@ function canonicalJsonAtDepth(value, maximumBytes, maximumDepth) {
   return visit3(value, 0);
 }
 function canonicalJsonSha256(value, maximumBytes) {
-  return createHash15("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
+  return createHash17("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
 }
 var init_canonical_json = () => {};
 
@@ -76630,8 +76878,8 @@ function recurringFailure(value, status) {
 }
 function recurringInput(action, raw) {
   try {
-    const snapshot = JSON.parse(canonicalJson2(raw, action === "preview" ? 1048576 : 4096));
-    return inputs[action].parse(snapshot);
+    const snapshot2 = JSON.parse(canonicalJson2(raw, action === "preview" ? 1048576 : 4096));
+    return inputs[action].parse(snapshot2);
   } catch {
     throw new RecurringInputError;
   }
@@ -77159,9 +77407,9 @@ function timestamp2(value) {
   const time3 = Date.parse(value);
   return Number.isFinite(time3) && new Date(time3).toISOString().slice(0, 23) === value.slice(0, 23);
 }
-function parseMember(row, fail2) {
+function parseMember(row, fail3) {
   if (!record5(row) || !uuid10(row.membershipId) || !uuid10(row.userId) || typeof row.email !== "string" || !row.email || !(row.displayName === null || typeof row.displayName === "string") || !isRole(row.role) || !timestamp2(row.createdAt))
-    return fail2();
+    return fail3();
   return {
     membershipId: row.membershipId,
     userId: row.userId,
@@ -77188,14 +77436,14 @@ function workspaceMemberRemovalInput(membershipId, input2) {
   return { membershipId: value.membershipId, body: { expectedRole: value.expectedRole } };
 }
 function parseWorkspaceMemberRoleResult(value, membershipId, role3) {
-  const fail2 = () => {
+  const fail3 = () => {
     throw new Error(invalidMemberResult);
   };
   if (!record5(value) || !uuid10(value.organizationId) || typeof value.changed !== "boolean")
-    return fail2();
-  const member = parseMember(value.member, fail2);
+    return fail3();
+  const member = parseMember(value.member, fail3);
   if (member.membershipId !== membershipId || member.role !== role3)
-    return fail2();
+    return fail3();
   return { organizationId: value.organizationId, member, changed: value.changed };
 }
 function parseWorkspaceMemberRemovalResult(value, membershipId) {
@@ -77210,14 +77458,14 @@ function workspaceMemberFailure(value, status) {
   return workspaceMemberFailures[code][0] === status ? code : null;
 }
 function parseWorkspaceMembersPage(value) {
-  const fail2 = () => {
+  const fail3 = () => {
     throw new Error("The server returned an invalid workspace roster.");
   };
   if (!record5(value) || !uuid10(value.organizationId) || !Array.isArray(value.members) || value.members.length > 100 || !(value.nextCursor === null || cursor(value.nextCursor)) || !value.members.length && value.nextCursor !== null)
-    return fail2();
-  const members2 = value.members.map((row) => parseMember(row, fail2));
+    return fail3();
+  const members2 = value.members.map((row) => parseMember(row, fail3));
   if (new Set(members2.map((row) => row.membershipId)).size !== members2.length)
-    return fail2();
+    return fail3();
   return { organizationId: value.organizationId, members: members2, nextCursor: value.nextCursor };
 }
 var record5 = (value) => !!value && typeof value === "object" && !Array.isArray(value), cursor = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,512}$/.test(value), uuid10 = (value) => typeof value === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(value), isRole = (value) => typeof value === "string" && ["owner", "admin", "member", "viewer"].includes(value), WorkspaceMemberInputError, invalidMemberResult = "The server returned an invalid workspace member result. Refresh the roster before another action.", workspaceMemberFailures;
@@ -77312,14 +77560,14 @@ var init_remote_workspace_leave = __esm(() => {
 });
 
 // src/lib/auth-store.ts
-import { chmodSync as chmodSync2, existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync19, renameSync as renameSync7, statSync as statSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync9 } from "fs";
-import { basename as basename10, dirname as dirname17, join as join34 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync19, renameSync as renameSync7, statSync as statSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
+import { basename as basename10, dirname as dirname18, join as join34 } from "path";
 function getAuthFilePath(env3 = process.env) {
   return skillsCredentialFilePath(env3);
 }
 function getIdentityFilePath(env3 = process.env) {
   const file2 = skillsCredentialFilePath(env3);
-  return join34(dirname17(file2), basename10(file2).replace(/^credentials/, "identity") + ".json");
+  return join34(dirname18(file2), basename10(file2).replace(/^credentials/, "identity") + ".json");
 }
 function getAuthIdentity(env3 = process.env) {
   return readIdentity(env3);
@@ -77353,7 +77601,7 @@ function getAuthConfig(env3 = process.env, options = {}) {
 }
 function writeCredentialValues(values2, env3 = process.env) {
   const file2 = skillsCredentialFilePath(env3);
-  mkdirSync11(dirname17(file2), { recursive: true, mode: 448 });
+  mkdirSync11(dirname18(file2), { recursive: true, mode: 448 });
   const lines = [];
   const written = new Set;
   if (existsSync20(file2)) {
@@ -77380,7 +77628,7 @@ function writeCredentialValues(values2, env3 = process.env) {
 `) + `
 `;
   const temp = `${file2}.tmp-${process.pid}`;
-  writeFileSync9(temp, body, { mode: 384 });
+  writeFileSync10(temp, body, { mode: 384 });
   chmodSync2(temp, 384);
   renameSync7(temp, file2);
   return file2;
@@ -77428,7 +77676,7 @@ function saveAuthConfig(config2, env3 = process.env, authenticatedOrigin) {
   }
   const identityFile = getIdentityFilePath(env3);
   if (Object.keys(identity4).length > 0) {
-    writeFileSync9(identityFile, JSON.stringify({ ...identity4, apiUrl }, null, 2) + `
+    writeFileSync10(identityFile, JSON.stringify({ ...identity4, apiUrl }, null, 2) + `
 `, { mode: 384 });
     chmodSync2(identityFile, 384);
   } else {
@@ -78818,7 +79066,7 @@ var init_remote_client = __esm(() => {
 });
 
 // src/lib/revision.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 function revisionIdOf(content) {
   const canonicalContent = {
     slug: content.slug,
@@ -78839,7 +79087,7 @@ function revisionIdOf(content) {
     canonicalContent.replacementSlug = content.replacementSlug ?? null;
   }
   const canonical4 = JSON.stringify(canonicalContent);
-  return createHash16("sha256").update(canonical4).digest("hex");
+  return createHash18("sha256").update(canonical4).digest("hex");
 }
 var REVISION_ID_PATTERN;
 var init_revision = __esm(() => {
@@ -78868,8 +79116,8 @@ var init_skill_bundles = __esm(() => {
 });
 
 // src/lib/pull.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync3, readFileSync as readFileSync20, renameSync as renameSync8, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname18, join as join35 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync3, readFileSync as readFileSync20, renameSync as renameSync8, rmSync as rmSync6, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname19, join as join35 } from "path";
 async function pullSkills(options = {}) {
   const client2 = options.client !== undefined ? options.client : await createRemoteSkillsClient();
   if (!client2) {
@@ -79173,8 +79421,8 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
   try {
     for (const entry of entries) {
       const destination = join35(staging, entry.path);
-      mkdirSync12(dirname18(destination), { recursive: true });
-      writeFileSync10(destination, entry.bytes, { mode: entry.mode });
+      mkdirSync12(dirname19(destination), { recursive: true });
+      writeFileSync11(destination, entry.bytes, { mode: entry.mode });
     }
     writePullMarker(staging, {
       skill: name,
@@ -79215,7 +79463,7 @@ function writePullMarker(dir, record7) {
     ...record7.revisionId ? { revisionId: record7.revisionId } : {},
     syncedAt: new Date().toISOString()
   };
-  writeFileSync10(join35(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+  writeFileSync11(join35(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
 `);
 }
 async function safeMeta(client2, slug2) {
@@ -79288,7 +79536,7 @@ var init_pull = __esm(() => {
 });
 
 // src/lib/skill-context.ts
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 import { resolve as resolve17 } from "path";
 function words2(value) {
   return new Set(value.toLowerCase().match(/[a-z0-9]+/g) ?? []);
@@ -79377,7 +79625,7 @@ ${content}`;
 `);
   const receipt = {
     schemaVersion: 1,
-    id: createHash17("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
+    id: createHash19("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
     profileId: profile.profileId,
     profileRevision: profile.profileRevision,
     authority: profile.authority,
@@ -79399,7 +79647,7 @@ var init_skill_context = __esm(() => {
 });
 
 // src/lib/session-reconciliation.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 function exactTimestamp(value) {
   const parsed = value === undefined ? Number.NaN : Date.parse(value);
   if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== value) {
@@ -79417,12 +79665,12 @@ function assertPlanWindow(issuedAt, expiresAt, now3) {
   }
 }
 function inspectSkillSession(sessionId, options = {}) {
-  const snapshot = readSkillSessionSnapshot(sessionId, options), { receipt } = snapshot;
+  const snapshot2 = readSkillSessionSnapshot(sessionId, options), { receipt } = snapshot2;
   return {
     sessionId,
-    path: snapshot.path,
-    receiptSha256: snapshot.sha256,
-    generation: snapshot.generation,
+    path: snapshot2.path,
+    receiptSha256: snapshot2.sha256,
+    generation: snapshot2.generation,
     verifiedAt: receipt.verifiedAt,
     authority: receipt.profile.authority,
     workspaceId: receipt.profile.workspaceId,
@@ -79447,8 +79695,8 @@ async function reconcileSkillSession(input2, options = {}) {
   const expiresAt = input2.apply ? input2.planExpiresAt : new Date(now3 + SESSION_RECONCILIATION_PLAN_TTL_MS).toISOString();
   if (input2.apply)
     assertPlanWindow(issuedAt, expiresAt, now3);
-  const snapshot = readSkillSessionSnapshot(input2.sessionId, options), old = snapshot.receipt;
-  if (snapshot.sha256 !== input2.receiptSha256 || old.profile.profileId !== input2.fromProfile || old.profile.profileRevision !== input2.fromRevision) {
+  const snapshot2 = readSkillSessionSnapshot(input2.sessionId, options), old = snapshot2.receipt;
+  if (snapshot2.sha256 !== input2.receiptSha256 || old.profile.profileId !== input2.fromProfile || old.profile.profileRevision !== input2.fromRevision) {
     throw new SkillSelectionError("SESSION_RECEIPT_CHANGED", "The current session receipt does not match the reviewed old bytes, profile and revision.");
   }
   const client2 = options.client ?? await createProfileClient();
@@ -79462,14 +79710,14 @@ async function reconcileSkillSession(input2, options = {}) {
   }
   const targetKeys = new Set(target.selections.map(selectionKey));
   const loaded = old.loaded.filter((key) => targetKeys.has(key));
-  const replacementGeneration = nextSkillSessionGeneration(snapshot.generation);
+  const replacementGeneration = nextSkillSessionGeneration(snapshot2.generation);
   const plan = {
     schemaVersion: 1,
     issuedAt,
     expiresAt,
     sessionId: input2.sessionId,
-    sessionPath: snapshot.path,
-    before: { receiptSha256: snapshot.sha256, generation: snapshot.generation, profileId: old.profile.profileId, profileRevision: old.profile.profileRevision, selectionCount: old.profile.selections.length },
+    sessionPath: snapshot2.path,
+    before: { receiptSha256: snapshot2.sha256, generation: snapshot2.generation, profileId: old.profile.profileId, profileRevision: old.profile.profileRevision, selectionCount: old.profile.selections.length },
     target: { authority: target.authority, workspaceId: target.workspaceId, profileId: target.profileId, profileRevision: target.profileRevision, profileSha256: digest3(target), selectionCount: target.selections.length },
     replacementGeneration,
     retainedLoadedCount: loaded.length,
@@ -79480,7 +79728,7 @@ async function reconcileSkillSession(input2, options = {}) {
   if (input2.planDigest !== undefined && input2.planDigest !== planDigest)
     throw new SkillSelectionError("SESSION_PLAN_CHANGED", "The session reconciliation plan differs from the reviewed plan.");
   if (!input2.apply)
-    return { applied: false, plan, planDigest, archivePath: undefined, receiptPath: undefined, beforeSha256: snapshot.sha256, afterSha256: undefined };
+    return { applied: false, plan, planDigest, archivePath: undefined, receiptPath: undefined, beforeSha256: snapshot2.sha256, afterSha256: undefined };
   assertPlanWindow(issuedAt, expiresAt, (options.now ?? Date.now)());
   const replacement = {
     ...old,
@@ -79489,10 +79737,10 @@ async function reconcileSkillSession(input2, options = {}) {
     profile: target,
     loaded
   };
-  const result2 = replaceSkillSession(skillSessionSnapshotBinding(snapshot), replacement, { ...plan, planDigest }, options, () => assertPlanWindow(issuedAt, expiresAt, (options.now ?? Date.now)()));
+  const result2 = replaceSkillSession(skillSessionSnapshotBinding(snapshot2), replacement, { ...plan, planDigest }, options, () => assertPlanWindow(issuedAt, expiresAt, (options.now ?? Date.now)()));
   return { applied: true, plan, planDigest, ...result2 };
 }
-var SESSION_RECONCILIATION_PLAN_TTL_MS, digest3 = (value) => createHash18("sha256").update(JSON.stringify(value)).digest("hex");
+var SESSION_RECONCILIATION_PLAN_TTL_MS, digest3 = (value) => createHash20("sha256").update(JSON.stringify(value)).digest("hex");
 var init_session_reconciliation = __esm(() => {
   init_profile_client();
   init_selection_cache();
@@ -79508,7 +79756,7 @@ __export(exports_context, {
   parseSkillContextInput: () => parseSkillContextInput,
   contextResolverOptions: () => contextResolverOptions
 });
-import { readSync as readSync10 } from "fs";
+import { readSync as readSync11 } from "fs";
 function selectedProfileId(explicit) {
   return explicit ?? process.env.HASNA_SKILLS_SELECTION_PROFILE ?? readManagedSkillPolicy()?.profileId ?? "default";
 }
@@ -79586,7 +79834,7 @@ async function readContextStdin() {
   let size2 = 0;
   while (true) {
     const chunk2 = Buffer.allocUnsafe(8192);
-    const count = readSync10(0, chunk2, 0, chunk2.length, null);
+    const count = readSync11(0, chunk2, 0, chunk2.length, null);
     if (count === 0)
       break;
     size2 += count;
@@ -81165,7 +81413,7 @@ var exports_init = {};
 __export(exports_init, {
   registerSetup: () => registerSetup
 });
-import { existsSync as existsSync23, readFileSync as readFileSync23, writeFileSync as writeFileSync11, appendFileSync } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync23, writeFileSync as writeFileSync12, appendFileSync } from "fs";
 import { join as join37 } from "path";
 function registerSetup(parent) {
   parent.command("init").option("--json", "Output as JSON", false).option("--for <agent>", "Detect project type and show MCP registration guidance for agent").option("--scope <scope>", "Deprecated; agent skill-folder installs are disabled", "global").description("Initialize project for pinned skills (.env.example, .gitignore)").action((options) => handleInit(options));
@@ -81250,7 +81498,7 @@ Use: skills render`));
       lines.push(`# Used by: ${skills.join(", ")}`);
       lines.push(`${envVar}=`);
     }
-    writeFileSync11(join37(cwd2, ".env.example"), lines.join(`
+    writeFileSync12(join37(cwd2, ".env.example"), lines.join(`
 `) + `
 `);
     envVarCount = envMap.size;
@@ -81412,7 +81660,7 @@ var init_init = __esm(() => {
 });
 
 // src/lib/home-adoption.ts
-import { constants as constants12, closeSync as closeSync12, fstatSync as fstatSync12, lstatSync as lstatSync20, openSync as openSync12, readSync as readSync11, existsSync as existsSync24, mkdirSync as mkdirSync13, readdirSync as readdirSync13, readFileSync as readFileSync25, rmSync as rmSync7, statSync as statSync12, writeFileSync as writeFileSync12 } from "fs";
+import { constants as constants13, closeSync as closeSync13, fstatSync as fstatSync13, lstatSync as lstatSync21, openSync as openSync13, readSync as readSync12, existsSync as existsSync24, mkdirSync as mkdirSync13, readdirSync as readdirSync13, readFileSync as readFileSync25, rmSync as rmSync7, statSync as statSync12, writeFileSync as writeFileSync13 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join38 } from "path";
 function indexCanonicalCorpus(corpusRoot) {
@@ -81528,7 +81776,7 @@ function appendConflictsLedger(appDir, conflicts) {
   for (const conflict of conflicts)
     byKey.set(`${conflict.agent}/${conflict.skill}`, conflict);
   ledger.entries = [...byKey.values()].sort((a, b) => `${a.agent}/${a.skill}`.localeCompare(`${b.agent}/${b.skill}`));
-  writeFileSync12(ledgerPath, `${JSON.stringify(ledger, null, 2)}
+  writeFileSync13(ledgerPath, `${JSON.stringify(ledger, null, 2)}
 `);
 }
 function writeRollbackRecord(mode, entries, appDir = getDataDir()) {
@@ -81536,7 +81784,7 @@ function writeRollbackRecord(mode, entries, appDir = getDataDir()) {
   mkdirSync13(dir, { recursive: true });
   const file2 = join38(dir, `${mode}-${Date.now()}.json`);
   const record7 = { version: 1, mode, timestamp: new Date().toISOString(), entries };
-  writeFileSync12(file2, `${JSON.stringify(record7, null, 2)}
+  writeFileSync13(file2, `${JSON.stringify(record7, null, 2)}
 `);
   return file2;
 }
@@ -81553,7 +81801,7 @@ function adoptUnmarkedHomes(options = {}) {
       source: "adopted",
       syncedAt: new Date().toISOString()
     };
-    writeFileSync12(join38(entry.path, SYNC_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+    writeFileSync13(join38(entry.path, SYNC_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
 `);
     return { agent: entry.agent, skill: entry.skill, path: entry.path, hash: entry.hash, marker };
   });
@@ -81567,25 +81815,25 @@ function adoptUnmarkedHomes(options = {}) {
 function pruneOwnership(dir) {
   let descriptor;
   try {
-    const directory = lstatSync20(dir);
+    const directory = lstatSync21(dir);
     if (!directory.isDirectory())
       return;
-    const markerPath = join38(dir, SYNC_MARKER_FILE), markerPathBefore = lstatSync20(markerPath);
+    const markerPath = join38(dir, SYNC_MARKER_FILE), markerPathBefore = lstatSync21(markerPath);
     if (!markerPathBefore.isFile())
       return;
-    descriptor = openSync12(markerPath, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
-    const before2 = fstatSync12(descriptor);
+    descriptor = openSync13(markerPath, constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK);
+    const before2 = fstatSync13(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;
     const bytes = Buffer.alloc(before2.size + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync11(descriptor, bytes, length, bytes.length - length, length);
+      const count = readSync12(descriptor, bytes, length, bytes.length - length, length);
       if (!count)
         break;
       length += count;
     }
-    const after2 = fstatSync12(descriptor), current = lstatSync20(dir), markerPathAfter = lstatSync20(markerPath);
+    const after2 = fstatSync13(descriptor), current = lstatSync21(dir), markerPathAfter = lstatSync21(markerPath);
     if (!markerPathAfter.isFile() || markerPathAfter.dev !== before2.dev || markerPathAfter.ino !== before2.ino || markerPathAfter.size !== before2.size || markerPathAfter.mtimeMs !== before2.mtimeMs || markerPathAfter.ctimeMs !== before2.ctimeMs || length !== before2.size || after2.size !== before2.size || after2.mtimeMs !== before2.mtimeMs || after2.ctimeMs !== before2.ctimeMs || !current.isDirectory() || current.dev !== directory.dev || current.ino !== directory.ino)
       return;
     const text3 = bytes.subarray(0, length).toString("utf8"), marker = JSON.parse(text3);
@@ -81596,7 +81844,7 @@ function pruneOwnership(dir) {
     return;
   } finally {
     if (descriptor !== undefined)
-      closeSync12(descriptor);
+      closeSync13(descriptor);
   }
 }
 function pruneStrayHomes(options = {}) {
@@ -81781,7 +82029,7 @@ var init_home_census = __esm(() => {
 });
 
 // src/cli/env-assignment.ts
-import { closeSync as closeSync13, constants as constants13, fstatSync as fstatSync13, ftruncateSync as ftruncateSync2, lstatSync as lstatSync21, openSync as openSync13, readFileSync as readFileSync27, writeSync as writeSync3 } from "fs";
+import { closeSync as closeSync14, constants as constants14, fstatSync as fstatSync14, ftruncateSync as ftruncateSync2, lstatSync as lstatSync22, openSync as openSync14, readFileSync as readFileSync27, writeSync as writeSync3 } from "fs";
 function serializeValue(value) {
   if (controls.test(value))
     throw new EnvAssignmentError("Environment values cannot contain control characters or newlines.");
@@ -81860,7 +82108,7 @@ function setEnvAssignment(path, assignment) {
   try {
     const previous = (() => {
       try {
-        return lstatSync21(path);
+        return lstatSync22(path);
       } catch (error61) {
         if (error61.code === "ENOENT")
           return;
@@ -81869,8 +82117,8 @@ 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 = openSync13(path, previous ? constants13.O_RDWR | constants13.O_NOFOLLOW | constants13.O_NONBLOCK : constants13.O_WRONLY | constants13.O_CREAT | constants13.O_EXCL | constants13.O_NOFOLLOW, 384);
-    const opened = fstatSync13(descriptor);
+    descriptor = openSync14(path, previous ? constants14.O_RDWR | constants14.O_NOFOLLOW | constants14.O_NONBLOCK : constants14.O_WRONLY | constants14.O_CREAT | constants14.O_EXCL | constants14.O_NOFOLLOW, 384);
+    const opened = fstatSync14(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.");
     }
@@ -81897,7 +82145,7 @@ function setEnvAssignment(path, assignment) {
     throw new EnvAssignmentError("Cannot safely read or write the project .env file.");
   } finally {
     if (descriptor !== undefined)
-      closeSync13(descriptor);
+      closeSync14(descriptor);
   }
 }
 var INVALID_LAYOUT = "Cannot safely update .env with multiline or unsupported assignments. Use single-line KEY=VALUE entries or edit the file manually.", controls, EnvAssignmentError;
@@ -82415,7 +82663,7 @@ var init_cloud_executions = __esm(() => {
 // node_modules/@hasna/secrets/dist/sdk.js
 import { isIP as isIP3 } from "net";
 import { spawnSync as spawnSync2 } from "child_process";
-import { closeSync as closeSync14, fstatSync as fstatSync14, openSync as openSync14, readFileSync as readFileSync29 } from "fs";
+import { closeSync as closeSync15, fstatSync as fstatSync15, openSync as openSync15, readFileSync as readFileSync29 } 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";
@@ -82520,7 +82768,7 @@ function readAppConfigFile2(path) {
   };
   let fd = -1;
   try {
-    fd = openSync14(path, O_RDONLY3 | O_NOFOLLOW3 | O_NONBLOCK3);
+    fd = openSync15(path, O_RDONLY3 | O_NOFOLLOW3 | O_NONBLOCK3);
   } catch (error61) {
     const code = error61.code;
     if (code === "ENOENT" || code === "ENOTDIR")
@@ -82530,7 +82778,7 @@ function readAppConfigFile2(path) {
     unsafe(`the path could not be opened (${code ?? "unknown error"})`);
   }
   try {
-    const before2 = fstatSync14(fd);
+    const before2 = fstatSync15(fd);
     if (!before2.isFile())
       unsafe("the path is not a regular file");
     if (!configFileModeAllowed2(before2.mode)) {
@@ -82542,14 +82790,14 @@ function readAppConfigFile2(path) {
     if (before2.size > MAX_CREDENTIAL_FILE_BYTES2)
       unsafe("the file exceeds the size limit");
     const bytes = readFileSync29(fd);
-    const after2 = fstatSync14(fd);
+    const after2 = fstatSync15(fd);
     if (!configFileReadsCoherent2(before2, after2)) {
       unsafe("the file changed while being read");
     }
     return parseEnvFile2(bytes.toString("utf8"));
   } finally {
     if (fd !== -1)
-      closeSync14(fd);
+      closeSync15(fd);
   }
 }
 function readCredentialFile2(path, apiKeyKeys) {
@@ -82599,14 +82847,14 @@ function assertUsableCredential2(appName, source, value) {
     return;
   throw new CredentialResolutionError2(appName, `The credential from ${source} contains characters that cannot be sent in an HTTP header ` + `(a control character or non-ASCII byte). A file written with CR-only line endings is the usual ` + `cause. Rewrite that credential file with one LF-terminated KEY=value line. ` + `The value is not shown here, and is deliberately never logged.`, [source]);
 }
-function sealCredential2(fields) {
-  const { apiKey } = fields;
+function sealCredential2(fields2) {
+  const { apiKey } = fields2;
   const visible = {
-    tier: fields.tier,
-    source: fields.source,
-    deliberate: fields.deliberate,
-    diskCandidates: Object.freeze([...fields.diskCandidates]),
-    warning: fields.warning
+    tier: fields2.tier,
+    source: fields2.source,
+    deliberate: fields2.deliberate,
+    diskCandidates: Object.freeze([...fields2.diskCandidates]),
+    warning: fields2.warning
   };
   const sealed = { ...visible };
   Object.defineProperty(sealed, "apiKey", {
@@ -82615,9 +82863,9 @@ function sealCredential2(fields) {
     writable: false,
     configurable: false
   });
-  if (fields.pointerVaultKey !== undefined) {
+  if (fields2.pointerVaultKey !== undefined) {
     Object.defineProperty(sealed, "pointerVaultKey", {
-      value: fields.pointerVaultKey,
+      value: fields2.pointerVaultKey,
       enumerable: false,
       writable: false,
       configurable: false
@@ -82755,7 +83003,7 @@ function keychainConfigValue2(name, env3, options = {}) {
 function snapshotClientEnvironment2(name, env3) {
   const keys2 = clientTransportEnvKeys2(name);
   const ambient = isAmbientEnvironment2(env3);
-  const snapshot = Object.create(null);
+  const snapshot2 = Object.create(null);
   for (const key of [
     ...keys2.apiUrlKeys,
     ...keys2.apiKeyKeys,
@@ -82777,17 +83025,17 @@ function snapshotClientEnvironment2(name, env3) {
     if (descriptor.value !== undefined && typeof descriptor.value !== "string") {
       throw new CredentialResolutionError2(name, `${key} must be a string data property.`, [key]);
     }
-    snapshot[key] = descriptor.value;
+    snapshot2[key] = descriptor.value;
   }
   if (ambient) {
-    Object.defineProperty(snapshot, AMBIENT_ENVIRONMENT2, {
+    Object.defineProperty(snapshot2, AMBIENT_ENVIRONMENT2, {
       value: true,
       enumerable: false,
       writable: false,
       configurable: false
     });
   }
-  return Object.freeze(snapshot);
+  return Object.freeze(snapshot2);
 }
 function resolveCredential2(name, env3, options = {}) {
   env3 = snapshotClientEnvironment2(name, env3);
@@ -83715,7 +83963,7 @@ var init_sdk = __esm(() => {
 });
 
 // src/lib/execution-secrets.ts
-import { constants as constants14, closeSync as closeSync15, fstatSync as fstatSync15, openSync as openSync15, readSync as readSync12, realpathSync as realpathSync6 } from "fs";
+import { constants as constants15, closeSync as closeSync16, fstatSync as fstatSync16, openSync as openSync16, readSync as readSync13, realpathSync as realpathSync6 } from "fs";
 import { hostname as stationHostname } from "os";
 function selectedSecretBindingsTemplate(scope, names, createClient2 = createSecretsClientFromEnv) {
   let secretsAuthority;
@@ -83759,13 +84007,13 @@ function declaredSecretNames(value) {
 function readSelectedSecretBindings(path) {
   let fd;
   try {
-    fd = openSync15(path, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
-    const stat2 = fstatSync15(fd);
+    fd = openSync16(path, constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK);
+    const stat2 = fstatSync16(fd);
     if (!stat2.isFile() || stat2.size > 65536)
       throw new Error;
     const bytes = Buffer.alloc(65537);
     let size2 = 0, count;
-    while ((count = readSync12(fd, bytes, size2, bytes.length - size2, null)) > 0) {
+    while ((count = readSync13(fd, bytes, size2, bytes.length - size2, null)) > 0) {
       size2 += count;
       if (size2 > 65536)
         throw new Error;
@@ -83775,7 +84023,7 @@ function readSelectedSecretBindings(path) {
     return refuse("INVALID_SECRET_BINDINGS", "Secret bindings must be a regular JSON file of at most 64 KiB, containing reference names only.");
   } finally {
     if (fd !== undefined)
-      closeSync15(fd);
+      closeSync16(fd);
   }
 }
 function validateSelectedSecretBindings(value, scope, names) {
@@ -83982,7 +84230,7 @@ var init_execution_grants = __esm(() => {
 });
 
 // src/lib/execution-grant-client.ts
-import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual6 } from "util";
 function id(value) {
   if (!grantIdentifier(value))
     throw new Error("Invalid execution grant profile or revision identifier.");
@@ -84026,26 +84274,26 @@ async function readExecutionGrantPolicy(profileId, revision) {
   return policy;
 }
 async function saveExecutionGrantPolicy(profileId, grants, revision) {
-  const snapshot = validateExecutionGrants(grants);
+  const snapshot2 = validateExecutionGrants(grants);
   if (revision !== undefined)
     id(revision);
   const policy = validateExecutionGrantPolicy(await request(`/execution-grants/${id(profileId)}`, {
     method: "PUT",
     headers: revision === undefined ? { "If-None-Match": "*" } : { "If-Match": `"${revision}"` },
-    body: JSON.stringify({ grants: snapshot })
+    body: JSON.stringify({ grants: snapshot2 })
   }));
-  if (policy.profileId !== profileId || policy.previousRevision !== (revision ?? null) || !isDeepStrictEqual4(policy.grants, snapshot)) {
+  if (policy.profileId !== profileId || policy.previousRevision !== (revision ?? null) || !isDeepStrictEqual6(policy.grants, snapshot2)) {
     throw new Error("The API did not preserve the reviewed execution grant policy; read it before retrying.");
   }
   return policy;
 }
 async function resolveExecutionGrant(input2) {
-  const snapshot = validateExecutionGrantRequest(input2);
-  const value = await request(`/execution-grants/${id(snapshot.selection.profileId)}/resolve`, { method: "POST", body: JSON.stringify(snapshot) }, snapshot.selection.authority);
+  const snapshot2 = validateExecutionGrantRequest(input2);
+  const value = await request(`/execution-grants/${id(snapshot2.selection.profileId)}/resolve`, { method: "POST", body: JSON.stringify(snapshot2) }, snapshot2.selection.authority);
   if (!grantRecord(value) || Object.keys(value).length !== 3 || !grantIdentifier(value.policyRevision) || !grantIdentifier(value.grantId) || !grantRecord(value.bindings)) {
     throw new SkillSelectionError("INVALID_EXECUTION_GRANT", "The Skills API returned an invalid execution grant.");
   }
-  if (!isDeepStrictEqual4(value.bindings.selection, snapshot.selection) || !isDeepStrictEqual4(value.bindings.consumer, snapshot.consumer)) {
+  if (!isDeepStrictEqual6(value.bindings.selection, snapshot2.selection) || !isDeepStrictEqual6(value.bindings.consumer, snapshot2.consumer)) {
     throw new SkillSelectionError("EXECUTION_GRANT_SCOPE_MISMATCH", "The Skills API returned a grant for a different selection or consumer.");
   }
   return value;
@@ -84064,10 +84312,10 @@ __export(exports_selected_run, {
   prepareSelectedSecretBindings: () => prepareSelectedSecretBindings,
   executeSelectedLocal: () => executeSelectedLocal
 });
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 import { spawn as spawn2 } from "child_process";
-import { mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync4, writeFileSync as writeFileSync13, realpathSync as realpathSync7 } from "fs";
-import { dirname as dirname19, join as join42, resolve as resolve18 } from "path";
+import { mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync4, writeFileSync as writeFileSync14, realpathSync as realpathSync7 } from "fs";
+import { dirname as dirname20, join as join42, resolve as resolve18 } from "path";
 import { tmpdir, hostname as stationHostname2 } from "os";
 async function resolveSelectedRun(spec, profileId, options = {}) {
   const context = await resolveSelectionContext(profileId, options);
@@ -84156,8 +84404,8 @@ async function executeSelectedLocal(selected, options = {}) {
       throw new SkillSelectionError("INVALID_BUNDLE_PATH", "The execution bundle path exceeds its limit.");
     });
     const destination = join42(runDirectory, entry.path);
-    mkdirSync14(dirname19(destination), { recursive: true, mode: 448 });
-    writeFileSync13(destination, entry.bytes, { flag: "wx", mode: entry.mode & 511 });
+    mkdirSync14(dirname20(destination), { recursive: true, mode: 448 });
+    writeFileSync14(destination, entry.bytes, { flag: "wx", mode: entry.mode & 511 });
   }
   env3.SKILLS_INPUT_JSON = input2;
   env3.SKILLS_WORKSPACE_DIR = resolve18(options.cwd ?? process.cwd());
@@ -84190,13 +84438,13 @@ async function executeSelectedLocal(selected, options = {}) {
     selection: selection2,
     target: "local",
     runtime: runtimeName,
-    inputDigest: `sha256:${createHash19("sha256").update(input2).digest("hex")}`,
+    inputDigest: `sha256:${createHash21("sha256").update(input2).digest("hex")}`,
     runDirectory,
     ...executionGrant ? { executionGrant } : {},
     ...bindings ? { secretBinding: { schema: bindings.schema, selection: bindings.selection, consumer: bindings.consumer, secretsAuthority: bindings.secretsAuthority, bindings: bindings.bindings } } : {},
     ...result2
   };
-  writeFileSync13(join42(runDirectory, ".execution-receipt.json"), JSON.stringify({ ...receipt, stdout: undefined, stderr: undefined }), { mode: 384 });
+  writeFileSync14(join42(runDirectory, ".execution-receipt.json"), JSON.stringify({ ...receipt, stdout: undefined, stderr: undefined }), { mode: 384 });
   return receipt;
 }
 async function subprocess(command, cwd2, env3, input2, timeoutMs) {
@@ -88407,8 +88655,8 @@ var init_runs = __esm(() => {
 });
 
 // src/lib/run-state.ts
-import { createHash as createHash20, randomBytes } from "crypto";
-import { existsSync as existsSync27, mkdirSync as mkdirSync15, readFileSync as readFileSync30, readdirSync as readdirSync16, statSync as statSync15, writeFileSync as writeFileSync14 } from "fs";
+import { createHash as createHash22, randomBytes } from "crypto";
+import { existsSync as existsSync27, mkdirSync as mkdirSync15, readFileSync as readFileSync30, readdirSync as readdirSync16, statSync as statSync15, writeFileSync as writeFileSync15 } from "fs";
 import { extname, join as join43, relative as relative6 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now3 = new Date;
@@ -88473,15 +88721,15 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync14(join43(context.logsDir, "stdout.log"), stdout);
-  writeFileSync14(join43(context.logsDir, "stderr.log"), stderr);
+  writeFileSync15(join43(context.logsDir, "stdout.log"), stdout);
+  writeFileSync15(join43(context.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
   const path = join43(context.runDir, "events.ndjson");
   const previous = existsSync27(path) ? readFileSync30(path, "utf-8") : "";
-  writeFileSync14(path, previous + line);
+  writeFileSync15(path, previous + line);
 }
 function listSkillRuns(targetDir = process.cwd(), limit = 50) {
   const runsRoot = join43(getProjectStateDir(targetDir), "runs");
@@ -88527,11 +88775,11 @@ function getRunExportDir(runId2, skill, targetDir = process.cwd()) {
   return join43(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId2);
 }
 function writeRunRecord(context) {
-  writeFileSync14(join43(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
+  writeFileSync15(join43(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context, artifacts) {
-  writeFileSync14(join43(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
+  writeFileSync15(join43(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context) {
@@ -88544,7 +88792,7 @@ function collectRunArtifacts(context) {
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
-      sha256: createHash20("sha256").update(bytes).digest("hex"),
+      sha256: createHash22("sha256").update(bytes).digest("hex"),
       sizeBytes: stat2.size
     });
   }
@@ -92501,11 +92749,11 @@ var require_codegen = __commonJS((exports) => {
       const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`;
       return `${varKind} ${this.name}${rhs};` + _n;
     }
-    optimizeNames(names, constants15) {
+    optimizeNames(names, constants16) {
       if (!names[this.name.str])
         return;
       if (this.rhs)
-        this.rhs = optimizeExpr(this.rhs, names, constants15);
+        this.rhs = optimizeExpr(this.rhs, names, constants16);
       return this;
     }
     get names() {
@@ -92523,10 +92771,10 @@ var require_codegen = __commonJS((exports) => {
     render({ _n }) {
       return `${this.lhs} = ${this.rhs};` + _n;
     }
-    optimizeNames(names, constants15) {
+    optimizeNames(names, constants16) {
       if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
         return;
-      this.rhs = optimizeExpr(this.rhs, names, constants15);
+      this.rhs = optimizeExpr(this.rhs, names, constants16);
       return this;
     }
     get names() {
@@ -92592,8 +92840,8 @@ var require_codegen = __commonJS((exports) => {
     optimizeNodes() {
       return `${this.code}` ? this : undefined;
     }
-    optimizeNames(names, constants15) {
-      this.code = optimizeExpr(this.code, names, constants15);
+    optimizeNames(names, constants16) {
+      this.code = optimizeExpr(this.code, names, constants16);
       return this;
     }
     get names() {
@@ -92623,12 +92871,12 @@ var require_codegen = __commonJS((exports) => {
       }
       return nodes.length > 0 ? this : undefined;
     }
-    optimizeNames(names, constants15) {
+    optimizeNames(names, constants16) {
       const { nodes } = this;
       let i = nodes.length;
       while (i--) {
         const n2 = nodes[i];
-        if (n2.optimizeNames(names, constants15))
+        if (n2.optimizeNames(names, constants16))
           continue;
         subtractNames(names, n2.names);
         nodes.splice(i, 1);
@@ -92685,12 +92933,12 @@ var require_codegen = __commonJS((exports) => {
         return;
       return this;
     }
-    optimizeNames(names, constants15) {
+    optimizeNames(names, constants16) {
       var _a3;
-      this.else = (_a3 = this.else) === null || _a3 === undefined ? undefined : _a3.optimizeNames(names, constants15);
-      if (!(super.optimizeNames(names, constants15) || this.else))
+      this.else = (_a3 = this.else) === null || _a3 === undefined ? undefined : _a3.optimizeNames(names, constants16);
+      if (!(super.optimizeNames(names, constants16) || this.else))
         return;
-      this.condition = optimizeExpr(this.condition, names, constants15);
+      this.condition = optimizeExpr(this.condition, names, constants16);
       return this;
     }
     get names() {
@@ -92715,10 +92963,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.iteration})` + super.render(opts);
     }
-    optimizeNames(names, constants15) {
-      if (!super.optimizeNames(names, constants15))
+    optimizeNames(names, constants16) {
+      if (!super.optimizeNames(names, constants16))
         return;
-      this.iteration = optimizeExpr(this.iteration, names, constants15);
+      this.iteration = optimizeExpr(this.iteration, names, constants16);
       return this;
     }
     get names() {
@@ -92756,10 +93004,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
     }
-    optimizeNames(names, constants15) {
-      if (!super.optimizeNames(names, constants15))
+    optimizeNames(names, constants16) {
+      if (!super.optimizeNames(names, constants16))
         return;
-      this.iterable = optimizeExpr(this.iterable, names, constants15);
+      this.iterable = optimizeExpr(this.iterable, names, constants16);
       return this;
     }
     get names() {
@@ -92804,11 +93052,11 @@ var require_codegen = __commonJS((exports) => {
       (_b = this.finally) === null || _b === undefined || _b.optimizeNodes();
       return this;
     }
-    optimizeNames(names, constants15) {
+    optimizeNames(names, constants16) {
       var _a3, _b;
-      super.optimizeNames(names, constants15);
-      (_a3 = this.catch) === null || _a3 === undefined || _a3.optimizeNames(names, constants15);
-      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants15);
+      super.optimizeNames(names, constants16);
+      (_a3 = this.catch) === null || _a3 === undefined || _a3.optimizeNames(names, constants16);
+      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants16);
       return this;
     }
     get names() {
@@ -93082,7 +93330,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, constants15) {
+  function optimizeExpr(expr, names, constants16) {
     if (expr instanceof code_1.Name)
       return replaceName(expr);
     if (!canOptimize(expr))
@@ -93097,14 +93345,14 @@ var require_codegen = __commonJS((exports) => {
       return items;
     }, []));
     function replaceName(n2) {
-      const c = constants15[n2.str];
+      const c = constants16[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 && constants15[c.str] !== undefined);
+      return e2 instanceof code_1._Code && e2._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants16[c.str] !== undefined);
     }
   }
   function subtractNames(names, from) {
@@ -100681,7 +100929,7 @@ var init_remote_invitation_recovery = __esm(() => {
 });
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 function checkedPublicationDeclaration(value) {
   if (!exact(value, ["idempotencyKey", "version", "expectedCurrentVersionId", "manifestText", "archiveSha256", "archiveByteSize"]) || !publicationUuid(value.idempotencyKey) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || typeof value.manifestText !== "string" || Buffer.byteLength(value.manifestText) > 16384 || !hash3(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
     return bad();
@@ -100942,7 +101190,7 @@ var PRIVATE_PUBLICATION_MAX_BYTES, failures2, PrivatePublicationError, bad = ()
   throw new PrivatePublicationError("INVALID_PUBLICATION_INPUT", "Invalid publication input or recovery data.");
 }, invalid5 = () => {
   throw new PrivatePublicationError("INVALID_PUBLICATION_RESPONSE", "The server returned an invalid publication result.");
-}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record10 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys3) => record10(v) && Object.keys(v).sort().join(",") === keys3.sort().join(","), date6 = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash21("sha256").update(bytes).digest("hex");
+}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record10 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys3) => record10(v) && Object.keys(v).sort().join(",") === keys3.sort().join(","), date6 = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash23("sha256").update(bytes).digest("hex");
 var init_remote_private_publications = __esm(() => {
   init_fleet_credentials();
   init_remote_workspace_selection();
@@ -101219,11 +101467,11 @@ var init_remote_auth = __esm(() => {
 });
 
 // src/lib/workspace-profile.ts
-import { constants as constants15, closeSync as closeSync16, fstatSync as fstatSync16, lstatSync as lstatSync22, mkdirSync as mkdirSync16, mkdtempSync as mkdtempSync5, openSync as openSync16, readFileSync as readFileSync31, renameSync as renameSync9, rmSync as rmSync8, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname20, join as join44 } from "path";
+import { constants as constants16, closeSync as closeSync17, fstatSync as fstatSync17, lstatSync as lstatSync23, mkdirSync as mkdirSync16, mkdtempSync as mkdtempSync5, openSync as openSync17, readFileSync as readFileSync31, renameSync as renameSync9, rmSync as rmSync8, writeFileSync as writeFileSync16 } from "fs";
+import { dirname as dirname21, join as join44 } from "path";
 function stat2(path) {
   try {
-    return lstatSync22(path);
+    return lstatSync23(path);
   } catch (error61) {
     if (error61.code === "ENOENT")
       return null;
@@ -101233,14 +101481,14 @@ function stat2(path) {
 function safeText(file2) {
   if (stat2(file2) === null)
     return null;
-  const fd = openSync16(file2, constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK);
+  const fd = openSync17(file2, constants16.O_RDONLY | constants16.O_NOFOLLOW | constants16.O_NONBLOCK);
   try {
-    const s = fstatSync16(fd);
+    const s = fstatSync17(fd);
     if (!s.isFile() || s.size > 65536 || ![256, 384].includes(s.mode & 4095) || process.getuid && s.uid !== process.getuid())
-      return fail2("The selected profile must use bounded owner-only regular files.");
+      return fail3("The selected profile must use bounded owner-only regular files.");
     return readFileSync31(fd, "utf8");
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
   }
 }
 function checkIdentityMetadata(file2, identity4) {
@@ -101251,37 +101499,37 @@ function checkIdentityMetadata(file2, identity4) {
   try {
     value = JSON.parse(text3);
   } catch {
-    return fail2("The profile identity metadata is invalid. Sign in again before managing this workspace.");
+    return fail3("The profile identity metadata is invalid. Sign in again before managing this workspace.");
   }
   if (!value || typeof value !== "object" || Array.isArray(value))
-    return fail2("The profile identity metadata is invalid.");
+    return fail3("The profile identity metadata is invalid.");
   for (const [key, expected] of Object.entries({ userId: identity4.user.id, orgId: identity4.organization.id })) {
     if (value[key] !== undefined && value[key] !== expected)
-      return fail2("The profile identity metadata does not match its authenticated key. Sign in again before managing this workspace.");
+      return fail3("The profile identity metadata does not match its authenticated key. Sign in again before managing this workspace.");
   }
 }
 async function keyIdentity(key, origin) {
   const value = await new RemoteSkillsClient(key, origin).getIdentity();
   if (value.authMethod !== "api_key")
-    return fail2("The selected credential is not a workspace API key.");
+    return fail3("The selected credential is not a workspace API key.");
   const user = value.user;
   return parseWorkspaceIdentity(value, workspaceExpectedUserId(user?.id));
 }
 function prepareProfileWorkspace(action, source = process.env) {
   const env3 = { ...source }, origin = getApiUrl(action, env3), profile = selectedSkillsProfile(env3);
-  const unchanged2 = captureSkillsCredentialFiles(skillsProfileCredentialFiles(env3));
+  const unchanged3 = captureSkillsCredentialFiles(skillsProfileCredentialFiles(env3));
   return { origin, async resolve() {
-    unchanged2();
+    unchanged3();
     if (!profile)
-      return { origin, context: undefined, unchanged: unchanged2 };
+      return { origin, context: undefined, unchanged: unchanged3 };
     const connection = await resolveSkillsConnection(env3);
     if (!connection || connection.apiOrigin !== origin)
-      return fail2("The selected profile has no usable credential for this server.");
+      return fail3("The selected profile has no usable credential for this server.");
     const identity4 = await keyIdentity(connection.apiKey, origin);
     checkIdentityMetadata(getIdentityFilePath(env3), identity4);
-    unchanged2();
+    unchanged3();
     const context = { userId: identity4.user.id, membershipId: identity4.user.membershipId };
-    return { origin, context, unchanged: unchanged2 };
+    return { origin, context, unchanged: unchanged3 };
   } };
 }
 async function captureProfileWorkspace(action, source = process.env) {
@@ -101291,9 +101539,9 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
   workspaceExpectedUserId(membershipId);
   const env3 = { ...source }, profile = selectedSkillsProfile(env3);
   if (!profile)
-    return fail2("Workspace login requires an explicit HASNA_PROFILE name.");
+    return fail3("Workspace login requires an explicit HASNA_PROFILE name.");
   if (["HASNA_SKILLS_API_KEY_OVERRIDE", "HASNA_SKILLS_API_KEY_REF", "HASNA_SKILLS_API_KEY", "SKILLS_API_KEY"].some((name) => env3[name]?.trim()))
-    return fail2("Clear injected API keys before enrolling a named workspace profile.");
+    return fail3("Clear injected API keys before enrolling a named workspace profile.");
   const origin = getApiUrl("Sign in to a workspace", env3);
   const file2 = getAuthFilePath(env3), identityFile = getIdentityFilePath(env3);
   const paths = [...new Set([...skillsProfileCredentialFiles(env3), file2, identityFile])];
@@ -101304,17 +101552,17 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
   const credentialBody = (key) => [...lines.filter(Boolean), `HASNA_SKILLS_API_KEY=${key}`, `HASNA_SKILLS_API_URL=${origin}`, `HASNA_SKILLS_BOUND_API_URL=${origin}`, ""].join(`
 `);
   if (Buffer.byteLength(credentialBody("x".repeat(8192)), "utf8") > 65536)
-    return fail2("The selected profile has insufficient space for a bounded credential. Reduce its unrelated configuration before signing in.");
+    return fail3("The selected profile has insufficient space for a bounded credential. Reduce its unrelated configuration before signing in.");
   const parents3 = [];
-  for (let path = dirname20(file2);; path = dirname20(path)) {
+  for (let path = dirname21(file2);; path = dirname21(path)) {
     const before2 = stat2(path);
     if (before2 && (!before2.isDirectory() || before2.isSymbolicLink()))
-      return fail2("The profile directory must not be a symbolic link.");
+      return fail3("The profile directory must not be a symbolic link.");
     parents3.push([path, before2]);
-    if (path === dirname20(path))
+    if (path === dirname21(path))
       break;
   }
-  const unchanged2 = () => {
+  const unchanged3 = () => {
     unchangedFiles();
     for (const [path, before2] of parents3) {
       const now3 = stat2(path);
@@ -101327,7 +101575,7 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
     const connection = await resolveSkillsConnection(env3);
     if (connection) {
       if (connection.apiKeyTier !== "profile" || connection.apiOrigin !== origin)
-        return fail2("Workspace login must resolve only the explicitly named profile.");
+        return fail3("Workspace login must resolve only the explicitly named profile.");
       expected = await keyIdentity(connection.apiKey, origin);
       checkIdentityMetadata(identityFile, expected);
     }
@@ -101335,47 +101583,47 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
     if (!(error61 instanceof SkillsFleetCredentialError && error61.code === "MISSING_API_CREDENTIAL" && (old === null || !/^\s*(?:export\s+)?(?:HASNA_SKILLS_API_KEY|SKILLS_API_KEY)\s*=/m.test(old))))
       throw error61;
   }
-  unchanged2();
+  unchanged3();
   return {
     profile,
     origin,
     async complete(email4, code) {
-      unchanged2();
+      unchanged3();
       if (!email4.includes("@") || !/^\d{6}$/.test(code))
-        return fail2("A fresh email and six-digit verification code are required.");
+        return fail3("A fresh email and six-digit verification code are required.");
       if (expected && expected.user.email.toLowerCase() !== email4.toLowerCase())
-        return fail2("This profile belongs to another account. Use a different profile or ordinary replacement login.");
+        return fail3("This profile belongs to another account. Use a different profile or ordinary replacement login.");
       let issued = false;
       try {
         const result2 = await new RemoteSkillsAuthClient(origin).verifyCode(email4, code);
         const login = parseWorkspaceLogin(result2, expected?.user.id);
         if (result2.firstLogin === true)
-          return fail2("This sign-in created a new account using the server signup policy. Finish ordinary account login before enrolling a workspace profile.");
+          return fail3("This sign-in created a new account using the server signup policy. Finish ordinary account login before enrolling a workspace profile.");
         const session = await new RemoteSkillsClient(login.token, origin).switchWorkspace({ userId: login.userId, membershipId });
         if (session.user.email.toLowerCase() !== email4.toLowerCase())
-          return fail2("The verified account does not match the requested email.");
+          return fail3("The verified account does not match the requested email.");
         if (session.user.role === "viewer")
-          return fail2("Viewer memberships cannot enroll API keys.");
-        unchanged2();
+          return fail3("Viewer memberships cannot enroll API keys.");
+        unchanged3();
         issued = true;
         const created = await new RemoteSkillsClient(session.token, origin).createApiKey("cli");
         const verified = await keyIdentity(created.key, origin);
         if (verified.user.id !== session.user.id || verified.user.membershipId !== membershipId || verified.organization.id !== session.organization.id)
-          return fail2("The issued key does not match the selected workspace.");
-        unchanged2();
+          return fail3("The issued key does not match the selected workspace.");
+        unchanged3();
         if (!created.key.trim() || /[^\x21-\x7e]/.test(created.key) || created.key.length > 8192)
-          return fail2("The server returned an invalid API key.");
+          return fail3("The server returned an invalid API key.");
         const body = credentialBody(created.key);
         if (Buffer.byteLength(body, "utf8") > 65536)
-          return fail2("The new profile exceeds the credential reader size limit.");
+          return fail3("The new profile exceeds the credential reader size limit.");
         const identity4 = JSON.stringify({ email: verified.user.email, userId: verified.user.id, orgId: verified.organization.id, orgSlug: verified.organization.slug, apiUrl: origin }, null, 2) + `
 `;
-        mkdirSync16(dirname20(file2), { recursive: true, mode: 448 });
-        const temp = mkdtempSync5(join44(dirname20(file2), ".workspace-login-"));
+        mkdirSync16(dirname21(file2), { recursive: true, mode: 448 });
+        const temp = mkdtempSync5(join44(dirname21(file2), ".workspace-login-"));
         let identityInstalled = false;
         try {
-          writeFileSync15(join44(temp, "credentials"), body, { mode: 384, flag: "wx" });
-          writeFileSync15(join44(temp, "identity"), identity4, { mode: 384, flag: "wx" });
+          writeFileSync16(join44(temp, "credentials"), body, { mode: 384, flag: "wx" });
+          writeFileSync16(join44(temp, "identity"), identity4, { mode: 384, flag: "wx" });
           unchangedFiles();
           for (const [path, before2] of parents3) {
             const now3 = stat2(path);
@@ -101392,7 +101640,7 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
             if (oldIdentity === null)
               rmSync8(identityFile, { force: true });
             else {
-              writeFileSync15(join44(temp, "restore"), oldIdentity, { mode: 384, flag: "wx" });
+              writeFileSync16(join44(temp, "restore"), oldIdentity, { mode: 384, flag: "wx" });
               renameSync9(join44(temp, "restore"), identityFile);
             }
           }
@@ -101414,17 +101662,17 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
         };
       } catch (error61) {
         if (issued)
-          return fail2("Workspace key issuance was attempted, but enrollment could not be confirmed. Inspect the selected profile and workspace keys before retrying; do not retry automatically.");
+          return fail3("Workspace key issuance was attempted, but enrollment could not be confirmed. Inspect the selected profile and workspace keys before retrying; do not retry automatically.");
         if (error61 instanceof WorkspaceProfileError)
           throw error61;
-        return fail2("Unable to verify and select the workspace. Check the account, membership, selected server and fresh code. No enrollment key was requested.");
+        return fail3("Unable to verify and select the workspace. Check the account, membership, selected server and fresh code. No enrollment key was requested.");
       }
     }
   };
 }
-var WorkspaceProfileError, fail2 = (message) => {
+var WorkspaceProfileError, fail3 = (message) => {
   throw new WorkspaceProfileError(message);
-}, changed = () => fail2("The selected profile changed during sign-in. No credential was saved; retry with a stable profile.");
+}, changed = () => fail3("The selected profile changed during sign-in. No credential was saved; retry with a stable profile.");
 var init_workspace_profile = __esm(() => {
   init_auth_store();
   init_fleet_credentials();
@@ -101587,8 +101835,8 @@ var init_recurring_customer = __esm(() => {
 });
 
 // src/lib/recurring-recovery.ts
-import { constants as constants16, closeSync as closeSync17, fsyncSync as fsyncSync4, fstatSync as fstatSync17, lstatSync as lstatSync23, mkdirSync as mkdirSync17, openSync as openSync17, readSync as readSync13, realpathSync as realpathSync8, renameSync as renameSync10, unlinkSync as unlinkSync6, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname21, isAbsolute as isAbsolute17, join as join45, resolve as resolve19 } from "path";
+import { constants as constants17, closeSync as closeSync18, fsyncSync as fsyncSync5, fstatSync as fstatSync18, lstatSync as lstatSync24, mkdirSync as mkdirSync17, openSync as openSync18, readSync as readSync14, realpathSync as realpathSync8, renameSync as renameSync10, unlinkSync as unlinkSync6, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname22, isAbsolute as isAbsolute17, join as join45, resolve as resolve19 } from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 
 class RecoveryOwner {
@@ -101598,12 +101846,12 @@ class RecoveryOwner {
     this.directory = directory;
     if (!isAbsolute17(directory) || resolve19(directory) !== directory || realpathSync8(directory) !== directory)
       invalid6();
-    for (let path = directory;; path = dirname21(path)) {
-      const stat3 = lstatSync23(path);
+    for (let path = directory;; path = dirname22(path)) {
+      const stat3 = lstatSync24(path);
       if (!stat3.isDirectory() || stat3.isSymbolicLink())
         invalid6();
       this.parents.push({ path, dev: stat3.dev, ino: stat3.ino });
-      if (path === dirname21(path))
+      if (path === dirname22(path))
         break;
     }
     this.assert();
@@ -101612,59 +101860,59 @@ class RecoveryOwner {
     if (realpathSync8(this.directory) !== this.directory)
       invalid6();
     for (const prior of this.parents) {
-      const now3 = lstatSync23(prior.path);
+      const now3 = lstatSync24(prior.path);
       if (!now3.isDirectory() || now3.isSymbolicLink() || now3.dev !== prior.dev || now3.ino !== prior.ino)
         invalid6();
     }
-    const own2 = lstatSync23(this.directory);
+    const own2 = lstatSync24(this.directory);
     if ((own2.mode & 511) !== 448 || (own2.mode & 3584) !== 0 || process.getuid && own2.uid !== process.getuid())
       invalid6();
   }
   read(name) {
     this.assert();
-    const fd = openSync17(join45(this.directory, name), constants16.O_RDONLY | constants16.O_NOFOLLOW | constants16.O_NONBLOCK);
+    const fd = openSync18(join45(this.directory, name), constants17.O_RDONLY | constants17.O_NOFOLLOW | constants17.O_NONBLOCK);
     try {
-      const before2 = fstatSync17(fd);
+      const before2 = fstatSync18(fd);
       if (!before2.isFile() || before2.nlink !== 1 || (before2.mode & 4095) !== 384 || before2.size < 1 || before2.size > 8192 || process.getuid && before2.uid !== process.getuid())
         invalid6();
       const bytes = Buffer.alloc(before2.size + 1);
       let size2 = 0;
       while (size2 < bytes.length) {
-        const n2 = readSync13(fd, bytes, size2, bytes.length - size2, size2);
+        const n2 = readSync14(fd, bytes, size2, bytes.length - size2, size2);
         if (!n2)
           break;
         size2 += n2;
       }
-      const after2 = fstatSync17(fd), path = lstatSync23(join45(this.directory, name));
+      const after2 = fstatSync18(fd), path = lstatSync24(join45(this.directory, name));
       if (size2 !== before2.size || after2.size !== before2.size || before2.mtimeMs !== after2.mtimeMs || before2.ctimeMs !== after2.ctimeMs || path.dev !== before2.dev || path.ino !== before2.ino || !path.isFile() || path.isSymbolicLink())
         invalid6();
       this.assert();
       return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, size2));
     } finally {
-      closeSync17(fd);
+      closeSync18(fd);
     }
   }
   write(name, value) {
     this.assert();
     const bytes = canonicalJson2(value, 8192) + `
 `;
-    const fd = openSync17(join45(this.directory, name), constants16.O_WRONLY | constants16.O_CREAT | constants16.O_EXCL | constants16.O_NOFOLLOW, 384);
+    const fd = openSync18(join45(this.directory, name), constants17.O_WRONLY | constants17.O_CREAT | constants17.O_EXCL | constants17.O_NOFOLLOW, 384);
     try {
-      writeFileSync16(fd, bytes);
-      fsyncSync4(fd);
+      writeFileSync17(fd, bytes);
+      fsyncSync5(fd);
     } finally {
-      closeSync17(fd);
+      closeSync18(fd);
     }
     this.assert();
     this.sync();
   }
   sync() {
     this.assert();
-    const fd = openSync17(this.directory, constants16.O_RDONLY | constants16.O_NOFOLLOW);
+    const fd = openSync18(this.directory, constants17.O_RDONLY | constants17.O_NOFOLLOW);
     try {
-      fsyncSync4(fd);
+      fsyncSync5(fd);
     } finally {
-      closeSync17(fd);
+      closeSync18(fd);
     }
   }
   saveState(state, expected) {
@@ -101682,20 +101930,20 @@ class RecoveryOwner {
     this.assert();
     let fd;
     try {
-      fd = openSync17(join45(this.directory, "operation.lock"), constants16.O_WRONLY | constants16.O_CREAT | constants16.O_EXCL | constants16.O_NOFOLLOW, 384);
+      fd = openSync18(join45(this.directory, "operation.lock"), constants17.O_WRONLY | constants17.O_CREAT | constants17.O_EXCL | constants17.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.");
     }
-    const owner2 = fstatSync17(fd);
+    const owner2 = fstatSync18(fd);
     try {
-      writeFileSync16(fd, JSON.stringify({ pid: process.pid }));
-      fsyncSync4(fd);
+      writeFileSync17(fd, JSON.stringify({ pid: process.pid }));
+      fsyncSync5(fd);
       this.sync();
       return await action();
     } finally {
-      closeSync17(fd);
+      closeSync18(fd);
       this.assert();
-      const now3 = lstatSync23(join45(this.directory, "operation.lock"));
+      const now3 = lstatSync24(join45(this.directory, "operation.lock"));
       if (owner2.dev !== now3.dev || owner2.ino !== now3.ino || !now3.isFile() || now3.isSymbolicLink())
         invalid6();
       unlinkSync6(join45(this.directory, "operation.lock"));
@@ -101731,7 +101979,7 @@ function base2(customer, organizationId) {
   };
 }
 function create3(directory, intent) {
-  if (!isAbsolute17(directory) || resolve19(directory) !== directory || realpathSync8(dirname21(directory)) !== dirname21(directory))
+  if (!isAbsolute17(directory) || resolve19(directory) !== directory || realpathSync8(dirname22(directory)) !== dirname22(directory))
     invalid6();
   mkdirSync17(directory, { mode: 448 });
   const owner2 = new RecoveryOwner(directory), checked = intentSchema.parse(intent), intentSha256 = canonicalJsonSha256(checked);
@@ -101790,7 +102038,7 @@ async function continueRecurringRecovery(customer, directory, options) {
       pending = state.phase === "pending";
       bindRecurringRecovery(customer, intent);
       await customer.assertCurrent();
-      const save = (next) => {
+      const save2 = (next) => {
         owner2.saveState(next, stateText);
         state = next;
         stateText = owner2.read("state.json");
@@ -101814,7 +102062,7 @@ async function continueRecurringRecovery(customer, directory, options) {
       } else {
         const consent2 = consentMatches(await customer.call("get", { consentId: intent.consentId }), intent);
         if (consent2.revokedAt !== null) {
-          save({ ...state, phase: "observed", consentId: consent2.consentId });
+          save2({ ...state, phase: "observed", consentId: consent2.consentId });
           return result2(consent2);
         }
         if (!captured.confirm)
@@ -101832,20 +102080,20 @@ async function continueRecurringRecovery(customer, directory, options) {
       owner2.assert();
       await active.assertCurrent();
       const previousUnknown = pending;
-      save({ ...state, phase: "pending", consentId: null });
+      save2({ ...state, phase: "pending", consentId: null });
       pending = true;
       let response;
       try {
         response = intent.operation === "activate" ? await active.call("activate", { draftId: intent.draftId, approval: intent.approval }) : await active.call("revoke", { consentId: intent.consentId });
       } catch (error61) {
         if (!previousUnknown && (error61 instanceof RemoteRecurringError || error61 instanceof RemoteRecurringReadError || error61 instanceof RemoteRecurringUnavailableError || error61 instanceof RecurringInputError)) {
-          save({ ...state, phase: "prepared", consentId: null });
+          save2({ ...state, phase: "prepared", consentId: null });
           pending = false;
         }
         throw error61;
       }
       const consentId = "consent" in response ? response.consent.consentId : response.consentId;
-      save({ ...state, phase: "observed", consentId });
+      save2({ ...state, phase: "observed", consentId });
       return result2(response);
     });
     pending = false;
@@ -101856,7 +102104,7 @@ async function continueRecurringRecovery(customer, directory, options) {
     throw error61;
   }
 }
-var uuid12, sha2, common2, intentSchema, stateSchema, invalid6 = () => {
+var uuid12, sha3, common2, intentSchema, stateSchema, invalid6 = () => {
   throw new RecurringCustomerError("RECURRING_RECOVERY_INVALID", "The original recovery directory or record is invalid or changed. Preserve it; do not create a replacement activation automatically.");
 };
 var init_recurring_recovery = __esm(() => {
@@ -101866,7 +102114,7 @@ var init_recurring_recovery = __esm(() => {
   init_remote_recurring();
   init_recurring_customer();
   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}$/);
-  sha2 = exports_external.string().regex(/^[a-f0-9]{64}$/);
+  sha3 = exports_external.string().regex(/^[a-f0-9]{64}$/);
   common2 = exports_external.object({
     contractVersion: exports_external.literal(1),
     apiOrigin: exports_external.string().min(1).max(4096),
@@ -101879,7 +102127,7 @@ var init_recurring_recovery = __esm(() => {
     common2.extend({
       operation: exports_external.literal("activate"),
       draftId: uuid12,
-      termsSha256: sha2,
+      termsSha256: sha3,
       approvalDeadline: exports_external.string().datetime(),
       approval: recurringActivationSchema
     }).strict(),
@@ -101887,7 +102135,7 @@ var init_recurring_recovery = __esm(() => {
   ]);
   stateSchema = exports_external.object({
     contractVersion: exports_external.literal(1),
-    intentSha256: sha2,
+    intentSha256: sha3,
     phase: exports_external.enum(["prepared", "pending", "observed"]),
     consentId: uuid12.nullable()
   }).strict();
@@ -103917,14 +104165,14 @@ var init_operation_tools = __esm(() => {
 
 // src/lib/feedback.ts
 import { appendFileSync as appendFileSync2, existsSync as existsSync29, mkdirSync as mkdirSync18 } from "fs";
-import { dirname as dirname22, join as join47 } from "path";
+import { dirname as dirname23, join as join47 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
   return join47(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
-  const dir = dirname22(dbPath);
+  const dir = dirname23(dbPath);
   if (!existsSync29(dir))
     mkdirSync18(dir, { recursive: true });
   const db = new Database(dbPath);
@@ -103953,7 +104201,7 @@ function saveFeedback(input2) {
   const category = input2.category ?? "general";
   if (isApiMode()) {
     const path = join47(getDataDir(), "feedback.jsonl");
-    const dir = dirname22(path);
+    const dir = dirname23(path);
     if (!existsSync29(dir))
       mkdirSync18(dir, { recursive: true });
     appendFileSync2(path, JSON.stringify({ message, category, email: input2.email ?? null, agent: input2.agent ?? null, version: input2.version ?? null, createdAt: new Date().toISOString() }) + `
@@ -104116,7 +104364,7 @@ var init_resource_meta_tools = __esm(() => {
 });
 
 // src/lib/scheduler.ts
-import { existsSync as existsSync30, readFileSync as readFileSync32, writeFileSync as writeFileSync17, mkdirSync as mkdirSync19 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync32, writeFileSync as writeFileSync18, mkdirSync as mkdirSync19 } from "fs";
 import { join as join48 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
   return join48(targetDir, ".skills", "schedules.json");
@@ -104135,7 +104383,7 @@ function saveSchedules(data, targetDir = process.cwd()) {
   const dir = join48(targetDir, ".skills");
   if (!existsSync30(dir))
     mkdirSync19(dir, { recursive: true });
-  writeFileSync17(path, JSON.stringify(data, null, 2));
+  writeFileSync18(path, JSON.stringify(data, null, 2));
 }
 function validateCronField(expr, min2, max2, label) {
   for (const part of expr.split(",")) {
@@ -104175,11 +104423,11 @@ function validateCronField(expr, min2, max2, label) {
   return { valid: true };
 }
 function validateCron(expr) {
-  const fields = expr.trim().split(/\s+/);
-  if (fields.length !== 5) {
-    return { valid: false, error: `Expected 5 fields, got ${fields.length}. Format: "minute hour day-of-month month day-of-week"` };
+  const fields2 = expr.trim().split(/\s+/);
+  if (fields2.length !== 5) {
+    return { valid: false, error: `Expected 5 fields, got ${fields2.length}. Format: "minute hour day-of-month month day-of-week"` };
   }
-  const [minuteF, hourF, domF, monthF, dowF] = fields;
+  const [minuteF, hourF, domF, monthF, dowF] = fields2;
   const checks4 = [
     { expr: minuteF, min: 0, max: 59, label: "minute" },
     { expr: hourF, min: 0, max: 23, label: "hour" },
@@ -104431,16 +104679,16 @@ var init_schedule_tools = __esm(() => {
 });
 
 // src/lib/native-storage.ts
-import { createHash as createHash22, createHmac as createHmac3 } from "crypto";
+import { createHash as createHash24, createHmac as createHmac3 } from "crypto";
 import {
   existsSync as existsSync31,
   mkdirSync as mkdirSync20,
   readFileSync as readFileSync33,
   readdirSync as readdirSync18,
   statSync as statSync17,
-  writeFileSync as writeFileSync18
+  writeFileSync as writeFileSync19
 } from "fs";
-import { dirname as dirname23, join as join49, normalize as normalize3, relative as relative7, sep as sep7 } from "path";
+import { dirname as dirname24, join as join49, normalize as normalize3, relative as relative7, sep as sep7 } from "path";
 function resolveSkillsNativeStorageConfig(env3 = process.env) {
   assertNoRetiredModeEnvVars(env3, {
     app: SKILLS_ENV_NAMESPACE,
@@ -104508,7 +104756,7 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash22("sha256").update(bytes).digest("hex"),
+        sha256: createHash24("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -104519,9 +104767,9 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
     files: files.sort((a, b) => a.path.localeCompare(b.path))
   };
 }
-function planSkillsS3SnapshotUpload(snapshot, options = {}) {
+function planSkillsS3SnapshotUpload(snapshot2, options = {}) {
   const prefix = normalizeS3Prefix(options.prefix);
-  return snapshot.files.map((file2) => ({
+  return snapshot2.files.map((file2) => ({
     path: file2.path,
     key: [prefix, file2.path.replace(/^\.?\//, "")].filter(Boolean).join("/"),
     sizeBytes: file2.sizeBytes,
@@ -104662,14 +104910,14 @@ function registerStorageTools(server) {
   }, async ({ directory: directory2, includeSchemaSql }) => {
     const targetDir = directory2 || process.cwd();
     const config2 = resolveStorageConfig();
-    const snapshot = exportSkillsLocalSnapshot(targetDir, { includeFileContents: false });
-    const s3Plan = config2.s3Bucket ? planSkillsS3SnapshotUpload(snapshot, { prefix: config2.s3Prefix }) : [];
+    const snapshot2 = exportSkillsLocalSnapshot(targetDir, { includeFileContents: false });
+    const s3Plan = config2.s3Bucket ? planSkillsS3SnapshotUpload(snapshot2, { prefix: config2.s3Prefix }) : [];
     return mcpJson({
       package: "skills",
       noNetwork: true,
       databaseConfigured: Boolean(config2.databaseUrl),
       s3Configured: Boolean(config2.s3Bucket),
-      snapshotFileCount: snapshot.files.length,
+      snapshotFileCount: snapshot2.files.length,
       s3ObjectCount: s3Plan.length,
       env: {
         databaseUrl: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
@@ -104800,73 +105048,73 @@ var init_private_publication_customer = __esm(() => {
 });
 
 // src/lib/private-publication-recovery.ts
-import { constants as constants17, closeSync as closeSync18, fsyncSync as fsyncSync5, fstatSync as fstatSync18, lstatSync as lstatSync24, mkdirSync as mkdirSync21, openSync as openSync18, readSync as readSync14, realpathSync as realpathSync9, renameSync as renameSync11, unlinkSync as unlinkSync7, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname24, isAbsolute as isAbsolute19, join as join50, resolve as resolve20 } from "path";
+import { constants as constants18, closeSync as closeSync19, fsyncSync as fsyncSync6, fstatSync as fstatSync19, lstatSync as lstatSync25, mkdirSync as mkdirSync21, openSync as openSync19, readSync as readSync15, realpathSync as realpathSync9, renameSync as renameSync11, unlinkSync as unlinkSync7, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname25, isAbsolute as isAbsolute19, join as join50, resolve as resolve20 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
 function safeDirectory(directory2) {
   if (!isAbsolute19(directory2) || directory2 !== resolve20(directory2) || realpathSync9(directory2) !== directory2)
-    return fail3();
-  for (let path = directory2;; path = dirname24(path)) {
-    const stat3 = lstatSync24(path);
+    return fail4();
+  for (let path = directory2;; path = dirname25(path)) {
+    const stat3 = lstatSync25(path);
     if (!stat3.isDirectory() || stat3.isSymbolicLink())
-      return fail3();
-    if (path === dirname24(path))
+      return fail4();
+    if (path === dirname25(path))
       break;
   }
-  const own2 = lstatSync24(directory2);
+  const own2 = lstatSync25(directory2);
   if ((own2.mode & 63) !== 0 || process.getuid && own2.uid !== process.getuid())
-    return fail3();
+    return fail4();
   return { dev: own2.dev, ino: own2.ino };
 }
 function unchangedDirectory(directory2, identity4) {
   const now3 = safeDirectory(directory2);
   if (now3.dev !== identity4.dev || now3.ino !== identity4.ino)
-    return fail3();
+    return fail4();
 }
 function readOwned(directory2, name, max2) {
   const identity4 = safeDirectory(directory2), file2 = join50(directory2, name);
-  const fd = openSync18(file2, constants17.O_RDONLY | constants17.O_NOFOLLOW);
+  const fd = openSync19(file2, constants18.O_RDONLY | constants18.O_NOFOLLOW);
   try {
-    const stat3 = fstatSync18(fd);
+    const stat3 = fstatSync19(fd);
     if (!stat3.isFile() || stat3.nlink !== 1 || stat3.size > max2 || stat3.size < 1 || (stat3.mode & 63) !== 0 || process.getuid && stat3.uid !== process.getuid())
-      return fail3();
+      return fail4();
     const buffer = Buffer.alloc(Math.min(max2, stat3.size) + 1);
     let length = 0;
     while (length < buffer.length) {
-      const count = readSync14(fd, buffer, length, buffer.length - length, length);
+      const count = readSync15(fd, buffer, length, buffer.length - length, length);
       if (count === 0)
         break;
       length += count;
     }
-    const bytes = buffer.subarray(0, length), after2 = fstatSync18(fd);
+    const bytes = buffer.subarray(0, length), after2 = fstatSync19(fd);
     unchangedDirectory(directory2, identity4);
     if (bytes.length !== stat3.size || stat3.size !== after2.size || stat3.mtimeMs !== after2.mtimeMs || stat3.ctimeMs !== after2.ctimeMs)
-      return fail3();
+      return fail4();
     return bytes;
   } finally {
-    closeSync18(fd);
+    closeSync19(fd);
   }
 }
 function writeOwned(directory2, name, bytes) {
-  const fd = openSync18(join50(directory2, name), constants17.O_WRONLY | constants17.O_CREAT | constants17.O_EXCL | constants17.O_NOFOLLOW, 384);
+  const fd = openSync19(join50(directory2, name), constants18.O_WRONLY | constants18.O_CREAT | constants18.O_EXCL | constants18.O_NOFOLLOW, 384);
   try {
-    writeFileSync19(fd, bytes);
-    fsyncSync5(fd);
+    writeFileSync20(fd, bytes);
+    fsyncSync6(fd);
   } finally {
-    closeSync18(fd);
+    closeSync19(fd);
   }
 }
-function save(directory2, value) {
+function save2(directory2, value) {
   const identity4 = safeDirectory(directory2), temporary = `.receipt-${randomUUID8()}.json`;
   writeOwned(directory2, temporary, JSON.stringify(value) + `
 `);
   unchangedDirectory(directory2, identity4);
   renameSync11(join50(directory2, temporary), join50(directory2, "receipt.json"));
-  const fd = openSync18(directory2, constants17.O_RDONLY | constants17.O_NOFOLLOW);
+  const fd = openSync19(directory2, constants18.O_RDONLY | constants18.O_NOFOLLOW);
   try {
-    fsyncSync5(fd);
+    fsyncSync6(fd);
   } finally {
-    closeSync18(fd);
+    closeSync19(fd);
   }
 }
 function bind2(client2, receipt) {
@@ -104877,22 +105125,22 @@ async function locked(directory2, action) {
   const identity4 = safeDirectory(directory2), file2 = join50(directory2, "operation.lock");
   let fd;
   try {
-    fd = openSync18(file2, constants17.O_WRONLY | constants17.O_CREAT | constants17.O_EXCL | constants17.O_NOFOLLOW, 384);
+    fd = openSync19(file2, constants18.O_WRONLY | constants18.O_CREAT | constants18.O_EXCL | constants18.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.");
   }
-  const lock = fstatSync18(fd);
+  const lock = fstatSync19(fd);
   try {
-    writeFileSync19(fd, JSON.stringify({ pid: process.pid }) + `
+    writeFileSync20(fd, JSON.stringify({ pid: process.pid }) + `
 `);
-    fsyncSync5(fd);
+    fsyncSync6(fd);
     return await action();
   } finally {
-    closeSync18(fd);
+    closeSync19(fd);
     unchangedDirectory(directory2, identity4);
-    const now3 = lstatSync24(file2);
+    const now3 = lstatSync25(file2);
     if (now3.dev !== lock.dev || now3.ino !== lock.ino || !now3.isFile() || now3.isSymbolicLink())
-      fail3();
+      fail4();
     unlinkSync7(file2);
   }
 }
@@ -104900,23 +105148,23 @@ function readPrivatePublicationRecovery(directory2) {
   try {
     const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(readOwned(directory2, "receipt.json", 65536)));
     if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== ["contractVersion", "apiOrigin", "organizationId", "userId", "membershipId", "skillId", "declaration", "phase", "intent"].sort().join(",") || value.contractVersion !== 1 || ![value.organizationId, value.userId, value.membershipId, value.skillId].every(publicationUuid) || typeof value.apiOrigin !== "string" || normalizeSkillsApiOrigin(value.apiOrigin) !== value.apiOrigin || !["prepared", "begin_uncertain", "awaiting_upload", "upload_uncertain", "uploaded", "finalize_uncertain", "observed"].includes(value.phase))
-      return fail3();
+      return fail4();
     value.declaration = checkedPublicationDeclaration(value.declaration);
     if (value.intent !== null)
       value.intent = checkedPublicationView(value.intent, value.skillId, undefined, value.declaration);
     if (value.intent === null && !["prepared", "begin_uncertain"].includes(value.phase))
-      return fail3();
+      return fail4();
     const bytes = readOwned(directory2, "bundle.tgz", PRIVATE_PUBLICATION_MAX_BYTES);
     if (bytes.length !== value.declaration.archiveByteSize || publicationSha256(bytes) !== value.declaration.archiveSha256)
-      return fail3();
+      return fail4();
     return { receipt: value, bytes };
   } catch {
-    return fail3();
+    return fail4();
   }
 }
 async function preparePrivatePublication(client2, sourceDirectory, recoveryDirectory, input2) {
   if (!publicationUuid(input2.skillId) || !(input2.expectedCurrentVersionId === null || publicationUuid(input2.expectedCurrentVersionId)) || input2.idempotencyKey !== undefined && !publicationUuid(input2.idempotencyKey))
-    return fail3();
+    return fail4();
   const packed = packSkillBundle(sourceDirectory, { maxUnpackedBytes: 32 * 1024 * 1024 });
   const inspected = await inspectSkillBundle(packed.bytes, { limits: { compressedBytes: PRIVATE_PUBLICATION_MAX_BYTES } });
   const manifest = inspected.entries.find((entry) => entry.path === "skill.json");
@@ -104942,18 +105190,18 @@ async function preparePrivatePublication(client2, sourceDirectory, recoveryDirec
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute19(recoveryDirectory) || resolve20(recoveryDirectory) !== recoveryDirectory || realpathSync9(dirname24(recoveryDirectory)) !== dirname24(recoveryDirectory))
-    return fail3();
+  if (!isAbsolute19(recoveryDirectory) || resolve20(recoveryDirectory) !== recoveryDirectory || realpathSync9(dirname25(recoveryDirectory)) !== dirname25(recoveryDirectory))
+    return fail4();
   mkdirSync21(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync18(dirname24(recoveryDirectory), constants17.O_RDONLY | constants17.O_NOFOLLOW);
+  const parent = openSync19(dirname25(recoveryDirectory), constants18.O_RDONLY | constants18.O_NOFOLLOW);
   try {
-    fsyncSync5(parent);
+    fsyncSync6(parent);
   } finally {
-    closeSync18(parent);
+    closeSync19(parent);
   }
   writeOwned(recoveryDirectory, "bundle.tgz", packed.bytes);
-  save(recoveryDirectory, receipt);
+  save2(recoveryDirectory, receipt);
   return receipt;
 }
 function privatePublicationResult(directory2, receipt) {
@@ -104974,7 +105222,7 @@ async function continuePrivatePublication(client2, directory2, options) {
   if (options.confirm !== true)
     throw new PrivatePublicationError("PUBLICATION_CONFIRM_REQUIRED", "Explicit upload confirmation is required.");
   if (options.waitMs !== undefined && (!Number.isSafeInteger(options.waitMs) || options.waitMs < 0 || options.waitMs > 300000))
-    return fail3();
+    return fail4();
   return locked(directory2, () => continueLocked(client2, directory2, options));
 }
 async function continueLocked(client2, directory2, options) {
@@ -104982,40 +105230,40 @@ async function continueLocked(client2, directory2, options) {
   bind2(client2, receipt);
   if (!receipt.intent) {
     receipt.phase = "begin_uncertain";
-    save(directory2, receipt);
+    save2(directory2, receipt);
     receipt.intent = await client2.begin(receipt.skillId, receipt.declaration);
     receipt.phase = "awaiting_upload";
-    save(directory2, receipt);
+    save2(directory2, receipt);
   } else {
     receipt.intent = checkedPublicationView(await client2.get(receipt.skillId, receipt.intent.id), receipt.skillId, receipt.intent.id, receipt.declaration);
-    save(directory2, receipt);
+    save2(directory2, receipt);
   }
   if (receipt.intent.state === "awaiting_upload") {
     if (receipt.phase === "awaiting_upload") {
       receipt.phase = "upload_uncertain";
-      save(directory2, receipt);
+      save2(directory2, receipt);
       try {
         await client2.upload(receipt.skillId, receipt.intent, bytes);
       } catch (error61) {
         if (error61 instanceof PrivatePublicationError && !error61.uncertain) {
           receipt.phase = "awaiting_upload";
-          save(directory2, receipt);
+          save2(directory2, receipt);
         }
         throw error61;
       }
       receipt.phase = "uploaded";
-      save(directory2, receipt);
+      save2(directory2, receipt);
     }
     receipt.phase = "finalize_uncertain";
-    save(directory2, receipt);
+    save2(directory2, receipt);
     receipt.intent = checkedPublicationView(await client2.finalize(receipt.skillId, receipt.intent.id), receipt.skillId, receipt.intent.id, receipt.declaration);
     receipt.phase = "observed";
-    save(directory2, receipt);
+    save2(directory2, receipt);
   }
   if (options.waitMs !== undefined && options.waitMs > 0 && ["queued", "verifying"].includes(receipt.intent.state)) {
     receipt.intent = checkedPublicationView(await client2.wait(receipt.skillId, receipt.intent.id, { timeoutMs: options.waitMs }), receipt.skillId, receipt.intent.id, receipt.declaration);
     receipt.phase = "observed";
-    save(directory2, receipt);
+    save2(directory2, receipt);
   }
   return privatePublicationResult(directory2, receipt);
 }
@@ -105027,12 +105275,12 @@ async function inspectLocked(client2, directory2, cancel) {
   bind2(client2, receipt);
   if (receipt.intent) {
     receipt.intent = checkedPublicationView(await (cancel ? client2.cancel(receipt.skillId, receipt.intent.id) : client2.get(receipt.skillId, receipt.intent.id)), receipt.skillId, receipt.intent.id, receipt.declaration);
-    save(directory2, receipt);
+    save2(directory2, receipt);
   } else if (cancel)
     throw new PrivatePublicationError("PUBLICATION_INTENT_UNKNOWN", "Reconcile the saved begin request with publication resume before cancelling its intent.");
   return privatePublicationResult(directory2, receipt);
 }
-var fail3 = () => {
+var fail4 = () => {
   throw new PrivatePublicationError("PUBLICATION_RECOVERY_INVALID", "The recovery directory is invalid or changed. Preserve it and inspect the existing intent; do not start a replacement automatically.");
 };
 var init_private_publication_recovery = __esm(() => {
@@ -105404,9 +105652,9 @@ var init_mcp2 = __esm(() => {
 });
 
 // src/cli/commands/runtime-mcp.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync22, readFileSync as readFileSync34, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync22, readFileSync as readFileSync34, writeFileSync as writeFileSync21 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname25, join as join51 } from "path";
+import { dirname as dirname26, join as join51 } from "path";
 async function handleMcp(options) {
   if (options.register) {
     let agents;
@@ -105580,8 +105828,8 @@ function writeJsonObject(path, data) {
 `);
 }
 function writeTextFile(path, content) {
-  mkdirSync22(dirname25(path), { recursive: true });
-  writeFileSync20(path, content.endsWith(`
+  mkdirSync22(dirname26(path), { recursive: true });
+  writeFileSync21(path, content.endsWith(`
 `) ? content : `${content}
 `);
 }
@@ -105690,8 +105938,8 @@ var exports_runtime = {};
 __export(exports_runtime, {
   registerRuntime: () => registerRuntime
 });
-import { createHash as createHash23, randomUUID as randomUUID9 } from "crypto";
-import { lstatSync as lstatSync25, mkdirSync as mkdirSync23, readFileSync as readFileSync35, realpathSync as realpathSync10, writeFileSync as writeFileSync21 } from "fs";
+import { createHash as createHash25, randomUUID as randomUUID9 } from "crypto";
+import { lstatSync as lstatSync26, mkdirSync as mkdirSync23, readFileSync as readFileSync35, realpathSync as realpathSync10, writeFileSync as writeFileSync22 } from "fs";
 import { basename as basename11, isAbsolute as isAbsolute21, join as join52 } from "path";
 import { createInterface } from "readline";
 function registerRuntime(parent) {
@@ -105731,9 +105979,9 @@ function registerRuntime(parent) {
       if (!expected)
         throw new Error("Cloud artifact not found");
       const bytes = await client2.download(id2, name);
-      if (bytes.length !== expected.byteSize || createHash23("sha256").update(bytes).digest("hex") !== expected.sha256)
+      if (bytes.length !== expected.byteSize || createHash25("sha256").update(bytes).digest("hex") !== expected.sha256)
         throw new Error("Cloud artifact integrity verification failed");
-      writeFileSync21(options.output, bytes, { flag: "wx", mode: 384 });
+      writeFileSync22(options.output, bytes, { flag: "wx", mode: 384 });
       console.log(JSON.stringify({ path: options.output, sha256: expected.sha256, byteSize: bytes.length }));
     } catch (error61) {
       console.error(JSON.stringify({ error: error61.message }));
@@ -106139,7 +106387,7 @@ async function handleRun(name, args2, options, separatorBeforeSkill) {
     try {
       parsePollingOptions(options);
       inputFiles = (options.file ?? []).map((path) => {
-        const info = lstatSync25(path);
+        const info = lstatSync26(path);
         if (!info.isFile() || info.size > 20 * 1024 * 1024)
           throw new Error("Input must be a regular file no larger than 20 MiB");
         return { name: basename11(path), bytes: new Uint8Array(readFileSync35(path)) };
@@ -106530,7 +106778,7 @@ async function handleExportsDownload(runId2, options) {
       const relativePath = safeArtifactRelativePath(typeof artifact.relativePath === "string" ? artifact.relativePath : artifact.fileName, String(artifact.fileName || artifactId));
       const outputPath = join52(exportDir, relativePath);
       ensureSafeExportParent(exportDir, relativePath);
-      writeFileSync21(outputPath, verified.bytes, { flag: "wx", mode: 384 });
+      writeFileSync22(outputPath, verified.bytes, { flag: "wx", mode: 384 });
       downloaded.push({ id: artifactId, path: outputPath, byteSize: verified.byteSize });
     }
     const payload = {
@@ -106569,7 +106817,7 @@ function ensureSafeExportParent(root2, relativePath) {
     if (part)
       parent = join52(parent, part);
     try {
-      if (!lstatSync25(parent).isDirectory() || lstatSync25(parent).isSymbolicLink())
+      if (!lstatSync26(parent).isDirectory() || lstatSync26(parent).isSymbolicLink())
         throw new Error("Unsafe artifact directory");
     } catch (error61) {
       if (error61.code !== "ENOENT")
@@ -106861,30 +107109,30 @@ var exports_recurring = {};
 __export(exports_recurring, {
   registerRecurringCommands: () => registerRecurringCommands
 });
-import { constants as constants18, closeSync as closeSync19, fstatSync as fstatSync19, lstatSync as lstatSync26, openSync as openSync19, readSync as readSync15 } from "fs";
+import { constants as constants19, closeSync as closeSync20, fstatSync as fstatSync20, lstatSync as lstatSync27, openSync as openSync20, readSync as readSync16 } from "fs";
 import { createInterface as createInterface2 } from "readline";
 function readRequest(path) {
-  const fd = openSync19(path, constants18.O_RDONLY | constants18.O_NOFOLLOW | constants18.O_NONBLOCK);
+  const fd = openSync20(path, constants19.O_RDONLY | constants19.O_NOFOLLOW | constants19.O_NONBLOCK);
   try {
-    const before2 = fstatSync19(fd);
+    const before2 = fstatSync20(fd);
     if (!before2.isFile() || before2.size > 1048576 || before2.size < 1)
       throw new RecurringInputError;
     const bytes = Buffer.alloc(before2.size + 1);
     let length = 0;
     while (length < bytes.length) {
-      const n2 = readSync15(fd, bytes, length, bytes.length - length, length);
+      const n2 = readSync16(fd, bytes, length, bytes.length - length, length);
       if (!n2)
         break;
       length += n2;
     }
-    const after2 = fstatSync19(fd), current = lstatSync26(path);
+    const after2 = fstatSync20(fd), current = lstatSync27(path);
     if (length !== before2.size || after2.size !== before2.size || before2.mtimeMs !== after2.mtimeMs || before2.ctimeMs !== after2.ctimeMs || current.dev !== before2.dev || current.ino !== before2.ino || !current.isFile() || current.isSymbolicLink())
       throw new RecurringInputError;
     return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length)));
   } catch {
     throw new RecurringInputError;
   } finally {
-    closeSync19(fd);
+    closeSync20(fd);
   }
 }
 async function acceptAtTerminal(draft) {
@@ -107310,22 +107558,22 @@ var init_portable_snapshot_filter = __esm(() => {
 });
 
 // src/lib/station-snapshot.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash26 } from "crypto";
 import {
   copyFileSync,
   mkdirSync as mkdirSync24,
   readFileSync as readFileSync36,
   statSync as statSync19,
-  writeFileSync as writeFileSync22
+  writeFileSync as writeFileSync23
 } from "fs";
-import { dirname as dirname27, isAbsolute as isAbsolute22, relative as relative8, resolve as resolve21, sep as sep9 } from "path";
+import { dirname as dirname28, isAbsolute as isAbsolute22, relative as relative8, resolve as resolve21, sep as sep9 } from "path";
 function validateStationId(stationId) {
   if (!/^[a-z0-9-]+$/.test(stationId)) {
     throw new StationSnapshotError("INVALID_STATION", `station id must be a slug, got: ${stationId}`);
   }
 }
 function sha256File(filePath) {
-  return createHash24("sha256").update(readFileSync36(filePath)).digest("hex");
+  return createHash26("sha256").update(readFileSync36(filePath)).digest("hex");
 }
 function scanHome(definition, homesRoot) {
   const homePath = homePathFor(definition, homesRoot);
@@ -107446,11 +107694,11 @@ function writeStationSnapshot(options) {
   let written = 0;
   for (const plan of untouched) {
     const destination = resolve21(repoRoot, plan.destination);
-    mkdirSync24(dirname27(destination), { recursive: true });
+    mkdirSync24(dirname28(destination), { recursive: true });
     copyFileSync(plan.source.fullPath, destination);
     written += 1;
   }
-  const unchanged2 = plans.length - untouched.length;
+  const unchanged3 = plans.length - untouched.length;
   const manifest = {
     schema: STATION_SYNC_MANIFEST_SCHEMA,
     stationId: options.stationId,
@@ -107458,20 +107706,20 @@ function writeStationSnapshot(options) {
     producer: STATION_SNAPSHOT_PRODUCER,
     stats: {
       written,
-      unchanged: unchanged2,
+      unchanged: unchanged3,
       files: plans.length,
       bytes: totalBytes
     },
     files: manifestFiles
   };
   const manifestPath = resolve21(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
-  mkdirSync24(dirname27(manifestPath), { recursive: true });
-  writeFileSync22(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  mkdirSync24(dirname28(manifestPath), { recursive: true });
+  writeFileSync23(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return {
     ...base3,
     mode: "populate",
-    stats: { files: plans.length, bytes: totalBytes, written, unchanged: unchanged2 },
+    stats: { files: plans.length, bytes: totalBytes, written, unchanged: unchanged3 },
     manifestPath
   };
 }
@@ -107932,7 +108180,7 @@ async function connectCodexHookRpc(options) {
   });
   const pending = new Map;
   let nextId = 1, buffer = Buffer.alloc(0), stopped = false, diagnosticBytes = 0;
-  const fail4 = () => {
+  const fail5 = () => {
     stopped = true;
     for (const value of pending.values()) {
       clearTimeout(value.timer);
@@ -107940,19 +108188,19 @@ async function connectCodexHookRpc(options) {
     }
     pending.clear();
   };
-  child.on("error", fail4);
-  child.on("exit", fail4);
-  child.stdin.on("error", fail4);
+  child.on("error", fail5);
+  child.on("exit", fail5);
+  child.stdin.on("error", fail5);
   child.stderr.on("data", (bytes) => {
     diagnosticBytes += bytes.length;
     if (diagnosticBytes > 2 * 1024 * 1024) {
-      fail4();
+      fail5();
       child.kill();
     }
   });
   child.stdout.on("data", (bytes) => {
     if (buffer.length + bytes.length > 8 * 1024 * 1024) {
-      fail4();
+      fail5();
       child.kill();
       return;
     }
@@ -107967,12 +108215,12 @@ async function connectCodexHookRpc(options) {
       try {
         value = JSON.parse(line.toString("utf8"));
       } catch {
-        fail4();
+        fail5();
         child.kill();
         return;
       }
       if (!value || typeof value !== "object" || Array.isArray(value)) {
-        fail4();
+        fail5();
         child.kill();
         return;
       }
@@ -107996,7 +108244,7 @@ async function connectCodexHookRpc(options) {
       return new Promise((resolve22, reject2) => {
         const id2 = nextId++;
         const timer = setTimeout(() => {
-          fail4();
+          fail5();
           child.kill();
         }, 20000);
         pending.set(id2, { resolve: resolve22, reject: reject2, timer });
@@ -108005,7 +108253,7 @@ async function connectCodexHookRpc(options) {
       });
     },
     async close() {
-      fail4();
+      fail5();
       child.stdin.end();
       if (child.exitCode !== null || child.signalCode !== null)
         return;
@@ -108036,203 +108284,10 @@ var init_codex_hook_rpc = __esm(() => {
   SUPPORTED_CODEX_HOOK_VERSIONS = ["codex-cli 0.153.0", "codex-cli 0.154.0", "codex-cli 0.155.0", "codex-cli 0.155.1"];
 });
 
-// src/lib/codex-hook-trust-layout.ts
-import { isDeepStrictEqual as isDeepStrictEqual5 } from "util";
-function codexTrustTextWitness(text3, keys3, canonicalize = true) {
-  const parsed = Bun.TOML.parse(text3), wanted = new Set(keys3);
-  const headers = [...text3.matchAll(/^[ \t]*(\[[^\r\n]+\])[ \t]*(#[^\r\n]*)?(?:\r?\n|$)/gm)];
-  if (headers.length > 512)
-    throw fail4();
-  let root2 = parsed;
-  for (const header of headers) {
-    try {
-      root2 = Bun.TOML.parse(text3.slice(0, header.index));
-      break;
-    } catch {}
-  }
-  if (root2.hooks !== undefined)
-    throw fail4();
-  const replacements2 = [];
-  const stateSections = [];
-  for (const [index, header] of headers.entries()) {
-    let shape;
-    try {
-      shape = Bun.TOML.parse(header[1]);
-    } catch {
-      continue;
-    }
-    const state = shape.hooks?.state;
-    if (!state || Object.keys(shape).length !== 1 || Object.keys(shape.hooks).length !== 1)
-      continue;
-    const names = Object.keys(state), start = header.index, end = headers[index + 1]?.index ?? text3.length;
-    if (names.length === 0) {
-      replacements2.push({ start, end: start + header[0].length, comments: header[2] ? header[2] + `
-` : "" });
-      stateSections.push({ start, end: start + header[0].length });
-    } else if (names.length === 1 && !Object.keys(state[names[0]]).length) {
-      stateSections.push({ start, end });
-      if (!wanted.has(names[0])) {
-        replacements2.push({ start, end: start + header[0].length, comments: `[hooks.state.${JSON.stringify(names[0])}]${header[2] ? " " + header[2] : ""}
-` });
-        continue;
-      }
-      const comments = header[2] ? [header[2]] : [];
-      for (const line of text3.slice(start + header[0].length, end).split(/\r?\n/)) {
-        if (!line.trim())
-          continue;
-        if (/^[ \t]*#/.test(line)) {
-          comments.push(line);
-          continue;
-        }
-        const field2 = /^[ \t]*(?:enabled|trusted_hash)[ \t]*=[ \t]*(?:true|false|"(?:[^"\\]|\\.)*"|'[^']*')[ \t]*(#[^\r\n]*)?$/.exec(line);
-        if (!field2)
-          throw fail4();
-        if (field2[1])
-          comments.push(field2[1]);
-      }
-      replacements2.push({ start, end, comments: comments.join(`
-`) + `
-` });
-    }
-  }
-  let noState = text3;
-  for (const span of [...stateSections].reverse())
-    noState = noState.slice(0, span.start) + noState.slice(span.end);
-  const expected = structuredClone(parsed);
-  if (expected.hooks)
-    delete expected.hooks.state;
-  try {
-    if (!isDeepStrictEqual5(prune(Bun.TOML.parse(noState)), prune(expected)))
-      throw fail4();
-  } catch {
-    throw fail4();
-  }
-  let result2 = text3;
-  for (const span of replacements2.reverse())
-    result2 = result2.slice(0, span.start) + span.comments + result2.slice(span.end);
-  return (canonicalize ? canonicalizeTableOrder(result2) : result2).split(/\r?\n/).filter((line) => line.trim()).join(`
-`);
-}
-function codexTrustReconcileWitness(text3, keys3) {
-  return codexTrustTextWitness(text3, keys3, false).replace(/[ \t]+$/gm, "");
-}
-function codexTrustUnmanagedSemantic(text3, keys3) {
-  const parsed = structuredClone(Bun.TOML.parse(text3));
-  for (const key of keys3)
-    if (parsed.hooks?.state?.[key] !== undefined)
-      delete parsed.hooks.state[key];
-  return JSON.stringify(stableSemantic(prune(parsed)));
-}
-var fail4 = () => new Error('CODEX_HOOK_TRUST_UNSUPPORTED_LAYOUT: preserve and convert hook trust to ordinary [hooks.state."<key>"] tables before enrollment'), prune = (value) => {
-  if (value.hooks?.state && !Object.keys(value.hooks.state).length)
-    delete value.hooks.state;
-  if (value.hooks && !Object.keys(value.hooks).length)
-    delete value.hooks;
-  return value;
-}, canonicalizeTableOrder = (text3) => {
-  const headers = [...text3.matchAll(/^[ \t]*(\[\[?[^\r\n]+\]\]?)[ \t]*(#[^\r\n]*)?(?:\r?\n|$)/gm)];
-  if (!headers.length)
-    return text3;
-  const keys3 = headers.map((header) => header[1].trim());
-  const repeated = keys3.filter((key) => !key.startsWith("[[")).filter((key, index, simple2) => simple2.indexOf(key) !== index);
-  const arrayKeys = keys3.filter((key) => key.startsWith("[["));
-  const plain = keys3.map((key) => key.replace(/^\[\[?/, "").replace(/\]\]?$/, "").trim());
-  const parentChild = plain.some((key, index) => plain.some((other, otherIndex) => index !== otherIndex && (other.startsWith(`${key}.`) || key.startsWith(`${other}.`))));
-  if (repeated.length || parentChild)
-    return text3;
-  if (!arrayKeys.length) {
-    const first2 = headers[0].index;
-    const prefix2 = text3.slice(0, first2);
-    const blocks2 = headers.map((header, index) => ({
-      key: header[1],
-      order: index,
-      text: text3.slice(header.index, headers[index + 1]?.index ?? text3.length)
-    }));
-    blocks2.sort((a, b) => a.key.localeCompare(b.key) || a.order - b.order);
-    return prefix2 + blocks2.map((block) => block.text).join("");
-  }
-  const first = headers[0].index;
-  const prefix = text3.slice(0, first);
-  const blocks = headers.map((header, index) => ({
-    key: header[1],
-    order: index,
-    text: text3.slice(header.index, headers[index + 1]?.index ?? text3.length)
-  }));
-  const simple = blocks.filter((block) => !block.key.startsWith("[["));
-  const arrays = blocks.filter((block) => block.key.startsWith("[["));
-  return prefix + [...simple, ...arrays].map((block) => block.text).join("");
-}, stableSemantic = (value) => {
-  if (Array.isArray(value))
-    return value.map(stableSemantic);
-  if (value && typeof value === "object")
-    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stableSemantic(value[key])]));
-  return value;
-};
-var init_codex_hook_trust_layout = () => {};
-
-// src/lib/codex-hook-trust-files.ts
-import { closeSync as closeSync20, constants as constants19, fstatSync as fstatSync20, fsyncSync as fsyncSync6, lstatSync as lstatSync27, openSync as openSync20, readSync as readSync16, writeFileSync as writeFileSync23 } from "fs";
-import { createHash as createHash25 } from "crypto";
-import { dirname as dirname28 } from "path";
-function need4(value, code2) {
-  if (!value)
-    throw new Error(`CODEX_HOOK_TRUST_${code2}`);
-}
-function safeParents(file2) {
-  for (let p = dirname28(file2);; p = dirname28(p)) {
-    const s = lstatSync27(p);
-    need4(s.isDirectory() && !s.isSymbolicLink(), "UNSAFE_PARENT");
-    need4((s.mode & 18) === 0 || s.uid === 0 && (s.mode & 512) !== 0, "UNSAFE_PARENT");
-    if (dirname28(p) === p)
-      break;
-  }
-}
-function snapshot(file2, privateFile = false, options = {}) {
-  const readOnlyPackage = options.readOnlyPackage === true && !privateFile;
-  safeParents(file2);
-  const initial2 = lstatSync27(file2, { bigint: true });
-  need4(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");
-  need4(initial2.size <= 8n * 1024n * 1024n, "FILE_BOUND");
-  const fd = openSync20(file2, constants19.O_RDONLY | constants19.O_NOFOLLOW | constants19.O_NONBLOCK);
-  try {
-    const before2 = fstatSync20(fd, { bigint: true });
-    need4(sameStat(initial2, before2), "INPUT_CHANGED");
-    const bytes = Buffer.alloc(Number(before2.size) + 1);
-    let length = 0;
-    while (length < bytes.length) {
-      const n2 = readSync16(fd, bytes, length, bytes.length - length, null);
-      if (!n2)
-        break;
-      length += n2;
-    }
-    need4(length === Number(before2.size) && sameStat(before2, fstatSync20(fd, { bigint: true })) && sameStat(before2, lstatSync27(file2, { bigint: true })), "INPUT_CHANGED");
-    const content = bytes.subarray(0, length), text3 = new TextDecoder("utf-8", { fatal: true }).decode(content);
-    return { file: file2, privateFile, readOnlyPackage, text: text3, bytes: content, stat: before2, sha256: createHash25("sha256").update(content).digest("hex") };
-  } finally {
-    closeSync20(fd);
-  }
-}
-function unchanged2(before2) {
-  const after2 = snapshot(before2.file, before2.privateFile, before2.readOnlyPackage ? { readOnlyPackage: true } : {});
-  need4(sameStat(before2.stat, after2.stat) && after2.sha256 === before2.sha256, "INPUT_CHANGED");
-}
-function save2(file2, content) {
-  safeParents(file2);
-  const fd = openSync20(file2, constants19.O_WRONLY | constants19.O_CREAT | constants19.O_EXCL | constants19.O_NOFOLLOW, 384);
-  try {
-    writeFileSync23(fd, content);
-    fsyncSync6(fd);
-  } finally {
-    closeSync20(fd);
-  }
-}
-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/lib/codex-hook-trust-identity.ts
 import { realpathSync as realpathSync12 } from "fs";
 import { dirname as dirname29, isAbsolute as isAbsolute24, join as join55 } from "path";
-import { isDeepStrictEqual as isDeepStrictEqual6 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual7 } from "util";
 function inspectRecordedSkillsCli(command, expected) {
   need4(isAbsolute24(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
   const resolved = realpathSync12(command);
@@ -108242,7 +108297,7 @@ function inspectRecordedSkillsCli(command, expected) {
   need4(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join55(dirname29(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
   need4((cli.stat.mode & 0o100n) !== 0n, "SKILLS_COMMAND_NOT_EXECUTABLE");
   const receipt = { path: resolved, version: pkg.version, sha256: cli.sha256, manifestSha256: manifest.sha256 };
-  need4(isDeepStrictEqual6(receipt, expected), "RECONCILE_SKILLS_BINDING_CHANGED");
+  need4(isDeepStrictEqual7(receipt, expected), "RECONCILE_SKILLS_BINDING_CHANGED");
   return { receipt, recheck() {
     need4(realpathSync12(command) === resolved, "SKILLS_COMMAND_CHANGED");
     unchanged2(cli);
@@ -108278,19 +108333,19 @@ var init_codex_hook_trust_identity = __esm(() => {
 });
 
 // src/lib/codex-hook-policy-recovery.ts
-import { isDeepStrictEqual as isDeepStrictEqual7 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual8 } from "util";
 function reviewedClaudeDiscoveryChange(beforeText, currentText, options) {
   need4(typeof options.reason === "string" && options.reason.trim().length > 0 && options.reason.length <= 512 && !/[\x00-\x1f\x7f]/.test(options.reason), "RECONCILE_RECOVERY_REASON_REQUIRED");
   need4(options.reviewedPlanDigest === undefined || /^[a-f0-9]{64}$/.test(options.reviewedPlanDigest), "RECONCILE_RECOVERY_PLAN_CHANGED");
   const before2 = parseManagedSkillPolicy(beforeText), current = parseManagedSkillPolicy(currentText);
   const oldDiscovery = before2.bridge?.discovery?.claude, newDiscovery = current.bridge?.discovery?.claude;
   need4(oldDiscovery?.agent === "claude" && newDiscovery?.agent === "claude" && oldDiscovery.method === "reviewed" && newDiscovery.method === "reviewed", "RECONCILE_POLICY_CHANGED");
-  const changes = ["roots", "sources"].filter((key) => !isDeepStrictEqual7(oldDiscovery[key], newDiscovery[key])).map((key) => ({ path: `bridge.discovery.claude.${key}`, before: oldDiscovery[key], after: newDiscovery[key] }));
+  const changes = ["roots", "sources"].filter((key) => !isDeepStrictEqual8(oldDiscovery[key], newDiscovery[key])).map((key) => ({ path: `bridge.discovery.claude.${key}`, before: oldDiscovery[key], after: newDiscovery[key] }));
   need4(changes.length > 0, "RECONCILE_POLICY_CHANGED");
   const compared = structuredClone(current);
   compared.bridge.discovery.claude.roots = oldDiscovery.roots;
   compared.bridge.discovery.claude.sources = oldDiscovery.sources;
-  need4(isDeepStrictEqual7(before2, compared), "RECONCILE_POLICY_CHANGED");
+  need4(isDeepStrictEqual8(before2, compared), "RECONCILE_POLICY_CHANGED");
   verifyAgentDiscovery(newDiscovery);
   return { reason: options.reason, changes };
 }
@@ -108302,21 +108357,21 @@ var init_codex_hook_policy_recovery = __esm(() => {
 
 // src/lib/agent-codex-trust.ts
 import { lstatSync as lstatSync28, mkdirSync as mkdirSync25, readdirSync as readdirSync20, readFileSync as readFileSync37, realpathSync as realpathSync13, statSync as statSync21 } from "fs";
-import { createHash as createHash26, randomUUID as randomUUID10 } from "crypto";
+import { createHash as createHash27, randomUUID as randomUUID10 } from "crypto";
 import { execFileSync } from "child_process";
 import { dirname as dirname30, isAbsolute as isAbsolute25, join as join56, resolve as resolve22 } from "path";
 import { homedir as homedir11 } from "os";
-import { isDeepStrictEqual as isDeepStrictEqual8 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual9 } from "util";
 function verifyReleaseArtifact(proof, skillsCli) {
   need4(isAbsolute25(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
   const tarPath = realpathSync13(proof.packageTarPath);
   need4(statSync21(tarPath).isFile(), "RECONCILE_RELEASE_PROVENANCE_PATH");
   const tarBytes = readFileSync37(tarPath);
-  need4(tarBytes.byteLength === proof.packageTarBytes && createHash26("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
+  need4(tarBytes.byteLength === proof.packageTarBytes && createHash27("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
   const packageRoot = dirname30(dirname30(realpathSync13(skillsCli.receipt.path)));
   const manifest = readFileSync37(join56(packageRoot, "package.json"));
-  need4(createHash26("sha256").update(manifest).digest("hex") === skillsCli.receipt.manifestSha256 && skillsCli.receipt.manifestSha256 === proof.manifestSha256, "RECONCILE_RELEASE_MANIFEST_CHANGED");
-  need4(createHash26("sha256").update(readFileSync37(skillsCli.receipt.path)).digest("hex") === proof.executableSha256 && skillsCli.receipt.sha256 === proof.executableSha256, "RECONCILE_RELEASE_EXECUTABLE_CHANGED");
+  need4(createHash27("sha256").update(manifest).digest("hex") === skillsCli.receipt.manifestSha256 && skillsCli.receipt.manifestSha256 === proof.manifestSha256, "RECONCILE_RELEASE_MANIFEST_CHANGED");
+  need4(createHash27("sha256").update(readFileSync37(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", readFileSync37(skillsCli.receipt.path)]];
   for (const [member, expected] of members2) {
     let actual;
@@ -108348,7 +108403,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     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 };
     need4(makePlanDigest(digestInput) === intent.planDigest, "RECONCILE_PLAN_CHANGED");
-    need4(isDeepStrictEqual8(intent.hooks, admitted.filter((hook) => !hook.enabled || hook.trustStatus !== "trusted")), "RECONCILE_INTENT_HOOKS_CHANGED");
+    need4(isDeepStrictEqual9(intent.hooks, admitted.filter((hook) => !hook.enabled || hook.trustStatus !== "trusted")), "RECONCILE_INTENT_HOOKS_CHANGED");
     need4(configBefore.sha256 === (intent.beforeSha256 ?? intent.configSha256) && hooksBefore.sha256 === intent.hooksSha256 && policyBefore.sha256 === intent.policySha256, "RECONCILE_JOURNAL_CHANGED");
     const policyCurrent = snapshot(join56(dataDir3, "agent-policy.json"), true);
     const recovery = options.claudeDiscoveryRecovery;
@@ -108358,7 +108413,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     if (policyCurrent.sha256 !== policyBefore.sha256 && !recovery) {
       need4(options.supersedeBinding === true, "RECONCILE_POLICY_CHANGED");
       const oldPolicy = JSON.parse(policyBefore.text), currentPolicy = JSON.parse(policyCurrent.text);
-      need4(isDeepStrictEqual8(withoutCodexCommand(oldPolicy), withoutCodexCommand(currentPolicy)), "RECONCILE_POLICY_CHANGED");
+      need4(isDeepStrictEqual9(withoutCodexCommand(oldPolicy), withoutCodexCommand(currentPolicy)), "RECONCILE_POLICY_CHANGED");
       supersededBinding = true;
     }
     if (supersededBinding || recovery) {
@@ -108371,7 +108426,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     const witnessSame = codexTrustReconcileWitness(configBefore.text, managedKeys) === codexTrustReconcileWitness(currentConfig.text, managedKeys);
     const unmanagedSame = codexTrustUnmanagedSemantic(configBefore.text, managedKeys) === codexTrustUnmanagedSemantic(currentConfig.text, managedKeys);
     need4(unmanagedSame && (witnessSame || supersededBinding), "RECONCILE_UNRELATED_CONFIG_CHANGED");
-    const before2 = structure(configBefore.text), current = structure(currentConfig.text), expectedConfig = structuredClone(before2);
+    const before2 = structure2(configBefore.text), current = structure2(currentConfig.text), expectedConfig = structuredClone(before2);
     expectedConfig.hooks ??= {};
     expectedConfig.hooks.state ??= {};
     for (const hook of intent.hooks)
@@ -108382,16 +108437,17 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
         need4(state?.enabled === true && typeof state.trusted_hash === "string" && /^sha256:[a-f0-9]{64}$/.test(state.trusted_hash), "RECONCILE_CONFIG_DRIFT");
       }
     } else
-      need4(isDeepStrictEqual8(expectedConfig, current), "RECONCILE_CONFIG_DRIFT");
+      need4(isDeepStrictEqual9(expectedConfig, current), "RECONCILE_CONFIG_DRIFT");
     const policy = parseManagedSkillPolicy(policyCurrent.text), binding = policy.bridge;
-    assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home });
+    const configDiscoveryRecovery = recovery && binding.discovery?.codex ? createCodexHookDiscoveryRecovery(binding.discovery.codex, configBefore, currentConfig, intent.hooks) : undefined;
+    assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home, codexDiscoveryRecovery: configDiscoveryRecovery });
     const recoveryCli = recovery ? bindSkillsCli("skills", options.reviewedSkillsCli) : undefined;
     if (recoveryCli)
       verifyReleaseArtifact(options.releaseProof, recoveryCli);
     const skillsCli = recovery ? inspectRecordedSkillsCli(binding.commands.codex, intent.skillsCli) : bindSkillsCli(binding.commands.codex, options.reviewedSkillsCli);
     if (supersededBinding)
       verifyReleaseArtifact(options.releaseProof, skillsCli);
-    const skillsBindingChanged = !isDeepStrictEqual8(skillsCli.receipt, intent.skillsCli);
+    const skillsBindingChanged = !isDeepStrictEqual9(skillsCli.receipt, intent.skillsCli);
     need4(!skillsBindingChanged || supersededBinding, "RECONCILE_SKILLS_BINDING_CHANGED");
     const alias = binding.rootAliases?.find((item) => item.agent === "codex"), physicalRoot = alias?.target ?? join56(home, ".codex"), hooksPath = join56(physicalRoot, "hooks.json");
     need4(resolve22(intent.configPath) === resolve22(join56(physicalRoot, "config.toml")), "RECONCILE_CONFIG_PATH_CHANGED");
@@ -108404,7 +108460,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
       const currentDeclarations = JSON.parse(hooksCurrent.text).hooks;
       for (const [event, [nativeEvent]] of Object.entries(eventNames)) {
         const command = renderAgentHookCommand(binding.commands.codex, "codex", binding.profiles.codex, event);
-        need4(isDeepStrictEqual8(currentDeclarations?.[event], [{ hooks: [{ type: "command", command, timeout: 15 }] }]), "RECONCILE_BINDING_HOOK_CHANGED");
+        need4(isDeepStrictEqual9(currentDeclarations?.[event], [{ hooks: [{ type: "command", command, timeout: 15 }] }]), "RECONCILE_BINDING_HOOK_CHANGED");
       }
     }
     rpc = await connect({ command: options.codexCommand ?? "codex", home, codexHome });
@@ -108427,9 +108483,9 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
           delete identity4.command;
         return identity4;
       };
-      need4(isDeepStrictEqual8(stable(actual), stable(expected)), "RECONCILE_NATIVE_IDENTITY_CHANGED");
+      need4(isDeepStrictEqual9(stable(actual), stable(expected)), "RECONCILE_NATIVE_IDENTITY_CHANGED");
       if (!plannedKeys.has(expected.key))
-        need4(isDeepStrictEqual8(actual, expected), "RECONCILE_UNRELATED_HOOK_CHANGED");
+        need4(isDeepStrictEqual9(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(join56(home, ".codex/hooks.json"), hooksPath));
@@ -108446,12 +108502,12 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     }
     const config2 = await rpc.request("config/read", { includeLayers: true, cwd: home });
     const layers = config2?.layers?.filter((layer) => layer.name?.type === "user" && layer.name.file === nativeConfigPath && !layer.name.profile);
-    need4(layers?.length === 1 && !layers[0].disabledReason && isDeepStrictEqual8(layers[0].config, current), "RECONCILE_NATIVE_CONFIG_MISMATCH");
+    need4(layers?.length === 1 && !layers[0].disabledReason && isDeepStrictEqual9(layers[0].config, current), "RECONCILE_NATIVE_CONFIG_MISMATCH");
     const finalDiscovery = await rpc.request("hooks/list", { cwds: [home] });
-    need4(Array.isArray(finalDiscovery?.data) && finalDiscovery.data.length === 1 && finalDiscovery.data[0].cwd === home && !finalDiscovery.data[0].errors?.length && !finalDiscovery.data[0].warnings?.length && (!recordedNativeHooks || isDeepStrictEqual8(finalDiscovery.data[0].hooks.map(safeNativeHook), nativeHooks.map(safeNativeHook))), "RECONCILE_NATIVE_STATE_CHANGED");
+    need4(Array.isArray(finalDiscovery?.data) && finalDiscovery.data.length === 1 && finalDiscovery.data[0].cwd === home && !finalDiscovery.data[0].errors?.length && !finalDiscovery.data[0].warnings?.length && (!recordedNativeHooks || isDeepStrictEqual9(finalDiscovery.data[0].hooks.map(safeNativeHook), nativeHooks.map(safeNativeHook))), "RECONCILE_NATIVE_STATE_CHANGED");
     const finalConfig = await rpc.request("config/read", { includeLayers: true, cwd: home });
     const finalLayers = finalConfig?.layers?.filter((layer) => layer.name?.type === "user" && layer.name.file === nativeConfigPath && !layer.name.profile);
-    need4(finalLayers?.length === 1 && !finalLayers[0].disabledReason && isDeepStrictEqual8(finalLayers[0].config, current), "RECONCILE_NATIVE_CONFIG_CHANGED");
+    need4(finalLayers?.length === 1 && !finalLayers[0].disabledReason && isDeepStrictEqual9(finalLayers[0].config, current), "RECONCILE_NATIVE_CONFIG_CHANGED");
     if (recovery) {
       for (const response of [config2, finalConfig]) {
         const layerIndex = response.layers.findIndex((layer) => layer.name?.type === "user" && layer.name.file === nativeConfigPath && !layer.name.profile);
@@ -108470,16 +108526,16 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     unchanged2(hooksCurrent);
     unchanged2(currentConfig);
     skillsCli.recheck();
-    assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home });
-    const recoveryPlan = recovery ? { version: 1, kind: "claude-discovery-only", journal, journalIntentSha256: intentFile.sha256, stoppedSha256: stoppedFile.sha256, originalPlanDigest: intent.planDigest, policyBeforeSha256: policyBefore.sha256, policyCurrentSha256: policyCurrent.sha256, configBeforeSha256: configBefore.sha256, configCurrentSha256: currentConfig.sha256, hooksSha256: hooksCurrent.sha256, nativeConfigPath, nativeVersion: rpc.version, nativeInventorySha256: makePlanDigest(nativeHooks.map(safeNativeHook)), recordedNativeInventorySha256: makePlanDigest(recordedNativeHooks), boundSkillsCli: skillsCli.receipt, recoveryCli: recoveryCli.receipt, releaseProof: options.releaseProof, ...policyChange } : undefined;
+    assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home, codexDiscoveryRecovery: configDiscoveryRecovery });
+    const recoveryPlan = recovery ? { version: 1, kind: "claude-discovery-only", journal, journalIntentSha256: intentFile.sha256, stoppedSha256: stoppedFile.sha256, originalPlanDigest: intent.planDigest, policyBeforeSha256: policyBefore.sha256, policyCurrentSha256: policyCurrent.sha256, configBeforeSha256: configBefore.sha256, configCurrentSha256: currentConfig.sha256, ...configDiscoveryRecovery ? { configDiscoveryRecovery } : {}, hooksSha256: hooksCurrent.sha256, nativeConfigPath, nativeVersion: rpc.version, nativeInventorySha256: makePlanDigest(nativeHooks.map(safeNativeHook)), recordedNativeInventorySha256: makePlanDigest(recordedNativeHooks), boundSkillsCli: skillsCli.receipt, recoveryCli: recoveryCli.receipt, releaseProof: options.releaseProof, ...policyChange } : undefined;
     const recoveryPlanDigest = recoveryPlan ? makePlanDigest(recoveryPlan) : undefined;
     if (recovery?.reviewedPlanDigest !== undefined)
       need4(recovery.reviewedPlanDigest === recoveryPlanDigest, "RECONCILE_RECOVERY_PLAN_CHANGED");
     const preview2 = !!recovery && recovery.reviewedPlanDigest === undefined;
-    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, 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 } : {} };
+    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;
-    save2(join56(journal, "receipt.json"), json2(receipt));
+    save(join56(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";
@@ -108500,14 +108556,14 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
     need4(options.codexHome === undefined || isAbsolute25(options.codexHome) && [join56(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
     const codexHome = options.codexHome === undefined ? undefined : physicalRoot;
     const nativeConfigPath = join56(codexHome ?? join56(home, ".codex"), "config.toml");
-    const hooksFile = snapshot(hooksPath), configFile = snapshot(configPath, true), original = structure(configFile.text);
+    const hooksFile = snapshot(hooksPath), configFile = snapshot(configPath, true), original = structure2(configFile.text);
     const declarations = JSON.parse(hooksFile.text).hooks, expected = [];
     for (const [event, [nativeEvent, label]] of Object.entries(eventNames)) {
       const command = renderAgentHookCommand(binding.commands.codex, "codex", binding.profiles.codex, event);
       const groups = declarations[event];
       need4(Array.isArray(groups), "DECLARATION_CHANGED");
       const matches2 = groups.flatMap((group, gi) => (group.hooks ?? []).flatMap((entry, hi) => entry.command === command ? [{ group, entry, gi, hi }] : []));
-      need4(matches2.length === 1 && isDeepStrictEqual8(matches2[0].group, { hooks: [{ type: "command", command, timeout: 15 }] }), "DECLARATION_CHANGED");
+      need4(matches2.length === 1 && isDeepStrictEqual9(matches2[0].group, { hooks: [{ type: "command", command, timeout: 15 }] }), "DECLARATION_CHANGED");
       expected.push({ event: nativeEvent, key: `${join56(home, ".codex/hooks.json")}:${label}:${matches2[0].gi}:${matches2[0].hi}`, command });
     }
     codexTrustTextWitness(configFile.text, expected.map((h) => h.key));
@@ -108531,7 +108587,7 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
     const discovered = await list2(), admitted = admit(discovered);
     const config2 = await rpc.request("config/read", { includeLayers: true, cwd: home });
     const layers = config2?.layers?.filter((layer) => layer.name?.type === "user" && layer.name.file === nativeConfigPath && !layer.name.profile);
-    need4(layers?.length === 1 && /^sha256:[a-f0-9]{64}$/.test(layers[0].version) && !layers[0].disabledReason && isDeepStrictEqual8(layers[0].config, original), "NATIVE_CONFIG_MISMATCH");
+    need4(layers?.length === 1 && /^sha256:[a-f0-9]{64}$/.test(layers[0].version) && !layers[0].disabledReason && isDeepStrictEqual9(layers[0].config, original), "NATIVE_CONFIG_MISMATCH");
     need4(config2.config && config2.config.features?.hooks !== false, "NATIVE_HOOKS_DISABLED");
     need4(config2.layers.slice(0, config2.layers.indexOf(layers[0])).every((layer) => layer.config?.hooks === undefined && layer.config?.features?.hooks === undefined), "NATIVE_CONFIG_OVERRIDDEN");
     const keys3 = admitted.map((h) => h.key), planned = admitted.filter((h) => !h.enabled || h.trustStatus !== "trusted");
@@ -108546,7 +108602,7 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
     checkInputs();
     const digestInput = { version: 1, home, configPath, ...nativeConfigPath !== configPath ? { nativeConfigPath } : {}, configSha256: configFile.sha256, configVersion: layers[0].version, policySha256: policyFile.sha256, hooksSha256: hooksFile.sha256, skillsCli: skillsCli.receipt, nativeVersion: rpc.version, declarations: expected, admitted };
     const planDigest = makePlanDigest(digestInput);
-    const baseReceipt = { planDigest, skillsCli: skillsCli.receipt, nativeVersion: rpc.version, nativeConfigPath, ownedNativeProcessId: rpc.processId, agent: "codex", applied: false, planned, nativeEligible: planned.length === 0, transport: "owned-stdio-process", existingSessionsReloaded: false, nativeExecutionVerified: false };
+    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)
       need4(options.reviewedPlanDigest === planDigest, "PLAN_CHANGED: run the dry-run again and pass its reviewed --plan-digest with --apply");
     const parent = join56(dataDir3, "native-hook-trust");
@@ -108566,11 +108622,11 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
       mkdirSync25(parent, { mode: 448 });
     journal = join56(parent, randomUUID10());
     mkdirSync25(journal, { mode: 448 });
-    save2(join56(journal, "config.before.toml"), configFile.bytes);
-    save2(join56(journal, "hooks.before.json"), hooksFile.bytes);
-    save2(join56(journal, "policy.before.json"), policyFile.bytes);
-    save2(join56(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook) }));
-    need4(isDeepStrictEqual8(admit(await list2()), admitted), "NATIVE_DISCOVERY_CHANGED");
+    save(join56(journal, "config.before.toml"), configFile.bytes);
+    save(join56(journal, "hooks.before.json"), hooksFile.bytes);
+    save(join56(journal, "policy.before.json"), policyFile.bytes);
+    save(join56(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook) }));
+    need4(isDeepStrictEqual9(admit(await list2()), admitted), "NATIVE_DISCOVERY_CHANGED");
     checkInputs();
     let result2;
     try {
@@ -108584,25 +108640,30 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
     expectedConfig.hooks.state ??= {};
     for (const h of planned)
       expectedConfig.hooks.state[h.key] = { ...expectedConfig.hooks.state[h.key], enabled: true, trusted_hash: h.currentHash };
-    need4(isDeepStrictEqual8(structure(after2.text), expectedConfig) && codexTrustTextWitness(after2.text, keys3) === preservationText, "PRESERVATION_FAILED");
+    need4(isDeepStrictEqual9(structure2(after2.text), expectedConfig) && codexTrustTextWitness(after2.text, keys3) === preservationText, "PRESERVATION_FAILED");
+    const savedConfig = snapshot(join56(journal, "config.before.toml"), true);
+    need4(savedConfig.sha256 === configFile.sha256, "JOURNAL_CHANGED");
+    const discoveryTransition = binding.discovery?.codex ? createCodexHookDiscoveryRecovery(binding.discovery.codex, savedConfig, after2, planned) : undefined;
     unchanged2(policyFile);
     unchanged2(hooksFile);
-    assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home });
+    assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home, codexDiscoveryRecovery: discoveryTransition });
     const current = await list2(), confirmed = admit(current);
-    need4(confirmed.every((h) => h.enabled && h.trustStatus === "trusted") && isDeepStrictEqual8(confirmed.map((h) => [h.key, h.currentHash]), admitted.map((h) => [h.key, h.currentHash])), "NATIVE_NOT_ELIGIBLE");
-    need4(isDeepStrictEqual8(current.filter((h) => !keys3.includes(h.key)), discovered.filter((h) => !keys3.includes(h.key))), "UNRELATED_HOOK_CHANGED");
+    need4(confirmed.every((h) => h.enabled && h.trustStatus === "trusted") && isDeepStrictEqual9(confirmed.map((h) => [h.key, h.currentHash]), admitted.map((h) => [h.key, h.currentHash])), "NATIVE_NOT_ELIGIBLE");
+    need4(isDeepStrictEqual9(current.filter((h) => !keys3.includes(h.key)), discovered.filter((h) => !keys3.includes(h.key))), "UNRELATED_HOOK_CHANGED");
     unchanged2(after2);
+    unchanged2(savedConfig);
     unchanged2(hooksFile);
     unchanged2(policyFile);
     skillsCli.recheck();
-    const receipt = { ...baseReceipt, applied: true, nativeEligible: true, nativeConfigVersion: result2.version, journal, beforeSha256: configFile.sha256, afterSha256: after2.sha256, unrelatedSettingsAndCommentsPreserved: true };
-    save2(join56(journal, "receipt.json"), json2(receipt));
+    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(join56(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 {
-        save2(join56(journal, "stopped.json"), json2({ error: message.split(":")[0], automaticRollback: false, reconcileBeforeRetry: true }));
+        save(join56(journal, "stopped.json"), json2({ error: message.split(":")[0], automaticRollback: false, reconcileBeforeRetry: true }));
       } catch {}
     }
     throw new Error(message);
@@ -108611,7 +108672,7 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
   }
 }
 var json2 = (value) => JSON.stringify(value, null, 2) + `
-`, structure = (text3) => JSON.parse(JSON.stringify(Bun.TOML.parse(text3))), eventNames, makePlanDigest = (value) => createHash26("sha256").update(json2(value)).digest("hex"), safeNativeHook = (hook) => ({ key: hook.key, eventName: hook.eventName, handlerType: hook.handlerType, command: hook.command, matcher: hook.matcher, timeoutSec: hook.timeoutSec, async: hook.async, statusMessage: hook.statusMessage, additionalContextLimit: hook.additionalContextLimit, sourcePath: hook.sourcePath, source: hook.source, pluginId: hook.pluginId, isManaged: hook.isManaged, currentHash: hook.currentHash, enabled: hook.enabled, trustStatus: hook.trustStatus }), withoutCodexCommand = (value) => {
+`, structure2 = (text3) => JSON.parse(JSON.stringify(Bun.TOML.parse(text3))), eventNames, makePlanDigest = (value) => createHash27("sha256").update(json2(value)).digest("hex"), safeNativeHook = (hook) => ({ key: hook.key, eventName: hook.eventName, handlerType: hook.handlerType, command: hook.command, matcher: hook.matcher, timeoutSec: hook.timeoutSec, async: hook.async, statusMessage: hook.statusMessage, additionalContextLimit: hook.additionalContextLimit, sourcePath: hook.sourcePath, source: hook.source, pluginId: hook.pluginId, isManaged: hook.isManaged, currentHash: hook.currentHash, enabled: hook.enabled, trustStatus: hook.trustStatus }), withoutCodexCommand = (value) => {
   const copy = structuredClone(value);
   if (copy?.bridge?.commands && Object.hasOwn(copy.bridge.commands, "codex"))
     copy.bridge.commands.codex = "<reviewed-codex-binding>";
@@ -108621,6 +108682,7 @@ var init_agent_codex_trust = __esm(() => {
   init_config();
   init_managed_policy();
   init_agent_integration();
+  init_codex_hook_discovery_recovery();
   init_agent_adapters();
   init_codex_hook_rpc();
   init_codex_hook_trust_layout();
@@ -108805,7 +108867,7 @@ function registerAgentIntegration(parent) {
       if (options.json)
         await writeCliOutput(JSON.stringify(result2));
       else
-        await writeCliOutput(result2.applied ? `Enrolled ${result2.planned.length} Skills hook(s) for new Codex processes. Existing sessions were not reloaded; use their native hook controls.` : result2.planned.length ? `Planned ${result2.planned.length} native hook trust change(s). Review the --json plan, then use --apply --plan-digest ${result2.planDigest}.` : "The managed Skills hooks are enabled and trusted for new Codex processes. Existing session dispatch was not checked.");
+        await writeCliOutput(result2.applied ? result2.bindingRefreshRequired ? `Enrolled ${result2.planned.length} native Skills hook trust state(s). Managed context remains blocked: review the current configuration and run skills hook install with fresh --discovery-inputs and the same --command. Policy was not changed. Existing sessions were not reloaded.` : `Enrolled ${result2.planned.length} Skills hook(s) for new Codex processes. Existing sessions were not reloaded; use their native hook controls.` : result2.planned.length ? `Planned ${result2.planned.length} native hook trust change(s). Review the --json plan, then use --apply --plan-digest ${result2.planDigest}.` : "The managed Skills hooks are enabled and trusted for new Codex processes. Existing session dispatch was not checked.");
     } catch (error61) {
       console.error(error61.message);
       process.exitCode = 1;
@@ -108826,7 +108888,7 @@ function registerAgentIntegration(parent) {
       if (options.json)
         await writeCliOutput(JSON.stringify(result2));
       else
-        await writeCliOutput(result2.reconciled ? `Reconciled native Codex trust journal ${result2.journal}. No native configuration was written.` : `Recovery remains pending. Review the private --json plan, then repeat with --recovery-plan-digest ${result2.recoveryPlanDigest}.`);
+        await writeCliOutput(result2.reconciled ? result2.bindingRefreshRequired ? `Reconciled native Codex trust journal ${result2.journal}. Managed context remains blocked: install the reviewed binding with fresh --discovery-inputs before using ordinary hooks. Policy was not changed. No native configuration was written.` : `Reconciled native Codex trust journal ${result2.journal}. No native configuration was written.` : `Recovery remains pending. Review the private --json plan, then repeat with --recovery-plan-digest ${result2.recoveryPlanDigest}.`);
     } catch (error61) {
       console.error(error61.message);
       process.exitCode = 1;
@@ -109235,7 +109297,7 @@ var init_grants = __esm(() => {
 });
 
 // src/lib/station-hydrate.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
   mkdirSync as mkdirSync26,
@@ -109438,7 +109500,7 @@ function skillSha256(skill) {
     return sha256File(skill.files[0].winner.fullPath);
   }
   const joined = skill.files.map((file2) => sha256File(file2.winner.fullPath));
-  return createHash27("sha256").update(joined.sort().join(`
+  return createHash28("sha256").update(joined.sort().join(`
 `)).digest("hex");
 }
 function writeStationHydration(options) {
@@ -109595,7 +109657,7 @@ var init_hydrate = __esm(() => {
 });
 
 // src/lib/prepare-skill.ts
-import { createHash as createHash28, randomUUID as randomUUID11 } from "crypto";
+import { createHash as createHash29, randomUUID as randomUUID11 } from "crypto";
 import { chmodSync as chmodSync3, existsSync as existsSync34, lstatSync as lstatSync29, mkdirSync as mkdirSync27, mkdtempSync as mkdtempSync6, readFileSync as readFileSync40, readdirSync as readdirSync22, renameSync as renameSync12, rmSync as rmSync9, writeFileSync as writeFileSync27 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { dirname as dirname32, isAbsolute as isAbsolute27, join as join58, relative as relative9, resolve as resolve24, sep as sep11 } from "path";
@@ -109793,7 +109855,7 @@ function snapshot2(root2) {
   if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
     throw new Error("Skill root must be a real directory, not a symlink.");
   const files = [], directories = [];
-  const hash4 = createHash28("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
+  const hash4 = createHash29("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
   let count = 0, bytes = 0;
   const walk2 = (relative10) => {
     for (const name of readdirSync22(join58(root2, relative10)).sort()) {
@@ -111010,6 +111072,10 @@ function stringField2(value) {
 function recordField(value) {
   return isRecord7(value) ? value : undefined;
 }
+function identityApiKey(live) {
+  const root2 = recordField(live);
+  return root2 && Object.hasOwn(root2, "apiKey") ? root2.apiKey : recordField(root2?.data)?.apiKey;
+}
 function authIdentityPayload(authSource, live, cached2, offline = false) {
   const root2 = recordField(live) ?? {};
   const data = recordField(root2.data);
@@ -111021,11 +111087,11 @@ function authIdentityPayload(authSource, live, cached2, offline = false) {
   const userId = stringField2(user?.id) ?? cached2?.userId;
   const orgId = stringField2(organization2?.id) ?? cached2?.orgId;
   const role3 = stringField2(user?.role);
-  const apiKey = recordField(root2.apiKey) ?? recordField(data?.apiKey);
+  const apiKey = recordField(identityApiKey(live));
   const apiKeyId = stringField2(apiKey?.id);
   const apiKeyScopes = apiKey?.scopes;
   const safeApiKeyId = apiKeyId && /^[A-Za-z0-9_-]{1,256}$/.test(apiKeyId) ? apiKeyId : undefined;
-  const safeApiKeyScopes = Array.isArray(apiKeyScopes) && apiKeyScopes.length <= 32 && apiKeyScopes.every((scope) => typeof scope === "string" && scope.length <= 128 && /^(?:\*|[a-z][a-z0-9_-]*:(?:\*|[a-z][a-z0-9_-]*))$/.test(scope)) ? [...new Set(apiKeyScopes)] : undefined;
+  const safeApiKeyScopes = Array.isArray(apiKeyScopes) && apiKeyScopes.length <= 32 && apiKeyScopes.every((scope) => typeof scope === "string" && scope.length <= 128 && /^(?:\*|[a-z][a-z0-9_-]*:(?:\*|[a-z][a-z0-9_-]*))$/.test(scope)) ? [...apiKeyScopes] : undefined;
   return {
     status: "authenticated",
     authSource,
@@ -111493,8 +111559,10 @@ function registerAuth(parent) {
         access = await new RemoteSkillsClient(fleet.apiKey, fleet.apiOrigin).getCapabilities();
       } catch {}
       payload.permissions = { publish: access?.permissions?.publish ?? null, profilesWrite: access?.permissions?.profilesWrite ?? null };
-      if (access?.scopes)
+      const apiKey = identityApiKey(res);
+      if (access?.scopes && (apiKey === undefined || isRecord7(apiKey) && !Object.hasOwn(apiKey, "scopes"))) {
         payload.scopes = access.scopes;
+      }
       if (options.json) {
         console.log(JSON.stringify(payload, null, 2));
       } else {