@hasna/skills 0.10.75 → 0.10.76

package/bin/index.js

@@ -36888,7 +36888,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.75",
+    version: "0.10.76",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -51502,10 +51502,31 @@ var init_agent_discovery_path_bytes = __esm(() => {
 
 // src/lib/codex-corpus-write.ts
 import { KernelLock } from "@hasna/contracts/kernel-lock";
-import { execFileSync } from "child_process";
+import { AsyncLocalStorage } from "async_hooks";
+import { execFileSync, spawnSync as spawnSync2 } from "child_process";
 import { createHash as createHash16 } from "crypto";
-import { accessSync, constants as constants8, lstatSync as lstatSync12, readFileSync as readFileSync10, realpathSync as realpathSync2, statSync as statSync7 } from "fs";
+import { accessSync, constants as constants8, lstatSync as lstatSync12, mkdirSync as mkdirSync5, mkdtempSync, readdirSync as readdirSync5, readFileSync as readFileSync10, realpathSync as realpathSync2, rmSync as rmSync2, statSync as statSync7 } from "fs";
 import { basename as basename7, delimiter, dirname as dirname13, isAbsolute as isAbsolute13, join as join19, relative as relative3, resolve as resolve14, sep as sep6 } from "path";
+function codexAdmissionRecord(options) {
+  const record4 = options.onCodexAdmission;
+  const invalid = () => {
+    throw new Error("CODEX_CORPUS_ADMISSION_RECORD_INVALID: onCodexAdmission must be a synchronous function");
+  };
+  if (record4 !== undefined && typeof record4 !== "function")
+    invalid();
+  return { policy: { fallback: typeof record4 === "function" }, deliver(admission) {
+    if (!admission || typeof record4 !== "function")
+      return;
+    const result2 = record4(admission);
+    if (result2 !== null && (typeof result2 === "object" || typeof result2 === "function") && typeof result2.then === "function") {
+      Promise.resolve(result2).catch(() => {});
+      invalid();
+    }
+  } };
+}
+function codexAdmissionReceipt(admission) {
+  return admission?.nativeAdmission === "unavailable" && admission.probe ? { nativeAdmission: "unavailable", nativeAdmissionProbe: { ...admission.probe } } : {};
+}
 function physicalTarget(path) {
   const suffix = [];
   for (let cursor = path;; cursor = dirname13(cursor)) {
@@ -51587,13 +51608,224 @@ function executable(options) {
   const digest = hash2();
   if (options.codexSha256 && digest !== options.codexSha256)
     return fail2();
-  return { path, assertCurrent() {
+  return { path, sha256: digest, size: Number(initial2.size), assertCurrent() {
     const current = statSync7(path, { bigint: true });
     if (realpathSync2(found) !== path || ["dev", "ino", "size", "mtimeNs", "ctimeNs", "mode"].some((key2) => initial2[key2] !== current[key2]) || hash2() !== digest)
       fail2();
   } };
 }
-function acquireCodexCorpusWrite(roots, options) {
+function nativeLockAbsent(root) {
+  for (const name of [`${KEY}.flock-v1`, `${KEY}.lock`]) {
+    try {
+      lstatSync12(join19(root, name));
+      return false;
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+  return true;
+}
+function skillsState(root, leaf, roots) {
+  const chain = [realpathSync2(dirname13(root))];
+  for (const part of [".hasna", "skills", leaf])
+    chain.push(join19(chain.at(-1), part));
+  const path = chain.at(-1);
+  const uid2 = process.getuid();
+  const verify = () => {
+    if (roots.some((item) => contains(item, path)) || codexCorpusRootForPath(path) !== undefined)
+      fail2();
+    for (let ancestor = dirname13(chain[0]);; ancestor = dirname13(ancestor)) {
+      const stat2 = lstatSync12(ancestor), sticky = stat2.uid === 0 && (stat2.mode & 512) !== 0;
+      if (!stat2.isDirectory() || stat2.uid !== uid2 && stat2.uid !== 0 || (stat2.mode & 18) !== 0 && !sticky)
+        fail2();
+      if (dirname13(ancestor) === ancestor)
+        break;
+    }
+    for (const component of chain) {
+      const stat2 = lstatSync12(component, { throwIfNoEntry: false });
+      if (!stat2)
+        return;
+      if (!stat2.isDirectory() || stat2.uid !== uid2 && stat2.uid !== 0 || (stat2.mode & 18) !== 0 || component === path && stat2.uid !== uid2)
+        fail2();
+    }
+  };
+  verify();
+  return { path, ensure() {
+    verify();
+    for (const component of chain.slice(1)) {
+      try {
+        mkdirSync5(component, { mode: 448 });
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+    }
+    verify();
+    if (realpathSync2(path) !== path)
+      fail2();
+    return path;
+  } };
+}
+function probeParent(roots) {
+  const dataRoot = resolve14(getDataDirReadOnly()), path = join19(dataRoot, PROBE_PARENT), uid2 = process.getuid();
+  const chain = [];
+  for (let component = path;; component = dirname13(component)) {
+    chain.unshift(component);
+    if (dirname13(component) === component)
+      break;
+  }
+  const verify = () => {
+    if (roots.some((item) => contains(item, path)) || codexCorpusRootForPath(path) !== undefined)
+      fail2();
+    for (const component of chain) {
+      const stat2 = lstatSync12(component, { throwIfNoEntry: false });
+      if (!stat2)
+        return;
+      const skills = contains(dataRoot, component), sticky = !skills && stat2.uid === 0 && (stat2.mode & 512) !== 0;
+      if (!stat2.isDirectory() || stat2.uid !== uid2 && (skills || stat2.uid !== 0) || (stat2.mode & 18) !== 0 && !sticky)
+        fail2();
+    }
+  };
+  verify();
+  for (const component of chain) {
+    if (lstatSync12(component, { throwIfNoEntry: false }))
+      continue;
+    try {
+      mkdirSync5(component, { mode: 448 });
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+  }
+  verify();
+  if (realpathSync2(path) !== path)
+    fail2();
+  return path;
+}
+function probeHomeIntact(home, empty) {
+  const stat2 = lstatSync12(home.path, { bigint: true, throwIfNoEntry: false });
+  return !!stat2 && stat2.isDirectory() && stat2.dev === home.dev && stat2.ino === home.ino && stat2.uid === BigInt(process.getuid()) && (stat2.mode & 0o777n) === 0o700n && realpathSync2(home.path) === home.path && (!empty || readdirSync5(home.path).length === 0);
+}
+function removeProbeHome(home) {
+  try {
+    const stat2 = lstatSync12(home.path, { bigint: true });
+    if (stat2.isDirectory() && stat2.dev === home.dev && stat2.ino === home.ino)
+      rmSync2(home.path, { recursive: true, force: true });
+  } catch {}
+}
+function probe(path, args, parent, stdio) {
+  const created = mkdtempSync(join19(parent, "probe-")), stat2 = lstatSync12(created, { bigint: true });
+  const home = { path: created, dev: stat2.dev, ino: stat2.ino };
+  try {
+    if (!probeHomeIntact(home, true))
+      return;
+    const env3 = { CODEX_HOME: home.path };
+    for (const key2 of ["PATH", "HOME"])
+      if (process.env[key2] !== undefined)
+        env3[key2] = process.env[key2];
+    const result2 = spawnSync2(path, args, { ...PROBE, cwd: home.path, env: env3, stdio: ["ignore", stdio, stdio] });
+    return probeHomeIntact(home, false) ? result2 : undefined;
+  } finally {
+    removeProbeHome(home);
+  }
+}
+function probeAdmissionCommand(path, parent) {
+  const help = probe(path, ["help", "corpus-admission-inspect"], parent, "pipe");
+  if (!help || help.error || help.signal !== null)
+    return "inconclusive";
+  if (help.status === 0)
+    return "present";
+  if (help.status !== 2 || help.stdout !== "" || typeof help.stderr !== "string" || !UNRECOGNIZED.test(help.stderr))
+    return "inconclusive";
+  const control = probe(path, ["help", "exec"], parent, "ignore");
+  return control && !control.error && control.signal === null && control.status === 0 ? "absent" : "inconclusive";
+}
+function strictVersion(path, parent) {
+  const result2 = probe(path, ["--version"], parent, "pipe");
+  if (!result2 || result2.error || result2.signal !== null || result2.status !== 0 || typeof result2.stdout !== "string")
+    return;
+  const line = result2.stdout.replace(/\r?\n$/, "");
+  return VERSION.test(line) ? line : undefined;
+}
+function rootLockKey(root, id) {
+  return `codex-corpus-${createHash16("sha256").update(`${root}\x00${id.device}\x00${id.inode}`).digest("hex")}`;
+}
+function acquireFallback(inputs, options) {
+  let reason2 = "executable-unverified";
+  const refs = new Map, held = [];
+  const close = () => {
+    for (const ref of [...refs.values()].reverse())
+      release(ref);
+  };
+  try {
+    const native = executable(options);
+    reason2 = "skills-lock-unavailable";
+    const roots = inputs.map((item) => item.root);
+    const locks = new Map(roots.map((root) => [root, skillsState(root, LOCK_DIRECTORY, roots)]));
+    const parent = probeParent(roots);
+    reason2 = "probe-inconclusive";
+    const state = probeAdmissionCommand(native.path, parent);
+    if (state === "present")
+      reason2 = "command-present";
+    if (state !== "absent")
+      fail2();
+    const version = strictVersion(native.path, parent);
+    if (version === undefined)
+      fail2();
+    reason2 = "executable-unverified";
+    native.assertCurrent();
+    reason2 = "skills-lock-unavailable";
+    for (const { input, root } of inputs) {
+      const id = identity4(root), key2 = rootLockKey(root, id);
+      if (!refs.has(key2)) {
+        const owner2 = enclosing.getStore()?.get(key2);
+        if (owner2 && !owner2.released)
+          refs.set(key2, retain(owner2.hold));
+        else {
+          const lock = new KernelLock(locks.get(root).ensure(), key2, { mode: "exclusive" });
+          refs.set(key2, retain({ lock, refs: 0 }));
+          if (!lock.trySync(1000)) {
+            reason2 = "writer-busy";
+            fail2();
+          }
+        }
+      }
+      held.push({ input, root, id, ref: refs.get(key2) });
+    }
+    const assertCurrent = () => {
+      try {
+        for (const item of held) {
+          if (item.ref.released)
+            fail2();
+          item.ref.hold.lock.assertUnchanged();
+          if (realpathSync2(item.input) !== item.root || !sameIdentity(identity4(item.root), item.id) || !nativeLockAbsent(item.root))
+            fail2();
+        }
+        native.assertCurrent();
+      } catch {
+        fail2("lease-changed");
+      }
+    };
+    reason2 = "lease-changed";
+    assertCurrent();
+    const lease = { assertCurrent, close, admission: { nativeAdmission: "unavailable", probe: {
+      kind: "help-unrecognized-subcommand",
+      executable: native.path,
+      sha256: native.sha256,
+      size: native.size,
+      version,
+      probeExitCode: 2,
+      controlExitCode: 0
+    } } };
+    leaseHolds.set(lease, refs);
+    return lease;
+  } catch {
+    close();
+    return fail2(reason2);
+  }
+}
+function acquireCodexCorpusWrite(roots, options, policy = {}) {
   const held = [];
   const close = () => {
     for (const item of held.reverse())
@@ -51606,10 +51838,20 @@ function acquireCodexCorpusWrite(roots, options) {
         fail2();
     }
   };
+  let fallback = false, refusal;
   try {
     if (roots.some((root) => typeof root !== "string" || !isAbsolute13(root) || root.includes("\x00")))
       fail2();
     const inputs = [...new Set(roots)].map((input) => ({ input, root: realpathSync2(input) })).sort((a, b) => a.root.localeCompare(b.root));
+    const absent = inputs.filter(({ root }) => nativeLockAbsent(root));
+    if (absent.length && absent.length !== inputs.length) {
+      refusal = "native-lock-present";
+      fail2();
+    }
+    if (absent.length && policy.fallback !== false) {
+      fallback = true;
+      return acquireFallback(inputs, options);
+    }
     for (const { input, root } of inputs) {
       const lock = new KernelLock(root, KEY, { mode: "shared", existingOnly: true });
       held.push({ input, root, lock });
@@ -51637,42 +51879,67 @@ function acquireCodexCorpusWrite(roots, options) {
       if (Object.keys(row).sort().join(",") !== "lock,root,schema,state" || row.schema !== "codex-corpus-admission-status/v1" || row.state !== "committed-v1" && row.state !== "committed-v2" || !sameIdentity(row.root, rootIdentity) || !sameIdentity(row.lock, lockIdentity))
         fail2();
     }
-    return { assertCurrent, close };
-  } catch {
+    return { assertCurrent, close, admission: { nativeAdmission: "verified" } };
+  } catch (error) {
+    if (fallback)
+      throw error;
     close();
-    return fail2();
+    return fail2(refusal);
   }
 }
-function withCodexCorpusWrite(roots, run, options = {}) {
+function scoped(lease, run) {
+  const holds = leaseHolds.get(lease);
+  return holds?.size ? enclosing.run(new Map([...enclosing.getStore() ?? [], ...holds]), run) : run();
+}
+function withCodexCorpusWrite(roots, run, options = {}, policy = {}) {
   if (!roots.length)
     return run(() => {});
-  const lease = acquireCodexCorpusWrite(roots, options);
+  const lease = acquireCodexCorpusWrite(roots, options, policy);
   try {
     lease.assertCurrent();
-    const result2 = run(lease.assertCurrent);
+    const result2 = scoped(lease, () => run(lease.assertCurrent, lease.admission));
     lease.assertCurrent();
     return result2;
   } finally {
     lease.close();
   }
 }
-async function withCodexCorpusWriteAsync(roots, run, options = {}) {
+async function withCodexCorpusWriteAsync(roots, run, options = {}, policy = {}) {
   if (!roots.length)
     return run(() => {});
-  const lease = acquireCodexCorpusWrite(roots, options);
+  const lease = acquireCodexCorpusWrite(roots, options, policy);
   try {
     lease.assertCurrent();
-    const result2 = await run(lease.assertCurrent);
+    const result2 = await scoped(lease, () => run(lease.assertCurrent, lease.admission));
     lease.assertCurrent();
     return result2;
   } finally {
     lease.close();
   }
 }
-var KEY = ".native-corpus-admission", fail2 = () => {
-  throw new Error("CODEX_CORPUS_ADMISSION_REQUIRED: verified native admission and its existing shared lock are required");
+var KEY = ".native-corpus-admission", fail2 = (reason2) => {
+  throw new Error(`CODEX_CORPUS_ADMISSION_REQUIRED: verified native admission and its existing shared lock are required${reason2 ? ` (${reason2})` : ""}`);
+}, PROBE, UNRECOGNIZED, VERSION, LOCK_DIRECTORY = "codex-corpus-locks", PROBE_PARENT = "codex-probe-homes", retain = (hold) => {
+  hold.refs++;
+  return { hold, released: false };
+}, release = (ref) => {
+  if (ref.released)
+    return;
+  ref.released = true;
+  if (--ref.hold.refs === 0)
+    ref.hold.lock.close();
+}, enclosing, leaseHolds, contains = (base2, path) => {
+  const distance = relative3(base2, path);
+  return distance === "" || !distance.startsWith(`..${sep6}`) && distance !== ".." && !isAbsolute13(distance);
 };
-var init_codex_corpus_write = () => {};
+var init_codex_corpus_write = __esm(() => {
+  init_config();
+  PROBE = { timeout: 5000, maxBuffer: 4096, killSignal: "SIGKILL", encoding: "utf8" };
+  UNRECOGNIZED = /^error: unrecognized subcommand 'corpus-admission-inspect'(?:\r?\n|$)/;
+  VERSION = /^codex-cli (?:0|[1-9][0-9]{0,5})\.(?:0|[1-9][0-9]{0,5})\.(?:0|[1-9][0-9]{0,5})(?:-[0-9A-Za-z-]{1,32}(?:\.[0-9A-Za-z-]{1,32}){0,7})?$/;
+  enclosing = new AsyncLocalStorage;
+  leaseHolds = new WeakMap;
+});
 
 // src/lib/codex-hook-rpc.ts
 import { join as join20 } from "path";
@@ -51785,6 +52052,7 @@ async function connectCodexHookRpc(options) {
   const rpc = {
     version,
     processId: child2.pid,
+    admission: corpusLease.admission,
     request(method2, params) {
       if (stopped)
         return Promise.reject(new Error(configInvalid ? CODEX_CONFIG_INVALID : "CODEX_HOOK_TRUST_NATIVE_RPC_CLOSED"));
@@ -51992,7 +52260,7 @@ var init_codex_native_skill_catalog = __esm(() => {
 // src/lib/codex-plugin-skill-controls.ts
 import { createHash as createHash17 } from "crypto";
 import { basename as basename8, dirname as dirname14, join as join21, relative as relative4, resolve as resolve15, sep as sep7 } from "path";
-import { lstatSync as lstatSync13, readdirSync as readdirSync5, readFileSync as readFileSync11, readlinkSync as readlinkSync3, realpathSync as realpathSync5 } from "fs";
+import { lstatSync as lstatSync13, readdirSync as readdirSync6, readFileSync as readFileSync11, readlinkSync as readlinkSync3, realpathSync as realpathSync5 } from "fs";
 function refuse2() {
   throw new Error("CODEX_NATIVE_SKILL_IDENTITY_UNSUPPORTED: review native plugin names and hook controls");
 }
@@ -52245,7 +52513,7 @@ function reviewedRetiredCodexRoot(cache3, root, controls, rules, read2, allowAbs
     if (!enrolled.some((control) => control.namespace === parsed.namespace && control.manifestSha256 === parsed.manifestSha256 && !parsed.appSha256 && !parsed.mcpSha256))
       return false;
     let entries = 0;
-    const emptySkills = (directory, depth) => depth <= 64 && readdirSync5(directory).every((name) => {
+    const emptySkills = (directory, depth) => depth <= 64 && readdirSync6(directory).every((name) => {
       if (++entries > 4096 || name === "SKILL.md")
         return false;
       const path = join21(directory, name), stat2 = lstatSync13(path);
@@ -52270,7 +52538,7 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache3, controls, read2, rules
         if (control.remotePluginId !== undefined && !remoteInstallationMatches(parent, control.remotePluginId, read2))
           return false;
       }
-      const names = readdirSync5(parent);
+      const names = readdirSync6(parent);
       entries += names.length;
       if (entries > 4096)
         return false;
@@ -52465,7 +52733,7 @@ var init_codex_plugin_skill_controls = __esm(() => {
 });
 
 // src/lib/codex-vendor-refresh.ts
-import { lstatSync as lstatSync14, readdirSync as readdirSync6, readFileSync as readFileSync12 } from "fs";
+import { lstatSync as lstatSync14, readdirSync as readdirSync7, readFileSync as readFileSync12 } from "fs";
 import { isAbsolute as isAbsolute16, join as join22, relative as relative5, resolve as resolve16, sep as sep8 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual6 } from "util";
 function codexVendorMarketplace(cache3, path) {
@@ -52482,7 +52750,7 @@ function codexVendorMarketplace(cache3, path) {
 function pluginTreeVisible(path, hidden, insideSkill, depth, budget2) {
   if (depth > MAX_SUBTREE_DEPTH)
     return false;
-  const names = readdirSync6(path);
+  const names = readdirSync7(path);
   const skill = names.some(isSkillDocument);
   if (skill && (hidden || insideSkill))
     return false;
@@ -52506,7 +52774,7 @@ function codexVendorPluginRootRefreshSafe(root, budget2 = { remaining: MAX_SUBTR
       return false;
     if (!directory(join22(root, ".codex-plugin")))
       return false;
-    const controls = readdirSync6(join22(root, ".codex-plugin"));
+    const controls = readdirSync7(join22(root, ".codex-plugin"));
     if (controls.length !== 1 || controls[0] !== "plugin.json")
       return false;
     const manifest = join22(root, ".codex-plugin", "plugin.json"), stat2 = lstatSync14(manifest, { throwIfNoEntry: false });
@@ -52529,7 +52797,7 @@ function codexVendorPluginRootRefreshSafe(root, budget2 = { remaining: MAX_SUBTR
 }
 function vendorMembers(path, budget2) {
   const directories = [];
-  for (const name of readdirSync6(path)) {
+  for (const name of readdirSync7(path)) {
     if (--budget2.remaining < 0)
       return null;
     const stat2 = lstatSync14(join22(path, name));
@@ -52674,7 +52942,7 @@ function codexVendorConfigCandidates(text2, cache3, options = {}) {
 var CODEX_VENDOR_MARKETPLACES, CODEX_REMOTE_VENDOR_MARKETPLACES, identifier3 = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,64}$/.test(value), record4 = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value)), directory = (path) => {
   const stat2 = lstatSync14(path, { throwIfNoEntry: false });
   return Boolean(stat2?.isDirectory() && !stat2.isSymbolicLink());
-}, OTHER_PLUGIN_CONTROLS, VENDOR_MANIFEST_KEYS, DEFAULT_SKILLS_PATHS, VENDOR_APP_DECLARATION = "./.app.json", MAX_SUBTREE_ENTRIES = 20000, MAX_SUBTREE_DEPTH = 32, hiddenName = (name) => name.startsWith(".") || name === "node_modules", isSkillDocument = (name) => name.toLowerCase() === "skill.md", present = (path) => lstatSync14(path, { throwIfNoEntry: false }) !== undefined, holdsOtherControl = (path) => readdirSync6(path).some((name) => OTHER_PLUGIN_CONTROLS.includes(name.toLowerCase())), MAX_TRAILING_VENDOR_ROWS = 16, MAX_VENDOR_TABLES = 8, MAX_CONFIG_CANDIDATES = 128, HEADER;
+}, OTHER_PLUGIN_CONTROLS, VENDOR_MANIFEST_KEYS, DEFAULT_SKILLS_PATHS, VENDOR_APP_DECLARATION = "./.app.json", MAX_SUBTREE_ENTRIES = 20000, MAX_SUBTREE_DEPTH = 32, hiddenName = (name) => name.startsWith(".") || name === "node_modules", isSkillDocument = (name) => name.toLowerCase() === "skill.md", present = (path) => lstatSync14(path, { throwIfNoEntry: false }) !== undefined, holdsOtherControl = (path) => readdirSync7(path).some((name) => OTHER_PLUGIN_CONTROLS.includes(name.toLowerCase())), MAX_TRAILING_VENDOR_ROWS = 16, MAX_VENDOR_TABLES = 8, MAX_CONFIG_CANDIDATES = 128, HEADER;
 var init_codex_vendor_refresh = __esm(() => {
   init_claude_settings_witness();
   init_codex_plugin_skill_controls();
@@ -52862,7 +53130,7 @@ var init_claude_plugin_manifest_witness = __esm(() => {
 
 // node_modules/@hasna/contracts/dist/client/transport.js
 import { isIP as isIP2 } from "net";
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import { closeSync as closeSync22, fstatSync as fstatSync22, openSync as openSync22, readFileSync as readFileSync22 } from "fs";
 import { O_NOFOLLOW as O_NOFOLLOW2, O_NONBLOCK as O_NONBLOCK2, O_RDONLY as O_RDONLY2 } from "constants";
 import { hostname as osHostname } from "os";
@@ -53220,7 +53488,7 @@ function isAmbientEnvironment(env3) {
   return env3 === process.env || env3[AMBIENT_ENVIRONMENT] === true;
 }
 function defaultKeychainRunner(argv) {
-  const result2 = spawnSync2(KEYCHAIN_SECURITY_BIN, [...argv], {
+  const result2 = spawnSync3(KEYCHAIN_SECURITY_BIN, [...argv], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: KEYCHAIN_SPAWN_TIMEOUT_MS
@@ -54559,7 +54827,7 @@ function capturePreparationProcess(child2, platform2 = process.platform, signalG
 }
 
 // src/lib/dependency-preparation.ts
-import { constants as constants11, closeSync as closeSync10, fstatSync as fstatSync10, lstatSync as lstatSync18, mkdirSync as mkdirSync5, openSync as openSync10, readFileSync as readFileSync14, readdirSync as readdirSync7, rmdirSync as rmdirSync2, unlinkSync as unlinkSync3, ftruncateSync, writeSync as writeSync2 } from "fs";
+import { constants as constants11, closeSync as closeSync10, fstatSync as fstatSync10, lstatSync as lstatSync18, mkdirSync as mkdirSync6, openSync as openSync10, readFileSync as readFileSync14, readdirSync as readdirSync8, rmdirSync as rmdirSync2, unlinkSync as unlinkSync3, ftruncateSync, writeSync as writeSync2 } from "fs";
 import { join as join26 } from "path";
 function hasDependencyPreparationMarker(skillPath) {
   try {
@@ -54574,7 +54842,7 @@ function claimPreparation(skillPath) {
   const state = join26(marker, "state.json"), active = join26(marker, "active");
   let created = false;
   try {
-    mkdirSync5(marker, { mode: 448 });
+    mkdirSync6(marker, { mode: 448 });
     created = true;
   } catch (error) {
     if (error.code !== "EEXIST")
@@ -54585,7 +54853,7 @@ function claimPreparation(skillPath) {
     if (!lstatSync18(marker).isDirectory() || lstatSync18(marker).isSymbolicLink())
       return;
     if (!created) {
-      if (readdirSync7(marker).some((name) => name !== "state.json"))
+      if (readdirSync8(marker).some((name) => name !== "state.json"))
         return;
       if (!lstatSync18(state).isFile() || lstatSync18(state).isSymbolicLink() || lstatSync18(state).size > 1024)
         return;
@@ -54593,7 +54861,7 @@ function claimPreparation(skillPath) {
       if (previous.version !== 1 || previous.status !== "failed" || Object.keys(previous).length !== 2)
         return;
     }
-    mkdirSync5(active, { mode: 448 });
+    mkdirSync6(active, { mode: 448 });
     fd = openSync10(state, constants11.O_RDWR | constants11.O_NOFOLLOW | (created ? constants11.O_CREAT | constants11.O_EXCL : 0), 384);
     if (!fstatSync10(fd).isFile()) {
       closeSync10(fd);
@@ -54724,7 +54992,7 @@ var init_dependency_preparation = () => {};
 
 // src/lib/codex-native-skill-policy.ts
 import { createHash as createHash20, randomUUID as randomUUID6 } from "crypto";
-import { closeSync as closeSync11, constants as constants12, fstatSync as fstatSync11, fsyncSync as fsyncSync3, lstatSync as lstatSync19, mkdirSync as mkdirSync6, openSync as openSync11, readFileSync as readFileSync15, readSync as readSync8, readlinkSync as readlinkSync4, realpathSync as realpathSync7, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync4 } from "fs";
+import { closeSync as closeSync11, constants as constants12, fstatSync as fstatSync11, fsyncSync as fsyncSync3, lstatSync as lstatSync19, mkdirSync as mkdirSync7, openSync as openSync11, readFileSync as readFileSync15, readSync as readSync8, readlinkSync as readlinkSync4, realpathSync as realpathSync7, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname17, isAbsolute as isAbsolute19, join as join27, resolve as resolve18 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual7 } from "util";
 function codexNativeHookEnvelopeFromInput(input, event, inputBytes, inheritedFd) {
@@ -54984,7 +55252,7 @@ function writeExecutableCache(dataDir3, entries) {
       return;
     const existing = lstatSync19(directory2, { throwIfNoEntry: false });
     if (!existing)
-      mkdirSync6(directory2, { mode: 448 });
+      mkdirSync7(directory2, { mode: 448 });
     else if (existing.isSymbolicLink() || !existing.isDirectory())
       return;
     const holder = lstatSync19(directory2, { throwIfNoEntry: false, bigint: true });
@@ -55279,7 +55547,7 @@ function recordCodexNativePolicyAcceptance(dataDir3, verification, accepted) {
     ...verification.attestation ? { attestation: { schema: verification.attestation.schema, peerProcessId: verification.attestation.peerProcessId } } : {}
   };
   try {
-    mkdirSync6(directory2, { recursive: true, mode: 448 });
+    mkdirSync7(directory2, { recursive: true, mode: 448 });
     const stat2 = lstatSync19(directory2);
     if (stat2.isSymbolicLink() || !stat2.isDirectory())
       throw new Error(`the receipt directory is not a real directory: ${directory2}`);
@@ -55321,7 +55589,7 @@ var init_codex_native_skill_policy = __esm(() => {
 
 // src/lib/codex-semantic-cache-witness.ts
 import { createHash as createHash21 } from "crypto";
-import { constants as constants13, closeSync as closeSync12, fstatSync as fstatSync12, lstatSync as lstatSync20, openSync as openSync12, readSync as readSync9, readdirSync as readdirSync8, realpathSync as realpathSync8 } from "fs";
+import { constants as constants13, closeSync as closeSync12, fstatSync as fstatSync12, lstatSync as lstatSync20, openSync as openSync12, readSync as readSync9, readdirSync as readdirSync9, realpathSync as realpathSync8 } from "fs";
 import { basename as basename11, dirname as dirname18, isAbsolute as isAbsolute20, join as join28, relative as relative7, resolve as resolve19, sep as sep10 } from "path";
 function codexLocalMarketplaceMapsPlugin(text2, marketplace, plugin) {
   try {
@@ -55478,7 +55746,7 @@ function assertCanonicalDirectory(path) {
 function walkSafeTree(path, state, depth = 0, root = path) {
   if (depth > 64 || ++state.entries > 16384)
     refuse4();
-  const names = readdirSync8(path).sort();
+  const names = readdirSync9(path).sort();
   const files = [];
   for (const name of names) {
     if (!name || name === "." || name === ".." || name.includes(sep10) || ++state.entries > 16384)
@@ -55624,7 +55892,7 @@ function appOnlyParentProjection(cacheRoot, parents2, read2) {
     } catch {
       refuse4();
     }
-    const versions = readdirSync8(parent.pluginParent).filter((name) => name !== ".codex-remote-plugin-install.json");
+    const versions = readdirSync9(parent.pluginParent).filter((name) => name !== ".codex-remote-plugin-install.json");
     if (!versions.length || versions.length > 4096)
       refuse4();
     const materializations = versions.map((version) => {
@@ -55750,7 +56018,7 @@ function reviewedHookParentProjection(cacheRoot, parents2, read2) {
       if (createHash21("sha256").update(marketplaceText).digest("hex") !== parent.marketplaceSha256 || !codexLocalMarketplaceMapsPlugin(marketplaceText, parts[0], parent.namespace))
         refuse4();
     }
-    const materializations = readdirSync8(parent.pluginParent).filter((name) => name !== ".codex-remote-plugin-install.json").map((version) => {
+    const materializations = readdirSync9(parent.pluginParent).filter((name) => name !== ".codex-remote-plugin-install.json").map((version) => {
       if (!/^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/.test(version))
         refuse4();
       const root = join28(parent.pluginParent, version), stat2 = lstatSync20(root, { throwIfNoEntry: false });
@@ -55784,14 +56052,14 @@ function assertParents(cacheRoot, controls, appOnlyParents, hookParents, files,
       refuse4();
     actual.add(join28(cacheRoot, parts[0], parts[1]));
   }
-  const actualMarkets = readdirSync8(cacheRoot);
+  const actualMarkets = readdirSync9(cacheRoot);
   if (actualMarkets.length !== expectedMarkets.size || actualMarkets.some((market) => !expectedMarkets.has(market)))
     refuse4();
   for (const market of actualMarkets) {
     const marketPath = join28(cacheRoot, market), marketStat = lstatSync20(marketPath);
     if (!identifier5(market) || !marketStat.isDirectory() || marketStat.isSymbolicLink())
       refuse4();
-    for (const plugin of readdirSync8(marketPath)) {
+    for (const plugin of readdirSync9(marketPath)) {
       const parent = join28(marketPath, plugin), stat2 = lstatSync20(parent);
       if (!identifier5(plugin) || !stat2.isDirectory() || stat2.isSymbolicLink())
         refuse4();
@@ -55843,7 +56111,7 @@ function assertSkillMaterializations(cacheRoot, controls, files, read2) {
     const expectedNames = new Set(rows.map((row) => row.name));
     if (expectedNames.size !== rows.length)
       refuse4();
-    const entries = readdirSync8(parent);
+    const entries = readdirSync9(parent);
     let roots = 0;
     for (const entry of entries) {
       if (entry === ".codex-remote-plugin-install.json")
@@ -56198,7 +56466,7 @@ var init_managed_policy = __esm(() => {
 
 // src/lib/agent-bridge.ts
 import { createHash as createHash22 } from "crypto";
-import { lstatSync as lstatSync23, readFileSync as readFileSync17, readdirSync as readdirSync9 } from "fs";
+import { lstatSync as lstatSync23, readFileSync as readFileSync17, readdirSync as readdirSync10 } from "fs";
 import { join as join31 } from "path";
 function isOwnedCliBridge(path, expectedPaths) {
   if (!expectedPaths.includes(path))
@@ -56206,7 +56474,7 @@ function isOwnedCliBridge(path, expectedPaths) {
   try {
     if (!lstatSync23(path).isDirectory())
       return false;
-    if (JSON.stringify(readdirSync9(path).sort()) !== JSON.stringify(Object.keys(CLI_BRIDGE_FILES).sort()))
+    if (JSON.stringify(readdirSync10(path).sort()) !== JSON.stringify(Object.keys(CLI_BRIDGE_FILES).sort()))
       return false;
     return Object.entries(CLI_BRIDGE_FILES).every(([name, content]) => {
       const file = join31(path, name), stat2 = lstatSync23(file);
@@ -56641,7 +56909,7 @@ var init_hook_diagnostics = __esm(() => {
 });
 
 // src/lib/agent-sumi.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import { accessSync as accessSync2, constants as constants15, existsSync as existsSync12, lstatSync as lstatSync24, realpathSync as realpathSync9, statSync as statSync10 } from "fs";
 import { delimiter as delimiter2, isAbsolute as isAbsolute21, join as join32, resolve as resolve21 } from "path";
 function recordWithKeys(value, keys2) {
@@ -56715,7 +56983,7 @@ function sumiPathPlan(home, cwd2 = process.cwd(), env3 = process.env) {
       childEnv[key2] = env3[key2];
   let child2;
   try {
-    child2 = spawnSync3(executable2, ["--json", "--home", resolve21(home), "--cwd", resolve21(cwd2)], {
+    child2 = spawnSync4(executable2, ["--json", "--home", resolve21(home), "--cwd", resolve21(cwd2)], {
       cwd: resolve21(cwd2),
       env: childEnv,
       encoding: "buffer",
@@ -57296,8 +57564,8 @@ function assertPinnedLauncherShell() {
     if (!stat2.isFile() || (stat2.mode & 73) === 0)
       throw new Error("LAUNCHER_SHELL_UNSUPPORTED");
   }
-  const probe = Bun.spawnSync(["/bin/sh", "-p", "-c", "exit 0"], { env: {}, stdin: "ignore", stdout: "ignore", stderr: "ignore" });
-  if (probe.exitCode !== 0)
+  const probe2 = Bun.spawnSync(["/bin/sh", "-p", "-c", "exit 0"], { env: {}, stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+  if (probe2.exitCode !== 0)
     throw new Error("LAUNCHER_SHELL_UNSUPPORTED");
 }
 var PINNED_LAUNCHER_SCHEMA = "hasna-skills-pinned-launcher-v2", LAUNCH_CWD_VARIABLE3 = "HASNA_SKILLS_LAUNCH_CWD", PINNED_LAUNCHER_BUN_FLAGS2, PINNED_LAUNCHER_ENV_NAMES, PINNED_LAUNCHER_ENV_PREFIXES, ENV_NAME, ENV_PREFIX, ENV_EXACT, COMMAND_LINE, PINNED_LAUNCHER_MAX_BYTES;
@@ -57346,7 +57614,7 @@ var init_runtime_launcher = __esm(() => {
 
 // src/lib/retained-review-artifacts.ts
 import { createHash as createHash25 } from "crypto";
-import { constants as constants18, closeSync as closeSync16, fstatSync as fstatSync16, fsyncSync as fsyncSync6, lstatSync as lstatSync27, mkdirSync as mkdirSync7, openSync as openSync16, readSync as readSync12, writeSync as writeSync4 } from "fs";
+import { constants as constants18, closeSync as closeSync16, fstatSync as fstatSync16, fsyncSync as fsyncSync6, lstatSync as lstatSync27, mkdirSync as mkdirSync8, openSync as openSync16, readSync as readSync12, writeSync as writeSync4 } from "fs";
 import { dirname as dirname21, isAbsolute as isAbsolute24, join as join33, resolve as resolve23, sep as sep12 } from "path";
 function keys2(value, names) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === names.length && names.every((name) => Object.hasOwn(value, name)));
@@ -57467,7 +57735,7 @@ function writeReviewArtifactExclusive(change) {
   for (let parent = dirname21(change.path);!lstatSync27(parent, { throwIfNoEntry: false }); parent = dirname21(parent))
     missing2.push(parent);
   for (const parent of missing2.reverse())
-    mkdirSync7(parent, { mode: 448 });
+    mkdirSync8(parent, { mode: 448 });
   safe4(change.path);
   privateStore(change.artifact.storeRoot);
   for (let parent = dirname21(change.path);parent !== change.artifact.storeRoot; parent = dirname21(parent)) {
@@ -57510,7 +57778,7 @@ var init_retained_review_artifacts = __esm(() => {
 // src/lib/agent-integration.ts
 import { createHash as createHash26, randomUUID as randomUUID7 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual9 } from "util";
-import { existsSync as existsSync13, lstatSync as lstatSync28, statSync as statSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync19, readdirSync as readdirSync10, opendirSync as opendirSync4, readlinkSync as readlinkSync7, realpathSync as realpathSync11, renameSync as renameSync4, rmdirSync as rmdirSync3, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5, chmodSync, openSync as openSync17, closeSync as closeSync17, fsyncSync as fsyncSync7, fstatSync as fstatSync17, readSync as readSync13, constants as constants19, linkSync as linkSync3 } from "fs";
+import { existsSync as existsSync13, lstatSync as lstatSync28, statSync as statSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync19, readdirSync as readdirSync11, opendirSync as opendirSync4, readlinkSync as readlinkSync7, realpathSync as realpathSync11, renameSync as renameSync4, rmdirSync as rmdirSync3, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5, chmodSync, openSync as openSync17, closeSync as closeSync17, fsyncSync as fsyncSync7, fstatSync as fstatSync17, readSync as readSync13, constants as constants19, linkSync as linkSync3 } from "fs";
 import { basename as basename12, dirname as dirname22, join as join34, resolve as resolve24, relative as relative8, isAbsolute as isAbsolute25, sep as sep13 } from "path";
 import { homedir as homedir3 } from "os";
 function nativeAgentRoot(home, agent, cwd2 = process.cwd()) {
@@ -57731,7 +57999,7 @@ function treeHash(root) {
     const rel = relative8(root, path);
     if (stat2.isDirectory()) {
       hash3.update(`d\x00${rel}\x00`);
-      for (const name of readdirSync10(path).sort())
+      for (const name of readdirSync11(path).sort())
         visit2(join34(path, name));
       return;
     }
@@ -58592,7 +58860,7 @@ function verifyCoordinatedDiscovery(binding, home, aliases, executable2) {
 }
 function atomicWrite2(path, content) {
   assertSafePath(path);
-  mkdirSync8(dirname22(path), { recursive: true, mode: 448 });
+  mkdirSync9(dirname22(path), { recursive: true, mode: 448 });
   const temporary = `${path}.skills-${randomUUID7()}`;
   try {
     writeFileSync6(temporary, content, { mode: 384, flag: "wx" });
@@ -58760,7 +59028,7 @@ function planCodexSemanticCacheWitnessUpgrade(options) {
         throw new Error("Local marketplace hook parent is not enabled in the unchanged Codex settings");
       identity6 = { role: "reviewed-hook", pluginId: pluginId2, namespace: parts[1], pluginParent: parent, installation: "local-marketplace", marketplaceSourcePath: source.path, marketplaceSha256: source.sha256 };
     }
-    const versions = readdirSync10(parent).filter((name) => name !== ".codex-remote-plugin-install.json");
+    const versions = readdirSync11(parent).filter((name) => name !== ".codex-remote-plugin-install.json");
     if (!versions.length || versions.length > 4096)
       throw new Error("Reviewed native-hook parent has no bounded materializations");
     for (const version of versions) {
@@ -58854,9 +59122,10 @@ function applyAgentIntegration(plan, options = {}) {
     const alias = plan.rootAliases?.find((item) => item.agent === "codex" && (change.path === item.target || change.path.startsWith(item.target + "/")));
     return lexical ? [lexical] : alias ? [alias.alias] : [];
   });
-  return withCodexCorpusWrite(roots, (assertCurrent) => applyAgentIntegrationUnlocked(plan, options, assertCurrent), options);
+  return withCodexCorpusWrite(roots, (assertCurrent, admission) => applyAgentIntegrationUnlocked(plan, options, assertCurrent, admission), options);
 }
-function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
+function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent, admission) {
+  const fallback = codexAdmissionReceipt(admission);
   for (const source of plan.reviewArtifactSources ?? [])
     verifyReviewArtifactOriginal(source.path, source.sha256);
   for (const source of plan.observedNativeSources ?? [])
@@ -58920,10 +59189,10 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
     recheckRootAliases(aliases);
     for (const agent of plan.retainedReviewChecks?.agents ?? [])
       assertManagedAgentBridge(agent, { ...plan.retainedReviewChecks, dataDir: plan.dataDir });
-    return { changed: [], backups, ...aliases.length ? { rootAliases: aliases } : {} };
+    return { changed: [], backups, ...aliases.length ? { rootAliases: aliases } : {}, ...fallback };
   }
   assertSafePath(backupRoot);
-  mkdirSync8(backupRoot, { recursive: true, mode: 448 });
+  mkdirSync9(backupRoot, { recursive: true, mode: 448 });
   chmodSync(backupRoot, 448);
   for (const [index, change] of plan.changes.entries())
     if (change.before !== null) {
@@ -58971,7 +59240,7 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
       assertManagedAgentBridge(agent, { home: plan.managedAgentChecks.home, dataDir: plan.dataDir, projectDir: plan.managedAgentChecks.projectDir ?? plan.managedAgentChecks.home });
     for (const agent of plan.retainedReviewChecks?.agents ?? [])
       assertManagedAgentBridge(agent, { ...plan.retainedReviewChecks, dataDir: plan.dataDir });
-    atomicWrite2(join34(backupRoot, "receipt.json"), JSON.stringify({ version: 1, changes: written.map((change) => ({ path: change.path, beforeHash: change.before === null ? null : sha4(change.before), afterHash: sha4(change.after) })), backups, ...plan.cacheWitnessUpgrade ? { cacheWitnessUpgrade: plan.cacheWitnessUpgrade } : {}, ...plan.retainedReviewArtifacts?.length ? { retainedReviewArtifacts: plan.retainedReviewArtifacts.map((item) => ({ path: item.path, ...item.artifact })) } : {}, ...aliases.length ? { rootAliases: aliases } : {} }) + `
+    atomicWrite2(join34(backupRoot, "receipt.json"), JSON.stringify({ version: 1, changes: written.map((change) => ({ path: change.path, beforeHash: change.before === null ? null : sha4(change.before), afterHash: sha4(change.after) })), backups, ...plan.cacheWitnessUpgrade ? { cacheWitnessUpgrade: plan.cacheWitnessUpgrade } : {}, ...plan.retainedReviewArtifacts?.length ? { retainedReviewArtifacts: plan.retainedReviewArtifacts.map((item) => ({ path: item.path, ...item.artifact })) } : {}, ...aliases.length ? { rootAliases: aliases } : {}, ...fallback }) + `
 `);
   } catch (error) {
     assertCurrent();
@@ -58999,7 +59268,7 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
     }
     throw error;
   }
-  return { changed: plan.changes.map((change) => change.path), backups, ...aliases.length ? { rootAliases: aliases } : {} };
+  return { changed: plan.changes.map((change) => change.path), backups, ...aliases.length ? { rootAliases: aliases } : {}, ...fallback };
 }
 function syncArchiveDirectory(path) {
   assertSafePath(path);
@@ -59039,9 +59308,10 @@ function archiveNativeSkills(inventory, options) {
       throw new Error("CODEX_CORPUS_ROOT_UNVERIFIED");
     return [...new Set([root, owner2].filter((value) => value !== undefined))];
   });
-  return withCodexCorpusWrite(roots, (assertCurrent) => archiveNativeSkillsUnlocked(inventory, options, assertCurrent), options);
+  return withCodexCorpusWrite(roots, (assertCurrent, admission) => archiveNativeSkillsUnlocked(inventory, options, assertCurrent, admission), options);
 }
-function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
+function archiveNativeSkillsUnlocked(inventory, options, assertCurrent, admission) {
+  const fallback = codexAdmissionReceipt(admission);
   const aliases = [...new Map(inventory.filter((entry) => entry.rootAlias).map((entry) => [entry.rootAlias.alias, entry.rootAlias])).values()];
   if (aliases.length && !options.allowRootAliases)
     throw new Error("Native migration requires explicit allowRootAliases for agent root aliases");
@@ -59059,7 +59329,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
       throw new Error(`Native skill changed after planning: ${entry.path}`);
   const targetManifest = options.targetManifest ? { schema: options.targetManifest.schema, digest: options.targetManifest.digest, targetCount: options.targetManifest.targets.length } : undefined;
   if (!selected.length)
-    return { entries: [], ...targetManifest ? { targetManifest } : {}, ...aliases.length ? { rootAliases: aliases } : {} };
+    return { entries: [], ...targetManifest ? { targetManifest } : {}, ...aliases.length ? { rootAliases: aliases } : {}, ...fallback };
   const operationId = randomUUID7(), archiveRoot = join34(options.dataDir ?? getDataDir(), "migration", operationId, "native"), receiptPath = join34(archiveRoot, "receipt.json");
   const entries = selected.map((entry, index) => ({
     source: entry.vendor ? join34(entry.path, "SKILL.md") : entry.path,
@@ -59068,7 +59338,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
     ...entry.vendor ? { discoveryOnly: true } : {},
     status: "planned"
   }));
-  const journal = { version: 2, operationId, status: "planned", entries, ...targetManifest ? { targetManifest } : {}, ...aliases.length ? { rootAliases: aliases } : {} };
+  const journal = { version: 2, operationId, status: "planned", entries, ...targetManifest ? { targetManifest } : {}, ...aliases.length ? { rootAliases: aliases } : {}, ...fallback };
   const moved = [];
   const verifyArchive = (entry) => {
     assertSafePath(entry.archive);
@@ -59082,7 +59352,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
   const created = [];
   for (let path = archiveRoot;!existsSync13(path); path = dirname22(path))
     created.push(path);
-  mkdirSync8(archiveRoot, { recursive: true, mode: 448 });
+  mkdirSync9(archiveRoot, { recursive: true, mode: 448 });
   try {
     for (const directory2 of created)
       syncArchiveDirectory(directory2);
@@ -59165,7 +59435,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
     } catch {}
     throw new Error(`Native archive failed; inspect the recovery journal at ${receiptPath} before retrying.`, { cause: error });
   }
-  return { entries: entries.map(({ status, conflict, ...entry }) => entry), receiptPath, ...targetManifest ? { targetManifest } : {}, ...aliases.length ? { rootAliases: aliases } : {} };
+  return { entries: entries.map(({ status, conflict, ...entry }) => entry), receiptPath, ...targetManifest ? { targetManifest } : {}, ...aliases.length ? { rootAliases: aliases } : {}, ...fallback };
 }
 function classifiedCodexPluginCacheCopy(entry, cache3, read2, admit) {
   try {
@@ -59574,7 +59844,7 @@ var init_agent_integration = __esm(() => {
 });
 
 // src/lib/home-migration.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readdirSync as readdirSync11, renameSync as renameSync5, rmSync as rmSync2, statSync as statSync12, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync10, readdirSync as readdirSync12, renameSync as renameSync5, rmSync as rmSync3, statSync as statSync12, writeFileSync as writeFileSync7 } from "fs";
 import { join as join35 } from "path";
 function layoutMigrationRecordPath(appDir) {
   return join35(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD);
@@ -59600,7 +59870,7 @@ function listLegacyFlatSkillDirs(appDir) {
     return legacy;
   let entries = [];
   try {
-    entries = readdirSync11(appDir);
+    entries = readdirSync12(appDir);
   } catch {
     return legacy;
   }
@@ -59619,7 +59889,7 @@ function createLazyDirs(appDir, created) {
   for (const name of [LOGS_DIRNAME, OUTPUTS_DIRNAME]) {
     const dir = join35(appDir, name);
     if (!existsSync14(dir)) {
-      mkdirSync9(dir, { recursive: true });
+      mkdirSync10(dir, { recursive: true });
       created.push(dir);
     }
   }
@@ -59636,7 +59906,7 @@ function migrateOwnerLayout(options = {}) {
   if (existsSync14(cache3)) {
     let entries = [];
     try {
-      entries = readdirSync11(cache3);
+      entries = readdirSync12(cache3);
     } catch {}
     if (entries.length > 0) {
       return {
@@ -59663,7 +59933,7 @@ function migrateOwnerLayout(options = {}) {
     if (!existsSync14(dir))
       continue;
     try {
-      for (const entry of readdirSync11(dir))
+      for (const entry of readdirSync12(dir))
         collisionNames.add(entry);
     } catch {}
   }
@@ -59678,13 +59948,13 @@ function migrateOwnerLayout(options = {}) {
     }
   }
   if (existsSync14(cache3)) {
-    rmSync2(cache3, { recursive: true, force: true });
+    rmSync3(cache3, { recursive: true, force: true });
   }
   if (installedPresent) {
     renameSync5(installed, cache3);
     moved.push(INSTALLED_SKILLS_DIRNAME);
   } else {
-    mkdirSync9(cache3, { recursive: true });
+    mkdirSync10(cache3, { recursive: true });
   }
   for (const name of legacy) {
     renameSync5(join35(appDir, name), join35(cache3, name));
@@ -59713,12 +59983,12 @@ import {
   cpSync as cpSync2,
   existsSync as existsSync15,
   lstatSync as lstatSync29,
-  mkdirSync as mkdirSync10,
-  mkdtempSync,
+  mkdirSync as mkdirSync11,
+  mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync20,
-  readdirSync as readdirSync12,
+  readdirSync as readdirSync13,
   renameSync as renameSync6,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   statSync as statSync13,
   writeFileSync as writeFileSync8
 } from "fs";
@@ -59823,7 +60093,7 @@ function packageSourceRoots(source) {
 function containsSkillDirectories(path) {
   let entries;
   try {
-    entries = readdirSync12(path);
+    entries = readdirSync13(path);
   } catch {
     return false;
   }
@@ -59918,12 +60188,16 @@ function writeManagedAgentSkill(params) {
     agent: params.agent,
     path: result2.path,
     action: result2.action,
-    ...result2.reason ? { reason: result2.reason } : {}
+    ...result2.reason ? { reason: result2.reason } : {},
+    ...result2.nativeAdmission ? { nativeAdmission: result2.nativeAdmission, nativeAdmissionProbe: result2.nativeAdmissionProbe } : {}
   };
 }
 function writeManagedSkillDir(dir, skillMd, options) {
   const root = options.dryRun ? undefined : codexCorpusRootForPath(dir);
-  return withCodexCorpusWrite(root ? [root] : [], (assertCurrent) => writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent), options);
+  return withCodexCorpusWrite(root ? [root] : [], (assertCurrent, admission) => {
+    const result2 = writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent);
+    return { ...result2, ...codexAdmissionReceipt(admission) };
+  }, options);
 }
 function writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent) {
   const skillMdPath = join36(dir, "SKILL.md");
@@ -59964,8 +60238,8 @@ function writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent) {
   if (options.dryRun)
     return { action, path: skillMdPath };
   const parentDir = dirname23(dir);
-  mkdirSync10(parentDir, { recursive: true });
-  const transactionDir = mkdtempSync(join36(parentDir, `.hasna-skills-write-${basename13(dir)}-`));
+  mkdirSync11(parentDir, { recursive: true });
+  const transactionDir = mkdtempSync2(join36(parentDir, `.hasna-skills-write-${basename13(dir)}-`));
   const candidateDir = join36(transactionDir, "candidate");
   const backupDir = join36(transactionDir, "backup");
   const candidateSkillMdPath = join36(candidateDir, "SKILL.md");
@@ -59983,7 +60257,7 @@ function writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent) {
     if (options.resourceDir) {
       cpSync2(options.resourceDir, candidateDir, { recursive: true, force: true });
     } else {
-      mkdirSync10(candidateDir, { recursive: true });
+      mkdirSync11(candidateDir, { recursive: true });
     }
     writeFileSync8(candidateSkillMdPath, skillMd.endsWith(`
 `) ? skillMd : `${skillMd}
@@ -60007,7 +60281,7 @@ function writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent) {
       try {
         assertCurrent();
         if (existsSync15(dir))
-          rmSync3(dir, { recursive: true, force: true });
+          rmSync4(dir, { recursive: true, force: true });
         renameDirectory(backupDir, dir);
         originalMoved = false;
       } catch (rollbackError) {
@@ -60020,7 +60294,7 @@ function writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent) {
     if (!preserveTransaction) {
       try {
         assertCurrent();
-        rmSync3(transactionDir, { recursive: true, force: true });
+        rmSync4(transactionDir, { recursive: true, force: true });
       } catch {}
     }
   }
@@ -60081,7 +60355,7 @@ var init_skill_aliases = __esm(() => {
 });
 
 // src/lib/project-state.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync12, readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
 import { join as join37 } from "path";
 function getProjectStateDir(targetDir = process.cwd()) {
   return join37(targetDir, SKILLS_PROJECT_DIR);
@@ -60115,7 +60389,7 @@ function ensureProjectConfig(targetDir = process.cwd()) {
 }
 function saveProjectConfig(config, targetDir = process.cwd()) {
   const dir = getProjectStateDir(targetDir);
-  mkdirSync11(dir, { recursive: true });
+  mkdirSync12(dir, { recursive: true });
   const normalized2 = normalizeProjectConfig({ ...config, updatedAt: new Date().toISOString() });
   writeFileSync9(getProjectConfigPath(targetDir), JSON.stringify(normalized2, null, 2) + `
 `);
@@ -60248,7 +60522,7 @@ __export(exports_installer, {
   AGENT_TARGETS: () => AGENT_TARGETS,
   AGENT_LABELS: () => AGENT_LABELS
 });
-import { existsSync as existsSync17, readFileSync as readFileSync23, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync23, rmSync as rmSync5 } from "fs";
 import { join as join38 } from "path";
 import { homedir as homedir5 } from "os";
 function getSkillPath(name) {
@@ -60458,15 +60732,20 @@ function installSkillForAgent(name, options, generateSkillMd) {
     codexCommand: options.codexCommand,
     codexSha256: options.codexSha256
   });
+  const fallback = result2.nativeAdmission ? { nativeAdmission: result2.nativeAdmission, nativeAdmissionProbe: result2.nativeAdmissionProbe } : {};
   if (result2.action === "skip") {
-    return { skill: canonicalName, success: false, error: result2.reason ?? "skipped", path: result2.path };
+    return { skill: canonicalName, success: false, error: result2.reason ?? "skipped", path: result2.path, ...fallback };
   }
-  return { skill: canonicalName, success: true, path: result2.path };
+  return { skill: canonicalName, success: true, path: result2.path, ...fallback };
 }
 function removeSkillForAgent(name, options) {
+  const record5 = codexAdmissionRecord(options);
   const dir = getAgentSkillPath(name, options.agent, options.scope ?? "global", options.projectDir);
   const root = codexCorpusRootForPath(dir);
-  return withCodexCorpusWrite(root ? [root] : [], () => removeSkillForAgentUnlocked(name, options), options);
+  return withCodexCorpusWrite(root ? [root] : [], (_assertCurrent, admission) => {
+    record5.deliver(admission);
+    return removeSkillForAgentUnlocked(name, options);
+  }, options, record5.policy);
 }
 function removeSkillForAgentUnlocked(name, options) {
   const canonicalName = getCanonicalSkillName(name);
@@ -60474,7 +60753,7 @@ function removeSkillForAgentUnlocked(name, options) {
   const dir = getAgentSkillPath(canonicalName, options.agent, scope, options.projectDir);
   if (!hasSkillsOwnershipMarker(dir))
     return false;
-  rmSync4(dir, { recursive: true, force: true });
+  rmSync5(dir, { recursive: true, force: true });
   return true;
 }
 function resolveAgentSkillMd(name, generateSkillMd) {
@@ -62322,7 +62601,7 @@ var init_codex_hook_discovery_recovery = __esm(() => {
 
 // src/lib/agent-discovery.ts
 import { createHash as createHash29 } from "crypto";
-import { lstatSync as lstatSync32, readFileSync as readFileSync26, readdirSync as readdirSync13, realpathSync as realpathSync12 } from "fs";
+import { lstatSync as lstatSync32, readFileSync as readFileSync26, readdirSync as readdirSync14, realpathSync as realpathSync12 } from "fs";
 import { basename as basename16, dirname as dirname26, isAbsolute as isAbsolute30, join as join42, relative as relative9, resolve as resolve28, sep as sep14 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual13 } from "util";
 function discoveryRootUnresolved(agent, command, detail) {
@@ -63073,13 +63352,13 @@ function assertProjectDiscovery(agent, directories, home, canonical9 = resolve28
       for (const name of ["plugin", "plugins"]) {
         const path = canonical9(join42(directory2, ".sumi", name));
         safe6(path);
-        if (lstatSync32(path, { throwIfNoEntry: false })?.isDirectory() && readdirSync13(path).length)
+        if (lstatSync32(path, { throwIfNoEntry: false })?.isDirectory() && readdirSync14(path).length)
           throw new Error(`NATIVE_SKILL_DRIFT: project Sumi plugins require a dedicated discovery review: ${path}`);
       }
     if (agent === "claude") {
       const commands = canonical9(join42(directory2, ".claude/commands"));
       safe6(commands);
-      if (lstatSync32(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync13(commands).length)
+      if (lstatSync32(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync14(commands).length)
         throw new Error("NATIVE_SKILL_DRIFT: legacy project command discovery requires a dedicated format adapter");
     }
   }
@@ -63228,7 +63507,7 @@ function resolveAgentDiscovery(options) {
     for (const path of plugins) {
       safe6(path);
       if (lstatSync32(path, { throwIfNoEntry: false })?.isDirectory())
-        for (const name of readdirSync13(path).sort()) {
+        for (const name of readdirSync14(path).sort()) {
           if (name === "skills-cli.js" && path === plugins[1])
             continue;
           const target = join42(path, name);
@@ -63239,7 +63518,7 @@ function resolveAgentDiscovery(options) {
     }
     for (const root2 of roots) {
       safe6(root2);
-      if (lstatSync32(root2, { throwIfNoEntry: false })?.isDirectory() && readdirSync13(root2).some((name) => name.endsWith(".md")))
+      if (lstatSync32(root2, { throwIfNoEntry: false })?.isDirectory() && readdirSync14(root2).some((name) => name.endsWith(".md")))
         unresolved("flat markdown skills require a dedicated native migration adapter");
     }
   }
@@ -63283,7 +63562,7 @@ function resolveAgentDiscovery(options) {
       safe6(builtinRoot);
       if (!lstatSync32(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
         unresolved("installed Gemini builtin root is missing");
-      for (const name of readdirSync13(builtinRoot).sort()) {
+      for (const name of readdirSync14(builtinRoot).sort()) {
         const text3 = witness(join42(builtinRoot, name, "SKILL.md"));
         const match = text3?.match(/^---\r?\n[\s\S]*?^name:\s*([a-z0-9][a-z0-9-]*)\s*$/m);
         if (!match?.[1] || builtinNames.includes(match[1]))
@@ -63381,7 +63660,7 @@ function resolveAgentDiscovery(options) {
       unresolved("plugin hooks require a separate no-skill-injection review");
     const commands = join42(root2, "commands");
     safe6(commands);
-    if (agent === "claude" && (manifest.commands !== undefined || lstatSync32(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync13(commands).length))
+    if (agent === "claude" && (manifest.commands !== undefined || lstatSync32(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync14(commands).length))
       unresolved("legacy command discovery requires retirement or a dedicated format adapter");
     const rootSkill = witness(join42(root2, "SKILL.md"));
     if (rootSkill !== null)
@@ -63403,7 +63682,7 @@ function resolveAgentDiscovery(options) {
     const installed = registrations === null ? {} : parseConfig(registrations, join42(home, ".claude/plugins/installed_plugins.json")).plugins;
     const commands = canonical9(join42(home, ".claude/commands"));
     safe6(commands);
-    if (lstatSync32(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync13(commands).length)
+    if (lstatSync32(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync14(commands).length)
       unresolved("legacy home command discovery requires a dedicated format adapter");
     for (const [id, enabled] of Object.entries(config.enabledPlugins ?? {})) {
       if (enabled === false)
@@ -63445,7 +63724,7 @@ function resolveAgentDiscovery(options) {
     }
     const localPlugins = join42(home, ".config/opencode/plugins");
     safe6(localPlugins);
-    if (lstatSync32(localPlugins, { throwIfNoEntry: false }) && readdirSync13(localPlugins).some((name) => name !== "skills-cli.js"))
+    if (lstatSync32(localPlugins, { throwIfNoEntry: false }) && readdirSync14(localPlugins).some((name) => name !== "skills-cli.js"))
       unresolved("additional local plugin hooks require review");
   } else if (agent === "sumi") {
     if ((config.plugin?.length ?? 0) > 0 || (config.plugins?.length ?? 0) > 0 || sources.some((source) => source.path !== canonical9(configPath) && source.path !== canonical9(join42(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
@@ -63464,7 +63743,7 @@ function resolveAgentDiscovery(options) {
     const directory2 = join42(home, ".gemini/extensions");
     safe6(directory2);
     if (lstatSync32(directory2, { throwIfNoEntry: false }))
-      for (const name of readdirSync13(directory2)) {
+      for (const name of readdirSync14(directory2)) {
         const root2 = join42(directory2, name);
         safe6(root2);
         if (!lstatSync32(root2)?.isDirectory())
@@ -63552,7 +63831,7 @@ function physicalPath(path) {
   }
   return resolve29(realpathSync13(cursor), ...suffix);
 }
-function contains(root2, path) {
+function contains2(root2, path) {
   return path === root2 || path.startsWith(root2 + sep15);
 }
 function configuredRoots(home, explicitHome) {
@@ -63605,14 +63884,14 @@ function assertPortableAuthoringPath(path, options = {}) {
   const defaults2 = NATIVE_DISCOVERY_ROOTS.map((parts) => join43(home, ...parts));
   defaults2.push(join43(home, ".codex/plugins/cache"), join43(home, ".claude/plugins/cache"), join43(home, ".claude/plugins/synced"), join43(home, ".gemini/extensions"));
   for (const root2 of defaults2) {
-    if (candidates.some((candidate2) => contains(resolve29(root2), candidate2) || contains(physicalPath(root2), candidate2)))
+    if (candidates.some((candidate2) => contains2(resolve29(root2), candidate2) || contains2(physicalPath(root2), candidate2)))
       native ??= root2;
   }
   if (native) {
     throw new Error(`Refusing portable Skills authoring below native discovery root '${native}': ${lexical}. Set HASNA_SKILLS_DIR to a private authoring corpus outside native roots.`);
   }
   for (const root2 of configuredRoots(home, options.homeDir !== undefined)) {
-    if (candidates.some((candidate2) => contains(resolve29(root2), candidate2) || contains(physicalPath(root2), candidate2))) {
+    if (candidates.some((candidate2) => contains2(resolve29(root2), candidate2) || contains2(physicalPath(root2), candidate2))) {
       throw new Error(`Refusing portable Skills authoring below configured native discovery root: ${lexical}`);
     }
   }
@@ -63630,12 +63909,12 @@ var init_authoring_path = __esm(() => {
 // src/lib/portable-skills.ts
 import {
   existsSync as existsSync19,
-  mkdirSync as mkdirSync12,
-  mkdtempSync as mkdtempSync2,
-  readdirSync as readdirSync14,
+  mkdirSync as mkdirSync13,
+  mkdtempSync as mkdtempSync3,
+  readdirSync as readdirSync15,
   realpathSync as realpathSync14,
   renameSync as renameSync7,
-  rmSync as rmSync5,
+  rmSync as rmSync6,
   statSync as statSync14,
   writeFileSync as writeFileSync10
 } from "fs";
@@ -63680,7 +63959,7 @@ function listPortableSkills(options = {}) {
   if (!safeIsDirectory(root2))
     return [];
   const skills = [];
-  for (const entry of readdirSync14(root2).sort()) {
+  for (const entry of readdirSync15(root2).sort()) {
     if (entry.startsWith("."))
       continue;
     const path = join44(root2, entry);
@@ -63723,7 +64002,7 @@ function scaffoldPortableSkill(name, options = {}) {
   if (existsSync19(skillPath)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${skillPath}`);
-    rmSync5(skillPath, { recursive: true, force: true });
+    rmSync6(skillPath, { recursive: true, force: true });
   }
   const kind = options.kind ?? "executable";
   const description = options.description ?? `${displayName(skillName)} skill`;
@@ -63750,7 +64029,7 @@ function portPortableSkillDirectory(sourceDir, options = {}) {
   };
   const imported = [];
   const skipped = [];
-  const entries = readdirSync14(absoluteSource, { withFileTypes: true }).map((entry) => entry.name).filter((entryName) => !entryName.startsWith(".")).sort();
+  const entries = readdirSync15(absoluteSource, { withFileTypes: true }).map((entry) => entry.name).filter((entryName) => !entryName.startsWith(".")).sort();
   for (const entryName of entries) {
     const childPath = join44(absoluteSource, entryName);
     if (!safeIsDirectory(childPath))
@@ -63795,11 +64074,11 @@ function physicalImportPath(path) {
 function assertDisjointImportPaths(source, destination) {
   const sourcePath = realpathSync14(source);
   const destinationPath = physicalImportPath(destination);
-  const contains2 = (parent, child2) => {
+  const contains3 = (parent, child2) => {
     const path = relative10(parent, child2);
     return path === "" || !isAbsolute31(path) && path !== ".." && !path.startsWith(`..${sep16}`);
   };
-  if (contains2(sourcePath, destinationPath) || contains2(destinationPath, sourcePath)) {
+  if (contains3(sourcePath, destinationPath) || contains3(destinationPath, sourcePath)) {
     throw new Error("Source and destination skill directories must not overlap");
   }
 }
@@ -63826,9 +64105,9 @@ function portPortableSkill(sourcePath, options = {}) {
   if (existsSync19(destination)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
-    rmSync5(destination, { recursive: true, force: true });
+    rmSync6(destination, { recursive: true, force: true });
   }
-  mkdirSync12(dirname28(destination), { recursive: true });
+  mkdirSync13(dirname28(destination), { recursive: true });
   copySkillDirectory(absoluteSource, destination);
   const base2 = {
     ...inferred,
@@ -63870,8 +64149,8 @@ function installCorpusSkillAtomically(input, options = {}) {
   const target = join44(root2, name);
   assertPortableAuthoringPath(target, options);
   const created = !existsSync19(target);
-  mkdirSync12(root2, { recursive: true });
-  const staging = mkdtempSync2(join44(root2, `.pull-${name}-`));
+  mkdirSync13(root2, { recursive: true });
+  const staging = mkdtempSync3(join44(root2, `.pull-${name}-`));
   let moved = false;
   let backup = null;
   try {
@@ -63879,16 +64158,16 @@ function installCorpusSkillAtomically(input, options = {}) {
     const manifest = buildCorpusManifest(input, name);
     writeSkillJsonWithHash(staging, manifest);
     if (existsSync19(target)) {
-      backup = mkdtempSync2(join44(root2, `.pull-backup-${name}-`));
+      backup = mkdtempSync3(join44(root2, `.pull-backup-${name}-`));
       renameSync7(target, join44(backup, name));
       moved = true;
     }
     renameSync7(staging, target);
     if (moved && backup)
-      rmSync5(backup, { recursive: true, force: true });
+      rmSync6(backup, { recursive: true, force: true });
     return { name, path: target, manifest, created };
   } catch (error) {
-    rmSync5(staging, { recursive: true, force: true });
+    rmSync6(staging, { recursive: true, force: true });
     if (moved && backup && existsSync19(join44(backup, name))) {
       try {
         renameSync7(join44(backup, name), target);
@@ -64133,7 +64412,7 @@ __export(exports_registry, {
   CATEGORIES: () => CATEGORIES,
   BASIC_SKILL_NAMES: () => BASIC_SKILL_NAMES
 });
-import { existsSync as existsSync20, readFileSync as readFileSync27, readdirSync as readdirSync15 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync27, readdirSync as readdirSync16 } from "fs";
 import { join as join45 } from "path";
 function isBasicSkillName(name) {
   return BASIC_SKILL_NAMES.includes(name);
@@ -64174,7 +64453,7 @@ function discoverSkillsInDir(dir, source = "custom") {
     return [];
   const result2 = [];
   try {
-    const entries = readdirSync15(dir, { withFileTypes: true });
+    const entries = readdirSync16(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
@@ -64210,7 +64489,7 @@ function findExtensionSkillPath(name) {
   if (!config.extensionsDir || !existsSync20(config.extensionsDir))
     return null;
   try {
-    const entries = readdirSync15(config.extensionsDir, { withFileTypes: true });
+    const entries = readdirSync16(config.extensionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
@@ -65932,7 +66211,7 @@ var require_cli_spinners = __commonJS((exports, module) => {
 });
 
 // src/lib/auth-store.ts
-import { chmodSync as chmodSync2, existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync28, renameSync as renameSync8, statSync as statSync15, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync21, mkdirSync as mkdirSync14, readFileSync as readFileSync28, renameSync as renameSync8, statSync as statSync15, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
 import { basename as basename19, dirname as dirname29, join as join46 } from "path";
 function getAuthFilePath(env3 = process.env) {
   return skillsCredentialFilePath(env3);
@@ -65973,7 +66252,7 @@ function getAuthConfig(env3 = process.env, options = {}) {
 }
 function writeCredentialValues(values2, env3 = process.env) {
   const file = skillsCredentialFilePath(env3);
-  mkdirSync13(dirname29(file), { recursive: true, mode: 448 });
+  mkdirSync14(dirname29(file), { recursive: true, mode: 448 });
   const lines = [];
   const written = new Set;
   if (existsSync21(file)) {
@@ -87962,7 +88241,7 @@ var init_remote_auth = __esm(() => {
 
 // src/lib/sign-in.ts
 import { createHash as createHash32 } from "crypto";
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync14, readFileSync as readFileSync29, readdirSync as readdirSync16, renameSync as renameSync9, unlinkSync as unlinkSync7, writeFileSync as writeFileSync12 } from "fs";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync15, readFileSync as readFileSync29, readdirSync as readdirSync17, renameSync as renameSync9, unlinkSync as unlinkSync7, writeFileSync as writeFileSync12 } from "fs";
 import { basename as basename20, dirname as dirname30, join as join47 } from "path";
 function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -88116,7 +88395,7 @@ function pendingDeviceSignInPath(origin, env3 = process.env) {
 }
 function savePendingDeviceSignIn(origin, start, env3 = process.env, now3 = Date.now()) {
   const path = pendingDeviceSignInPath(origin, env3);
-  mkdirSync14(dirname30(path), { recursive: true, mode: 448 });
+  mkdirSync15(dirname30(path), { recursive: true, mode: 448 });
   const pending = {
     origin,
     deviceCode: start.deviceCode,
@@ -88174,7 +88453,7 @@ function pendingDeviceSignInOrigins(env3 = process.env, now3 = Date.now()) {
   }
   let entries;
   try {
-    entries = readdirSync16(location.dir);
+    entries = readdirSync17(location.dir);
   } catch {
     return [];
   }
@@ -88205,7 +88484,7 @@ function clearPendingDeviceSignIn(env3 = process.env, origin) {
   }
   let entries;
   try {
-    entries = readdirSync16(location.dir);
+    entries = readdirSync17(location.dir);
   } catch {
     return;
   }
@@ -88884,7 +89163,7 @@ var init_skill_bundles = __esm(() => {
 });
 
 // src/lib/pull.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync15, mkdtempSync as mkdtempSync3, readFileSync as readFileSync30, renameSync as renameSync10, rmSync as rmSync6, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync16, mkdtempSync as mkdtempSync4, readFileSync as readFileSync30, renameSync as renameSync10, rmSync as rmSync7, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname31, join as join48 } from "path";
 async function pullSkills(options = {}) {
   const client2 = options.client !== undefined ? options.client : await createRemoteSkillsClient();
@@ -89041,7 +89320,7 @@ function reconcileTombstone(slug2, corpusOptions) {
   if (!hasSkillsOwnershipMarker(target)) {
     return { name: slug2, success: true, tombstoned: true, removed: false, leftInPlace: true };
   }
-  rmSync6(target, { recursive: true, force: true });
+  rmSync7(target, { recursive: true, force: true });
   return { name: slug2, success: true, tombstoned: true, removed: true };
 }
 function readPullMarker(dir) {
@@ -89180,16 +89459,16 @@ function verifyBundleResponseBytes(buffer, response, verify = {}) {
 }
 function installBundleAtomically(name, entries, options = {}, marker = {}) {
   const root2 = getPortableSkillsRoot(options);
-  mkdirSync15(root2, { recursive: true });
+  mkdirSync16(root2, { recursive: true });
   const target = join48(root2, name);
   const created = !existsSync22(target);
-  const staging = mkdtempSync3(join48(root2, `.pull-${name}-`));
+  const staging = mkdtempSync4(join48(root2, `.pull-${name}-`));
   let moved = false;
   let backup = null;
   try {
     for (const entry of entries) {
       const destination = join48(staging, entry.path);
-      mkdirSync15(dirname31(destination), { recursive: true });
+      mkdirSync16(dirname31(destination), { recursive: true });
       writeFileSync13(destination, entry.bytes, { mode: entry.mode });
     }
     writePullMarker(staging, {
@@ -89201,15 +89480,15 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
       ...marker.revisionId ? { revisionId: marker.revisionId } : {}
     });
     if (existsSync22(target)) {
-      backup = mkdtempSync3(join48(root2, `.pull-backup-${name}-`));
+      backup = mkdtempSync4(join48(root2, `.pull-backup-${name}-`));
       renameSync10(target, join48(backup, name));
       moved = true;
     }
     renameSync10(staging, target);
     if (moved && backup)
-      rmSync6(backup, { recursive: true, force: true });
+      rmSync7(backup, { recursive: true, force: true });
   } catch (error61) {
-    rmSync6(staging, { recursive: true, force: true });
+    rmSync7(staging, { recursive: true, force: true });
     if (moved && backup && existsSync22(join48(backup, name))) {
       try {
         renameSync10(join48(backup, name), target);
@@ -91889,7 +92168,7 @@ var init_init = __esm(() => {
 });
 
 // src/lib/home-adoption.ts
-import { constants as constants22, closeSync as closeSync20, fstatSync as fstatSync20, lstatSync as lstatSync34, openSync as openSync20, readSync as readSync17, existsSync as existsSync25, mkdirSync as mkdirSync16, readdirSync as readdirSync17, readFileSync as readFileSync33, rmSync as rmSync7, statSync as statSync16, writeFileSync as writeFileSync15 } from "fs";
+import { constants as constants22, closeSync as closeSync20, fstatSync as fstatSync20, lstatSync as lstatSync34, openSync as openSync20, readSync as readSync17, existsSync as existsSync25, mkdirSync as mkdirSync17, readdirSync as readdirSync18, readFileSync as readFileSync33, rmSync as rmSync8, statSync as statSync16, writeFileSync as writeFileSync15 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join52 } from "path";
 function indexCanonicalCorpus(corpusRoot) {
@@ -91898,7 +92177,7 @@ function indexCanonicalCorpus(corpusRoot) {
     return byName;
   let entries = [];
   try {
-    entries = readdirSync17(corpusRoot);
+    entries = readdirSync18(corpusRoot);
   } catch {
     return byName;
   }
@@ -91948,7 +92227,7 @@ function scanUnmarkedHomes(options = {}) {
       continue;
     let entries = [];
     try {
-      entries = readdirSync17(home);
+      entries = readdirSync18(home);
     } catch {
       continue;
     }
@@ -92008,11 +92287,11 @@ function appendConflictsLedger(appDir, conflicts) {
   writeFileSync15(ledgerPath, `${JSON.stringify(ledger, null, 2)}
 `);
 }
-function writeRollbackRecord(mode, entries, appDir = getDataDir()) {
+function writeRollbackRecord(mode, entries, appDir = getDataDir(), admission = {}) {
   const dir = join52(appDir, ROLLBACK_DIRNAME);
-  mkdirSync16(dir, { recursive: true });
+  mkdirSync17(dir, { recursive: true });
   const file2 = join52(dir, `${mode}-${Date.now()}.json`);
-  const record12 = { version: 1, mode, timestamp: new Date().toISOString(), entries };
+  const record12 = { version: 1, mode, timestamp: new Date().toISOString(), entries, ...admission };
   writeFileSync15(file2, `${JSON.stringify(record12, null, 2)}
 `);
   return file2;
@@ -92024,8 +92303,9 @@ function adoptUnmarkedHomes(options = {}) {
   }
   const appDir = options.homeDir ? join52(options.homeDir, ".hasna", "skills") : getDataDir();
   const roots = scan.adoptable.map((entry) => codexCorpusRootForPath(entry.path)).filter((root2) => !!root2);
-  return withCodexCorpusWrite(roots, (assertCurrent) => {
+  return withCodexCorpusWrite(roots, (assertCurrent, admission) => {
     assertCurrent();
+    const fallback = codexAdmissionReceipt(admission);
     const canonical9 = indexCanonicalCorpus(resolveCorpusRoot(options));
     const markers = scan.adoptable.map((entry) => {
       const root2 = codexCorpusRootForPath(entry.path);
@@ -92042,7 +92322,7 @@ function adoptUnmarkedHomes(options = {}) {
     assertCurrent();
     let rollbackFile;
     if (markers.length > 0) {
-      rollbackFile = writeRollbackRecord("adopt", markers, appDir);
+      rollbackFile = writeRollbackRecord("adopt", markers, appDir, fallback);
     }
     for (const entry of markers) {
       assertCurrent();
@@ -92055,7 +92335,7 @@ function adoptUnmarkedHomes(options = {}) {
     }
     assertCurrent();
     appendConflictsLedger(appDir, scan.conflicts);
-    return { ...scan, applied: true, rollbackFile };
+    return { ...scan, applied: true, rollbackFile, ...fallback };
   }, options);
 }
 function pruneOwnership(dir) {
@@ -92107,7 +92387,7 @@ function pruneStrayHomes(options = {}) {
       continue;
     let entries = [];
     try {
-      entries = readdirSync17(home);
+      entries = readdirSync18(home);
     } catch {
       continue;
     }
@@ -92140,9 +92420,10 @@ function pruneStrayHomes(options = {}) {
   }
   const appDir = options.homeDir ? join52(options.homeDir, ".hasna", "skills") : getDataDir();
   const roots = candidates.map((candidate2) => codexCorpusRootForPath(candidate2.path)).filter((root2) => !!root2);
-  return withCodexCorpusWrite(roots, (assertCurrent) => {
+  return withCodexCorpusWrite(roots, (assertCurrent, admission) => {
     assertCurrent();
-    const rollbackFile = writeRollbackRecord("prune", candidates.map(({ agent, skill, path, hash: hash6, marker }) => ({ agent, skill, path, hash: hash6, marker })), appDir);
+    const fallback = codexAdmissionReceipt(admission);
+    const rollbackFile = writeRollbackRecord("prune", candidates.map(({ agent, skill, path, hash: hash6, marker }) => ({ agent, skill, path, hash: hash6, marker })), appDir, fallback);
     let pruned = 0;
     for (const candidate2 of candidates) {
       assertCurrent();
@@ -92156,13 +92437,13 @@ function pruneStrayHomes(options = {}) {
       const skillMd = join52(candidate2.path, "SKILL.md");
       if ((existsSync25(skillMd) ? hashSkillMarkdownFile(skillMd) : "") !== candidate2.hash)
         continue;
-      rmSync7(candidate2.path, { recursive: true, force: true });
+      rmSync8(candidate2.path, { recursive: true, force: true });
       assertCurrent();
       if (existsSync25(candidate2.path))
         throw new Error("Skill prune readback failed");
       pruned++;
     }
-    return { candidates, pruned, dryRun: false, rollbackFile };
+    return { candidates, pruned, dryRun: false, rollbackFile, ...fallback };
   }, options);
 }
 var CONFLICTS_LEDGER_FILE = "conflicts.json", ROLLBACK_DIRNAME = "rollback";
@@ -92176,7 +92457,7 @@ var init_home_adoption = __esm(() => {
 });
 
 // src/lib/home-census.ts
-import { existsSync as existsSync26, readFileSync as readFileSync34, readdirSync as readdirSync18, statSync as statSync17 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync34, readdirSync as readdirSync19, statSync as statSync17 } from "fs";
 import { homedir as homedir9 } from "os";
 import { join as join53 } from "path";
 function sortEntries(entries) {
@@ -92210,7 +92491,7 @@ function censusHomeDrift(options = {}) {
     const present2 = new Set;
     let dirEntries = [];
     try {
-      dirEntries = readdirSync18(home);
+      dirEntries = readdirSync19(home);
     } catch {
       continue;
     }
@@ -92474,7 +92755,7 @@ var exports_diagnostic = {};
 __export(exports_diagnostic, {
   registerDiagnostic: () => registerDiagnostic
 });
-import { existsSync as existsSync27, readFileSync as readFileSync36, readdirSync as readdirSync19, statSync as statSync18 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync36, readdirSync as readdirSync20, statSync as statSync18 } from "fs";
 import { join as join54 } from "path";
 import { execSync as execSync2 } from "child_process";
 function registerDiagnostic(parent) {
@@ -92667,7 +92948,7 @@ function handleWhoami(options) {
     let skillCount = 0;
     if (exists)
       try {
-        skillCount = readdirSync19(agentSkillsPath).filter((f) => !f.startsWith(".") && statSync18(join54(agentSkillsPath, f)).isDirectory()).length;
+        skillCount = readdirSync20(agentSkillsPath).filter((f) => !f.startsWith(".") && statSync18(join54(agentSkillsPath, f)).isDirectory()).length;
       } catch {}
     agentConfigs.push({ agent, label: AGENT_LABELS[agent], path: agentSkillsPath, exists, skillCount });
   }
@@ -92925,7 +93206,7 @@ var init_cloud_executions = __esm(() => {
 
 // node_modules/@hasna/secrets/dist/sdk.js
 import { isIP as isIP3 } from "net";
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync5 } from "child_process";
 import { closeSync as closeSync23, fstatSync as fstatSync23, openSync as openSync23, readFileSync as readFileSync37 } 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";
@@ -93200,7 +93481,7 @@ function isAmbientEnvironment2(env3) {
   return env3 === process.env || env3[AMBIENT_ENVIRONMENT2] === true;
 }
 function defaultKeychainRunner2(argv) {
-  const result2 = spawnSync4(KEYCHAIN_SECURITY_BIN2, [...argv], {
+  const result2 = spawnSync5(KEYCHAIN_SECURITY_BIN2, [...argv], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: KEYCHAIN_SPAWN_TIMEOUT_MS2
@@ -94581,7 +94862,7 @@ __export(exports_selected_run, {
 });
 import { createHash as createHash36 } from "crypto";
 import { spawn as spawn3 } from "child_process";
-import { mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync4, writeFileSync as writeFileSync16, realpathSync as realpathSync16 } from "fs";
+import { mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync5, writeFileSync as writeFileSync16, realpathSync as realpathSync16 } from "fs";
 import { dirname as dirname33, join as join56, resolve as resolve33 } from "path";
 import { tmpdir, hostname as stationHostname2 } from "os";
 async function resolveSelectedRun(spec, profileId, options = {}) {
@@ -94705,7 +94986,7 @@ async function executeSelectedLocal(selected, options = {}) {
         throw new SkillSelectionError("INVALID_SECRET_BINDINGS", "Explicit environment values must be bounded strings without NUL bytes.");
       secretEnv[name] = value;
     }
-  const runDirectory = mkdtempSync4(join56(tmpdir(), "skills-execution-"));
+  const runDirectory = mkdtempSync5(join56(tmpdir(), "skills-execution-"));
   const paths = new SkillEntryPaths;
   for (const entry of entries) {
     paths.add(entry.path, 100, () => {
@@ -94714,7 +94995,7 @@ async function executeSelectedLocal(selected, options = {}) {
       throw new SkillSelectionError("INVALID_BUNDLE_PATH", "The execution bundle path exceeds its limit.");
     });
     const destination = join56(runDirectory, entry.path);
-    mkdirSync17(dirname33(destination), { recursive: true, mode: 448 });
+    mkdirSync18(dirname33(destination), { recursive: true, mode: 448 });
     writeFileSync16(destination, entry.bytes, { flag: "wx", mode: entry.mode & 511 });
   }
   env3.SKILLS_INPUT_JSON = input2;
@@ -98967,7 +99248,7 @@ var init_runs = __esm(() => {
 
 // src/lib/run-state.ts
 import { createHash as createHash37, randomBytes } from "crypto";
-import { existsSync as existsSync28, mkdirSync as mkdirSync18, readFileSync as readFileSync38, readdirSync as readdirSync20, statSync as statSync19, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync19, readFileSync as readFileSync38, readdirSync as readdirSync21, statSync as statSync19, writeFileSync as writeFileSync17 } from "fs";
 import { extname, join as join57, relative as relative11 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now3 = new Date;
@@ -98978,9 +99259,9 @@ function createSkillRun(params, targetDir = process.cwd()) {
   const runDir = join57(root2, "runs", day, id2);
   const logsDir = join57(runDir, "logs");
   const exportDir = join57(root2, "exports", skillName, id2);
-  mkdirSync18(logsDir, { recursive: true });
-  mkdirSync18(exportDir, { recursive: true });
-  mkdirSync18(join57(root2, "tmp"), { recursive: true });
+  mkdirSync19(logsDir, { recursive: true });
+  mkdirSync19(exportDir, { recursive: true });
+  mkdirSync19(join57(root2, "tmp"), { recursive: true });
   const record13 = {
     id: id2,
     skill: skillName,
@@ -99047,11 +99328,11 @@ function listSkillRuns(targetDir = process.cwd(), limit = 50) {
   if (!existsSync28(runsRoot))
     return [];
   const records = [];
-  for (const day of readdirSync20(runsRoot).sort().reverse()) {
+  for (const day of readdirSync21(runsRoot).sort().reverse()) {
     const dayDir = join57(runsRoot, day);
     if (!statSync19(dayDir).isDirectory())
       continue;
-    for (const runId2 of readdirSync20(dayDir).sort().reverse()) {
+    for (const runId2 of readdirSync21(dayDir).sort().reverse()) {
       const record13 = readRunRecord(join57(dayDir, runId2));
       if (record13)
         records.push(record13);
@@ -99065,7 +99346,7 @@ function findSkillRun(runId2, targetDir = process.cwd()) {
   const runsRoot = join57(getProjectStateDir(targetDir), "runs");
   if (!existsSync28(runsRoot))
     return null;
-  for (const day of readdirSync20(runsRoot)) {
+  for (const day of readdirSync21(runsRoot)) {
     const record13 = readRunRecord(join57(runsRoot, day, runId2));
     if (record13)
       return record13;
@@ -99121,7 +99402,7 @@ function readRunRecord(runDir) {
 }
 function walkFiles(dir) {
   const files = [];
-  for (const entry of readdirSync20(dir)) {
+  for (const entry of readdirSync21(dir)) {
     const full = join57(dir, entry);
     if (statSync19(full).isDirectory())
       files.push(...walkFiles(full));
@@ -111139,7 +111420,7 @@ var init_remote_customer_operations = __esm(() => {
 });
 
 // src/lib/workspace-profile.ts
-import { constants as constants25, closeSync as closeSync26, fstatSync as fstatSync26, lstatSync as lstatSync36, mkdirSync as mkdirSync19, mkdtempSync as mkdtempSync5, openSync as openSync26, readFileSync as readFileSync39, renameSync as renameSync11, rmSync as rmSync8, writeFileSync as writeFileSync18 } from "fs";
+import { constants as constants25, closeSync as closeSync26, fstatSync as fstatSync26, lstatSync as lstatSync36, mkdirSync as mkdirSync20, mkdtempSync as mkdtempSync6, openSync as openSync26, readFileSync as readFileSync39, renameSync as renameSync11, rmSync as rmSync9, writeFileSync as writeFileSync18 } from "fs";
 import { dirname as dirname34, join as join58 } from "path";
 function stat2(path) {
   try {
@@ -111290,8 +111571,8 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
           return fail4("The new profile exceeds the credential reader size limit.");
         const identity6 = JSON.stringify({ email: verified.user.email, userId: verified.user.id, orgId: verified.organization.id, orgSlug: verified.organization.slug, apiUrl: origin, issuedBy: "sign-in" }, null, 2) + `
 `;
-        mkdirSync19(dirname34(file2), { recursive: true, mode: 448 });
-        const temp = mkdtempSync5(join58(dirname34(file2), ".workspace-login-"));
+        mkdirSync20(dirname34(file2), { recursive: true, mode: 448 });
+        const temp = mkdtempSync6(join58(dirname34(file2), ".workspace-login-"));
         let identityInstalled = false;
         try {
           writeFileSync18(join58(temp, "credentials"), body, { mode: 384, flag: "wx" });
@@ -111310,7 +111591,7 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
         } catch (error61) {
           if (identityInstalled) {
             if (oldIdentity === null)
-              rmSync8(identityFile, { force: true });
+              rmSync9(identityFile, { force: true });
             else {
               writeFileSync18(join58(temp, "restore"), oldIdentity, { mode: 384, flag: "wx" });
               renameSync11(join58(temp, "restore"), identityFile);
@@ -111318,7 +111599,7 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
           }
           throw error61;
         } finally {
-          rmSync8(temp, { recursive: true, force: true });
+          rmSync9(temp, { recursive: true, force: true });
         }
         return {
           status: "authenticated",
@@ -111507,7 +111788,7 @@ var init_recurring_customer = __esm(() => {
 });
 
 // src/lib/recurring-recovery.ts
-import { constants as constants26, closeSync as closeSync27, fsyncSync as fsyncSync8, fstatSync as fstatSync27, lstatSync as lstatSync37, mkdirSync as mkdirSync20, openSync as openSync27, readSync as readSync19, realpathSync as realpathSync17, renameSync as renameSync12, unlinkSync as unlinkSync8, writeFileSync as writeFileSync19 } from "fs";
+import { constants as constants26, closeSync as closeSync27, fsyncSync as fsyncSync8, fstatSync as fstatSync27, lstatSync as lstatSync37, mkdirSync as mkdirSync21, openSync as openSync27, readSync as readSync19, realpathSync as realpathSync17, renameSync as renameSync12, unlinkSync as unlinkSync8, writeFileSync as writeFileSync19 } from "fs";
 import { dirname as dirname35, isAbsolute as isAbsolute33, join as join59, resolve as resolve34 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
 
@@ -111653,7 +111934,7 @@ function base2(customer, organizationId) {
 function create3(directory2, intent) {
   if (!isAbsolute33(directory2) || resolve34(directory2) !== directory2 || realpathSync17(dirname35(directory2)) !== dirname35(directory2))
     invalid6();
-  mkdirSync20(directory2, { mode: 448 });
+  mkdirSync21(directory2, { mode: 448 });
   const owner2 = new RecoveryOwner(directory2), checked = intentSchema.parse(intent), intentSha256 = canonicalJsonSha256(checked);
   owner2.write(`intent-${intentSha256}.json`, checked);
   owner2.write("state.json", { contractVersion: 1, intentSha256, phase: "prepared", consentId: null });
@@ -113291,7 +113572,7 @@ var init_run_routing = __esm(() => {
 });
 
 // src/mcp/operation-tools.ts
-import { existsSync as existsSync29, readdirSync as readdirSync21, statSync as statSync20 } from "fs";
+import { existsSync as existsSync29, readdirSync as readdirSync22, statSync as statSync20 } from "fs";
 import { join as join60 } from "path";
 function registerOperationTools(server) {
   server.registerTool("cloud_skill_eligibility", {
@@ -113773,7 +114054,7 @@ function registerOperationTools(server) {
       let skillCount = 0;
       if (exists) {
         try {
-          skillCount = readdirSync21(agentSkillsPath).filter((f) => {
+          skillCount = readdirSync22(agentSkillsPath).filter((f) => {
             const full = join60(agentSkillsPath, f);
             return !f.startsWith(".") && statSync20(full).isDirectory();
           }).length;
@@ -113841,7 +114122,7 @@ var init_operation_tools = __esm(() => {
 });
 
 // src/lib/feedback.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync30, mkdirSync as mkdirSync21 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync30, mkdirSync as mkdirSync22 } from "fs";
 import { dirname as dirname36, join as join61 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
@@ -113851,7 +114132,7 @@ function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
   const dir = dirname36(dbPath);
   if (!existsSync30(dir))
-    mkdirSync21(dir, { recursive: true });
+    mkdirSync22(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec([
@@ -113880,7 +114161,7 @@ function saveFeedback(input2) {
     const path = join61(getDataDir(), "feedback.jsonl");
     const dir = dirname36(path);
     if (!existsSync30(dir))
-      mkdirSync21(dir, { recursive: true });
+      mkdirSync22(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() }) + `
 `);
     return { saved: true, category, path };
@@ -114041,7 +114322,7 @@ var init_resource_meta_tools = __esm(() => {
 });
 
 // src/lib/scheduler.ts
-import { existsSync as existsSync31, readFileSync as readFileSync40, writeFileSync as writeFileSync20, mkdirSync as mkdirSync22 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync40, writeFileSync as writeFileSync20, mkdirSync as mkdirSync23 } from "fs";
 import { join as join62 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
   return join62(targetDir, ".skills", "schedules.json");
@@ -114059,7 +114340,7 @@ function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
   const dir = join62(targetDir, ".skills");
   if (!existsSync31(dir))
-    mkdirSync22(dir, { recursive: true });
+    mkdirSync23(dir, { recursive: true });
   writeFileSync20(path, JSON.stringify(data, null, 2));
 }
 function validateCronField(expr, min2, max2, label) {
@@ -114359,9 +114640,9 @@ var init_schedule_tools = __esm(() => {
 import { createHash as createHash38, createHmac as createHmac3 } from "crypto";
 import {
   existsSync as existsSync32,
-  mkdirSync as mkdirSync23,
+  mkdirSync as mkdirSync24,
   readFileSync as readFileSync41,
-  readdirSync as readdirSync22,
+  readdirSync as readdirSync23,
   statSync as statSync21,
   writeFileSync as writeFileSync21
 } from "fs";
@@ -114486,7 +114767,7 @@ function parsePositiveInteger(value) {
 }
 function walkFiles2(dir) {
   const files = [];
-  for (const entry of readdirSync22(dir)) {
+  for (const entry of readdirSync23(dir)) {
     const full = join63(dir, entry);
     const stats = statSync21(full);
     if (stats.isDirectory())
@@ -114725,7 +115006,7 @@ var init_private_publication_customer = __esm(() => {
 });
 
 // src/lib/private-publication-recovery.ts
-import { constants as constants27, closeSync as closeSync28, fsyncSync as fsyncSync9, fstatSync as fstatSync28, lstatSync as lstatSync38, mkdirSync as mkdirSync24, openSync as openSync28, readSync as readSync20, realpathSync as realpathSync18, renameSync as renameSync13, unlinkSync as unlinkSync9, writeFileSync as writeFileSync22 } from "fs";
+import { constants as constants27, closeSync as closeSync28, fsyncSync as fsyncSync9, fstatSync as fstatSync28, lstatSync as lstatSync38, mkdirSync as mkdirSync25, openSync as openSync28, readSync as readSync20, realpathSync as realpathSync18, renameSync as renameSync13, unlinkSync as unlinkSync9, writeFileSync as writeFileSync22 } from "fs";
 import { dirname as dirname38, isAbsolute as isAbsolute35, join as join64, resolve as resolve35 } from "path";
 import { randomUUID as randomUUID9 } from "crypto";
 function safeDirectory(directory3) {
@@ -114869,7 +115150,7 @@ async function preparePrivatePublication(client2, sourceDirectory, recoveryDirec
   };
   if (!isAbsolute35(recoveryDirectory) || resolve35(recoveryDirectory) !== recoveryDirectory || realpathSync18(dirname38(recoveryDirectory)) !== dirname38(recoveryDirectory))
     return fail5();
-  mkdirSync24(recoveryDirectory, { mode: 448 });
+  mkdirSync25(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
   const parent = openSync28(dirname38(recoveryDirectory), constants27.O_RDONLY | constants27.O_NOFOLLOW);
   try {
@@ -115432,7 +115713,7 @@ var exports_runtime_mcp = {};
 __export(exports_runtime_mcp, {
   handleMcp: () => handleMcp
 });
-import { existsSync as existsSync33, mkdirSync as mkdirSync25, readFileSync as readFileSync42, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync26, readFileSync as readFileSync42, writeFileSync as writeFileSync23 } from "fs";
 import { homedir as homedir10 } from "os";
 import { dirname as dirname39, join as join65 } from "path";
 async function handleMcp(options) {
@@ -115608,7 +115889,7 @@ function writeJsonObject(path, data) {
 `);
 }
 function writeTextFile(path, content) {
-  mkdirSync25(dirname39(path), { recursive: true });
+  mkdirSync26(dirname39(path), { recursive: true });
   writeFileSync23(path, content.endsWith(`
 `) ? content : `${content}
 `);
@@ -115803,7 +116084,7 @@ async function validateReviewedRuntimeLock(bytes, sha2563, context2) {
       throw new Error("REVIEWED_LOCK_LOCATION_INVALID");
     if (location === `node_modules/${PACKAGE2}`)
       continue;
-    if (typeof entry.version !== "string" || !VERSION.test(entry.version) || typeof entry.resolved !== "string" || typeof entry.integrity !== "string" || !INTEGRITY.test(entry.integrity))
+    if (typeof entry.version !== "string" || !VERSION2.test(entry.version) || typeof entry.resolved !== "string" || typeof entry.integrity !== "string" || !INTEGRITY.test(entry.integrity))
       throw new Error("REVIEWED_LOCK_PACKAGE_INVALID");
     let url2;
     try {
@@ -115835,10 +116116,10 @@ async function validateReviewedRuntimeLock(bytes, sha2563, context2) {
     }));
   }
 }
-var PACKAGE2 = "@hasna/skills", NAME2, VERSION, INTEGRITY, MAX_LOCK_BYTES, MAX_METADATA_BYTES;
+var PACKAGE2 = "@hasna/skills", NAME2, VERSION2, INTEGRITY, MAX_LOCK_BYTES, MAX_METADATA_BYTES;
 var init_reviewed_runtime_lock = __esm(() => {
   NAME2 = /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/;
-  VERSION = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?(?:\+[a-zA-Z0-9.-]+)?$/;
+  VERSION2 = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?(?:\+[a-zA-Z0-9.-]+)?$/;
   INTEGRITY = /^sha512-[A-Za-z0-9+/]{86}==$/;
   MAX_LOCK_BYTES = 8 * 1024 * 1024;
   MAX_METADATA_BYTES = 32 * 1024 * 1024;
@@ -115848,15 +116129,15 @@ var init_reviewed_runtime_lock = __esm(() => {
 import { createHash as createHash40, randomUUID as randomUUID10 } from "crypto";
 import { Readable } from "stream";
 import { createGunzip as createGunzip2 } from "zlib";
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync6 } from "child_process";
 import {
   chmodSync as chmodSync4,
   copyFileSync,
   existsSync as existsSync34,
   lstatSync as lstatSync39,
-  mkdirSync as mkdirSync26,
+  mkdirSync as mkdirSync27,
   readFileSync as readFileSync43,
-  readdirSync as readdirSync23,
+  readdirSync as readdirSync24,
   readlinkSync as readlinkSync8,
   realpathSync as realpathSync19,
   renameSync as renameSync14,
@@ -115927,7 +116208,7 @@ function verifyTargetPrerequisites(manifest, packageRoot, home, cwd2, pathValue)
   for (const key2 of ["SUMI_CONFIG", "SUMI_CONFIG_CONTENT"])
     if (process.env[key2] !== undefined)
       env3[key2] = "";
-  const child2 = spawnSync5(pinnedLauncherRuntime(), [...PINNED_LAUNCHER_BUN_FLAGS2, entry, home, cwd2], {
+  const child2 = spawnSync6(pinnedLauncherRuntime(), [...PINNED_LAUNCHER_BUN_FLAGS2, entry, home, cwd2], {
     cwd: dirname40(packageRoot),
     env: env3,
     encoding: "buffer",
@@ -116001,7 +116282,7 @@ function assertNoSymlinkAncestors(path) {
 function acquireRuntimeLock(runtimeRoot) {
   const lockPath = join66(runtimeRoot, ".copyfile-update-lock");
   try {
-    mkdirSync26(lockPath, { mode: 448 });
+    mkdirSync27(lockPath, { mode: 448 });
   } catch {
     throw new Error("RUNTIME_UPDATE_LOCKED");
   }
@@ -116270,7 +116551,7 @@ async function downloadPackage(version2, stagingRoot, registryOrigin, fetcher) {
     throw new Error("TARBALL_PACKAGE_IDENTITY_MISMATCH");
   const bins = packageBins(unpacked);
   const archiveRoot = join66(stagingRoot, "verified-archive");
-  mkdirSync26(archiveRoot, { mode: 448 });
+  mkdirSync27(archiveRoot, { mode: 448 });
   await archive.extract(archiveRoot);
   const extractedPackage = join66(archiveRoot, "package");
   const extracted = readTree(extractedPackage, false);
@@ -116321,7 +116602,7 @@ function readTree(root2, includeModes, excludeNpmDependencies = false) {
   const base3 = realpathSync19(root2);
   const entries = [];
   const walk2 = (dir, prefix = "") => {
-    for (const item of readdirSync23(dir).sort()) {
+    for (const item of readdirSync24(dir).sort()) {
       const path = join66(dir, item);
       const rel = prefix ? `${prefix}/${item}` : item;
       const stat3 = lstatSync39(path);
@@ -116365,7 +116646,7 @@ function normalizeModes(root2) {
     throw new Error("RUNTIME_ENTRY_TYPE_UNSUPPORTED");
   chmodSync4(root2, rootStat.mode & 493);
   const walk2 = (dir) => {
-    for (const item of readdirSync23(dir)) {
+    for (const item of readdirSync24(dir)) {
       const path = join66(dir, item);
       const stat3 = lstatSync39(path);
       if (stat3.isSymbolicLink())
@@ -116426,7 +116707,7 @@ function verifyPreimageManifest(runtimePath, receipt, home) {
 }
 function captureConfigPreimages(home, stage) {
   const root2 = join66(stage, "preimage", "configs");
-  mkdirSync26(root2, { recursive: true, mode: 448 });
+  mkdirSync27(root2, { recursive: true, mode: 448 });
   return CONFIG_PREIMAGE_PATHS.map((relativePath) => {
     const sourcePath = join66(home, relativePath);
     if (!entryExists(sourcePath))
@@ -116436,7 +116717,7 @@ function captureConfigPreimages(home, stage) {
       throw new Error("CONFIG_PREIMAGE_NOT_REGULAR_FILE");
     const bytes = readFileSync43(sourcePath);
     const backupPath = join66(root2, relativePath);
-    mkdirSync26(dirname40(backupPath), { recursive: true, mode: 448 });
+    mkdirSync27(dirname40(backupPath), { recursive: true, mode: 448 });
     writeFileSync24(backupPath, bytes, { flag: "wx", mode: 384 });
     chmodSync4(backupPath, 384);
     const readback = readFileSync43(backupPath);
@@ -116589,7 +116870,7 @@ function persistReceipt(path, value) {
       return;
     const historyRoot = join66(dirname40(path), "receipt-history");
     if (!entryExists(historyRoot))
-      mkdirSync26(historyRoot, { mode: 448 });
+      mkdirSync27(historyRoot, { mode: 448 });
     const historyStat = lstatSync39(historyRoot);
     if (!historyStat.isDirectory() || historyStat.isSymbolicLink() || (historyStat.mode & 63) !== 0)
       throw new Error("RECEIPT_HISTORY_NOT_PRIVATE");
@@ -116613,7 +116894,7 @@ function persistAliasReceipt(path, value) {
       return;
     const history = join66(dirname40(path), "history");
     if (!entryExists(history))
-      mkdirSync26(history, { mode: 448 });
+      mkdirSync27(history, { mode: 448 });
     const historyStat = lstatSync39(history);
     if (!historyStat.isDirectory() || historyStat.isSymbolicLink() || (historyStat.mode & 63) !== 0)
       throw new Error("ALIAS_RECEIPT_HISTORY_UNSAFE");
@@ -116770,7 +117051,7 @@ function adoptCopyfileAliases(options = {}) {
     }
     if (!aliases.length)
       return { adopted: true, version: layout.currentVersion, aliasCount: 0 };
-    mkdirSync26(receiptDir, { recursive: true, mode: 448 });
+    mkdirSync27(receiptDir, { recursive: true, mode: 448 });
     const receiptDirStat = lstatSync39(receiptDir);
     if (!receiptDirStat.isDirectory() || receiptDirStat.isSymbolicLink() || receiptDirStat.mode & 63)
       throw new Error("ALIAS_RECEIPT_DIRECTORY_UNSAFE");
@@ -116996,7 +117277,7 @@ async function updateCopyfileRuntime(version2, options = {}) {
   try {
     if (entryExists(finalPath))
       throw new Error("TARGET_RUNTIME_ALREADY_EXISTS");
-    mkdirSync26(stagePath, { mode: 448 });
+    mkdirSync27(stagePath, { mode: 448 });
     chmodSync4(stagePath, 448);
     const configPreimages = captureConfigPreimages(home, stagePath);
     const fetcher = options.fetcher ?? fetch;
@@ -117005,7 +117286,7 @@ async function updateCopyfileRuntime(version2, options = {}) {
       throw new Error("PACKAGE_BIN_SET_CHANGED");
     }
     const stagePackage = join66(stagePath, "install");
-    mkdirSync26(stagePackage, { mode: 448 });
+    mkdirSync27(stagePackage, { mode: 448 });
     copyFileSync(artifact.tarballPath, join66(stagePackage, "verified.tgz"));
     writeFileSync24(join66(stagePackage, "package.json"), JSON.stringify({ name: "skills-runtime-install", version: "0.0.0", private: true, dependencies: { [PACKAGE_NAME]: "file:./verified.tgz" } }, null, 2), { mode: 384, flag: "wx" });
     let npmVersion;
@@ -117175,7 +117456,7 @@ function rollbackCopyfileRuntime(receiptId, options = {}) {
     throw new Error("RUNTIME_ROOT_NOT_PRIVATE");
   const releaseLock = acquireRuntimeLock(runtimeRoot);
   try {
-    const matches2 = readdirSync23(runtimeRoot).filter((name) => {
+    const matches2 = readdirSync24(runtimeRoot).filter((name) => {
       if (!/^\d+\.\d+\.\d+-copyfile$/.test(name))
         return false;
       const receipt2 = join66(runtimeRoot, name, "rollout-receipt.json");
@@ -117279,7 +117560,7 @@ __export(exports_runtime, {
   registerRuntime: () => registerRuntime
 });
 import { createHash as createHash41, randomUUID as randomUUID11 } from "crypto";
-import { lstatSync as lstatSync40, mkdirSync as mkdirSync27, readFileSync as readFileSync44, writeFileSync as writeFileSync25 } from "fs";
+import { lstatSync as lstatSync40, mkdirSync as mkdirSync28, readFileSync as readFileSync44, writeFileSync as writeFileSync25 } from "fs";
 import { basename as basename22, isAbsolute as isAbsolute38, join as join67 } from "path";
 import { createInterface } from "readline";
 function registerRuntime(parent) {
@@ -118196,7 +118477,7 @@ async function handleExportsDownload(runId2, options) {
     const canonicalSkill = typeof remoteRun.skill === "string" ? remoteRun.skill : "remote";
     const requestedSkill = typeof remoteRun.requestedSlug === "string" && remoteRun.requestedSlug.trim() ? remoteRun.requestedSlug : canonicalSkill;
     const exportDir = getRunExportDir(runId2, requestedSkill);
-    mkdirSync27(exportDir, { recursive: true });
+    mkdirSync28(exportDir, { recursive: true });
     const downloaded = [];
     for (const artifact of artifacts) {
       const artifactId = String(artifact.id || "");
@@ -118250,7 +118531,7 @@ function ensureSafeExportParent(root2, relativePath) {
     } catch (error61) {
       if (error61.code !== "ENOENT")
         throw error61;
-      mkdirSync27(parent, { mode: 448 });
+      mkdirSync28(parent, { mode: 448 });
     }
   }
 }
@@ -118840,7 +119121,7 @@ var init_completion = __esm(() => {
 });
 
 // src/lib/portable-snapshot-filter.ts
-import { readdirSync as readdirSync24, statSync as statSync22 } from "fs";
+import { readdirSync as readdirSync25, statSync as statSync22 } from "fs";
 import { homedir as homedir11 } from "os";
 import { join as join68, sep as sep19 } from "path";
 function isExcludedSkillFileName(fileName) {
@@ -118879,7 +119160,7 @@ function destinationFor(definition, stationId, relativePath) {
 function walkEntries(absoluteRoot) {
   let entries;
   try {
-    entries = readdirSync24(absoluteRoot, { withFileTypes: true });
+    entries = readdirSync25(absoluteRoot, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -118992,7 +119273,7 @@ var init_portable_snapshot_filter = __esm(() => {
 import { createHash as createHash42 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
-  mkdirSync as mkdirSync28,
+  mkdirSync as mkdirSync29,
   readFileSync as readFileSync45,
   statSync as statSync23,
   writeFileSync as writeFileSync26
@@ -119125,7 +119406,7 @@ function writeStationSnapshot(options) {
   let written = 0;
   for (const plan of untouched) {
     const destination = resolve37(repoRoot, plan.destination);
-    mkdirSync28(dirname42(destination), { recursive: true });
+    mkdirSync29(dirname42(destination), { recursive: true });
     copyFileSync2(plan.source.fullPath, destination);
     written += 1;
   }
@@ -119144,7 +119425,7 @@ function writeStationSnapshot(options) {
     files: manifestFiles
   };
   const manifestPath = resolve37(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
-  mkdirSync28(dirname42(manifestPath), { recursive: true });
+  mkdirSync29(dirname42(manifestPath), { recursive: true });
   writeFileSync26(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return {
@@ -119826,7 +120107,7 @@ var init_codex_hook_policy_recovery = __esm(() => {
 });
 
 // src/lib/agent-codex-trust.ts
-import { lstatSync as lstatSync44, mkdirSync as mkdirSync29, readdirSync as readdirSync25, readFileSync as readFileSync46, realpathSync as realpathSync21, statSync as statSync24 } from "fs";
+import { lstatSync as lstatSync44, mkdirSync as mkdirSync30, readdirSync as readdirSync26, readFileSync as readFileSync46, realpathSync as realpathSync21, statSync as statSync24 } from "fs";
 import { createHash as createHash43, randomUUID as randomUUID12 } from "crypto";
 import { execFileSync as execFileSync2 } from "child_process";
 import { dirname as dirname45, isAbsolute as isAbsolute41, join as join72, resolve as resolve40 } from "path";
@@ -120012,7 +120293,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     if (recovery?.reviewedPlanDigest !== undefined)
       need8(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, 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 } : {} };
+    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 } : {}, ...codexAdmissionReceipt(rpc.admission) };
     if (preview2)
       return receipt;
     save(join72(journal, "receipt.json"), json2(receipt));
@@ -120026,9 +120307,9 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
 }
 async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRpc) {
   const home = resolve40(options.home ?? homedir13());
-  return withCodexCorpusWriteAsync([join72(home, ".codex")], () => enrollCodexNativeHooksUnlocked(options, connect), options);
+  return withCodexCorpusWriteAsync([join72(home, ".codex")], (_assertCurrent, admission) => enrollCodexNativeHooksUnlocked(options, connect, admission), options);
 }
-async function enrollCodexNativeHooksUnlocked(options, connect) {
+async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
   let rpc, journal;
   try {
     const home = resolve40(options.home ?? homedir13()), dataDir3 = resolve40(options.dataDir ?? getDataDirReadOnly());
@@ -120089,14 +120370,14 @@ async function enrollCodexNativeHooksUnlocked(options, connect) {
     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, bindingRefreshRequired: false, 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, ...codexAdmissionReceipt(admission) };
     if (options.apply)
       need8(options.reviewedPlanDigest === planDigest, "PLAN_CHANGED: run the dry-run again and pass its reviewed --plan-digest with --apply");
     const parent = join72(dataDir3, "native-hook-trust");
     const st = lstatSync44(parent, { throwIfNoEntry: false });
     if (st) {
       need8(st.isDirectory() && !st.isSymbolicLink() && st.uid === process.getuid() && (st.mode & 511) === 448, "UNSAFE_JOURNAL");
-      const priorJournals = readdirSync25(parent);
+      const priorJournals = readdirSync26(parent);
       need8(priorJournals.length < 1000, "JOURNAL_BOUND");
       for (const name of priorJournals) {
         need8(/^[a-f0-9-]{36}$/.test(name), "UNSAFE_JOURNAL");
@@ -120106,13 +120387,13 @@ async function enrollCodexNativeHooksUnlocked(options, connect) {
     if (!options.apply || !planned.length)
       return baseReceipt;
     if (!st)
-      mkdirSync29(parent, { mode: 448 });
+      mkdirSync30(parent, { mode: 448 });
     journal = join72(parent, randomUUID12());
-    mkdirSync29(journal, { mode: 448 });
+    mkdirSync30(journal, { mode: 448 });
     save(join72(journal, "config.before.toml"), configFile.bytes);
     save(join72(journal, "hooks.before.json"), hooksFile.bytes);
     save(join72(journal, "policy.before.json"), policyFile.bytes);
-    save(join72(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook) }));
+    save(join72(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook), ...codexAdmissionReceipt(admission) }));
     need8(isDeepStrictEqual19(admit(await list2()), admitted), "NATIVE_DISCOVERY_CHANGED");
     checkInputs();
     let result2;
@@ -120150,7 +120431,7 @@ async function enrollCodexNativeHooksUnlocked(options, connect) {
     const message = error61 instanceof Error && error61.message.startsWith("CODEX_HOOK_TRUST_") ? error61.message : "CODEX_HOOK_TRUST_REFUSED: verify managed bridge installation and native Codex support";
     if (journal) {
       try {
-        save(join72(journal, "stopped.json"), json2({ error: message.split(":")[0], automaticRollback: false, reconcileBeforeRetry: true }));
+        save(join72(journal, "stopped.json"), json2({ error: message.split(":")[0], automaticRollback: false, reconcileBeforeRetry: true, ...codexAdmissionReceipt(admission) }));
       } catch {}
     }
     throw new Error(message);
@@ -120269,7 +120550,7 @@ var init_codex_native_trust = __esm(() => {
 
 // src/lib/claude-prospective-review.ts
 import { createHash as createHash45 } from "crypto";
-import { lstatSync as lstatSync45, readFileSync as readFileSync48, readdirSync as readdirSync26, realpathSync as realpathSync22 } from "fs";
+import { lstatSync as lstatSync45, readFileSync as readFileSync48, readdirSync as readdirSync27, realpathSync as realpathSync22 } from "fs";
 import { basename as basename23, dirname as dirname46, isAbsolute as isAbsolute42, join as join74, relative as relative15, resolve as resolve42, sep as sep21 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual20 } from "util";
 function hashClaudeDiscoveryBinding(binding) {
@@ -120359,7 +120640,7 @@ function captureClaudeProspectiveCandidateClosure(root2) {
   let bytes = 0;
   const walk2 = (directory3) => {
     const beforeDirectory = lstatSync45(directory3);
-    const names = readdirSync26(directory3).sort();
+    const names = readdirSync27(directory3).sort();
     if (new Set(names).size !== names.length)
       refuse8("candidate contains ambiguous directory entries");
     for (const name of names) {
@@ -120514,7 +120795,7 @@ function assertNoUnprojectedSkillPayload(root2, catalogPath, marketplace, plugin
   if (entries[0].skills !== undefined || entries[0].commands !== undefined)
     refuse8("candidate marketplace entry declares native skill or command payloads");
   const walk2 = (directory3) => {
-    for (const name of readdirSync26(directory3).sort()) {
+    for (const name of readdirSync27(directory3).sort()) {
       const path = join74(directory3, name), rel = relative15(root2, path).split(sep21).join("/");
       const stat3 = lstatSync45(path);
       if (stat3.isDirectory())
@@ -121468,11 +121749,16 @@ function registerAgentIntegration(parent) {
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_ABSOLUTE_PATH_REQUIRED");
       if (existsSync36(options.output))
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_OUTPUT_EXISTS");
+      let admission;
       const catalog = await captureCodexNativeSkillCatalog({
         command: options.codexCommand,
         home: homedir14(),
         ...process.env.CODEX_HOME === undefined ? {} : { codexHome: process.env.CODEX_HOME },
         cwd: options.cwd
+      }, async (connection) => {
+        const rpc = await connectCodexHookRpc(connection);
+        admission = rpc.admission;
+        return rpc;
       });
       const bytes = JSON.stringify(catalog, null, 2) + `
 `;
@@ -121492,7 +121778,8 @@ function registerAgentIntegration(parent) {
         skillCount: catalog.skills.length,
         output: options.output,
         bytes: Buffer.byteLength(bytes),
-        sha256: createHash47("sha256").update(bytes).digest("hex")
+        sha256: createHash47("sha256").update(bytes).digest("hex"),
+        ...codexAdmissionReceipt(admission)
       };
       await writeCliOutput(options.json ? JSON.stringify(receipt) : `Captured ${receipt.skillCount} native Codex skill(s) in ${receipt.output}.`);
     } catch (error61) {
@@ -121836,6 +122123,8 @@ var init_agent_integration2 = __esm(() => {
   init_claude_marketplace_entry_witness();
   init_claude_prospective_review();
   init_codex_native_skill_catalog();
+  init_codex_hook_rpc();
+  init_codex_corpus_write();
   init_self_spawn();
   init_config();
   init_claude_installer_capture();
@@ -122478,8 +122767,8 @@ var init_grants = __esm(() => {
 import { createHash as createHash48 } from "crypto";
 import {
   copyFileSync as copyFileSync3,
-  mkdirSync as mkdirSync30,
-  readdirSync as readdirSync27,
+  mkdirSync as mkdirSync31,
+  readdirSync as readdirSync28,
   readFileSync as readFileSync50,
   statSync as statSync25,
   writeFileSync as writeFileSync30
@@ -122523,7 +122812,7 @@ function planStationHydration(stationId, repoRoot) {
     const agentRoot = join76(snapshotRoot, "agent-homes", agent);
     let identEntries;
     try {
-      identEntries = readdirSync27(agentRoot, { withFileTypes: true });
+      identEntries = readdirSync28(agentRoot, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -122737,7 +123026,7 @@ function writeStationHydration(options) {
   }
   let written = 0;
   for (const entry of toWrite) {
-    mkdirSync30(dirname48(entry.destination), { recursive: true });
+    mkdirSync31(dirname48(entry.destination), { recursive: true });
     copyFileSync3(entry.fullPath, entry.destination);
     written += 1;
   }
@@ -122759,7 +123048,7 @@ function writeStationHydration(options) {
     skills: resultSkills
   };
   const hydrationManifestPath = join76(dirname48(cacheRoot), `hydration-${options.stationId}.json`);
-  mkdirSync30(dirname48(hydrationManifestPath), { recursive: true });
+  mkdirSync31(dirname48(hydrationManifestPath), { recursive: true });
   writeFileSync30(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
 `);
   return {
@@ -122836,7 +123125,7 @@ var init_hydrate = __esm(() => {
 
 // src/lib/prepare-skill.ts
 import { createHash as createHash49, randomUUID as randomUUID13 } from "crypto";
-import { chmodSync as chmodSync5, existsSync as existsSync37, lstatSync as lstatSync48, mkdirSync as mkdirSync31, mkdtempSync as mkdtempSync6, readFileSync as readFileSync51, readdirSync as readdirSync28, renameSync as renameSync15, rmSync as rmSync9, writeFileSync as writeFileSync31 } from "fs";
+import { chmodSync as chmodSync5, existsSync as existsSync37, lstatSync as lstatSync48, mkdirSync as mkdirSync32, mkdtempSync as mkdtempSync7, readFileSync as readFileSync51, readdirSync as readdirSync29, renameSync as renameSync15, rmSync as rmSync10, writeFileSync as writeFileSync31 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { dirname as dirname49, isAbsolute as isAbsolute46, join as join77, relative as relative16, resolve as resolve46, sep as sep24 } from "path";
 function prepareSkill(name, options) {
@@ -122878,13 +123167,13 @@ function prepareSkill(name, options) {
     throw new Error("skill.json provenance must be an object.");
   const provenance = manifest.provenance;
   const candidate2 = { ...manifest, version: options.version, kind, provenance: { ...provenance } };
-  const staging = mkdtempSync6(join77(tmpdir2(), "skills-prepare-"));
+  const staging = mkdtempSync7(join77(tmpdir2(), "skills-prepare-"));
   try {
     for (const directory3 of before2.directories)
-      mkdirSync31(join77(staging, directory3), { recursive: true });
+      mkdirSync32(join77(staging, directory3), { recursive: true });
     for (const file2 of before2.files) {
       const destination = join77(staging, file2.path);
-      mkdirSync31(dirname49(destination), { recursive: true });
+      mkdirSync32(dirname49(destination), { recursive: true });
       writeFileSync31(destination, file2.bytes, { mode: file2.mode });
     }
     const stagedManifest = join77(staging, "skill.json");
@@ -122916,12 +123205,12 @@ ${validation.issues.map((issue2) => `${issue2.code}: ${issue2.message}`).join(`
         chmodSync5(temporary, manifestFile.mode);
         renameSync15(temporary, join77(path, "skill.json"));
       } finally {
-        rmSync9(temporary, { force: true });
+        rmSync10(temporary, { force: true });
       }
     }
     return { name: normalized2, path, previousVersion, version: options.version, kind, contentHash, changed: changed3, written: changed3 && !options.dryRun, warnings: validation.warnings };
   } finally {
-    rmSync9(staging, { recursive: true, force: true });
+    rmSync10(staging, { recursive: true, force: true });
   }
 }
 function assertPackedCanonicalCoverage(root2) {
@@ -123037,7 +123326,7 @@ function snapshot2(root2) {
   const hash7 = createHash49("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
   let count = 0, bytes = 0;
   const walk2 = (relative17) => {
-    for (const name of readdirSync28(join77(root2, relative17)).sort()) {
+    for (const name of readdirSync29(join77(root2, relative17)).sort()) {
       if (IGNORED.has(name.toLowerCase()) || !relative17 && ROOT_IGNORED.has(name.toLowerCase()))
         continue;
       const path = relative17 ? `${relative17}/${name}` : name;
@@ -123458,7 +123747,7 @@ var init_schedule = __esm(() => {
 });
 
 // src/lib/registry-sync.ts
-import { mkdirSync as mkdirSync32, writeFileSync as writeFileSync32 } from "fs";
+import { mkdirSync as mkdirSync33, writeFileSync as writeFileSync32 } from "fs";
 import { dirname as dirname50, relative as relative17 } from "path";
 function createRegistrySyncArtifact(options = {}) {
   const profile = options.profile ?? "all";
@@ -123516,7 +123805,7 @@ function createRegistrySyncArtifact(options = {}) {
   };
 }
 function writeRegistrySyncArtifact(path, artifact) {
-  mkdirSync32(dirname50(path), { recursive: true });
+  mkdirSync33(dirname50(path), { recursive: true });
   writeFileSync32(path, `${JSON.stringify(artifact, null, 2)}
 `);
 }