@hasna/hooks 0.10.8 → 0.11.0

package/dist/index.js

@@ -4762,12 +4762,12 @@ __export(exports_store, {
   checkScriptHash: () => checkScriptHash,
   LockFileError: () => LockFileError
 });
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2, renameSync } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2, renameSync } from "fs";
 import { readFile } from "fs/promises";
 import { randomBytes } from "crypto";
 function sha256Of(input) {
-  return createHash2("sha256").update(input).digest("hex");
+  return createHash3("sha256").update(input).digest("hex");
 }
 async function sha256File(path) {
   const buf = await readFile(path);
@@ -4828,11 +4828,11 @@ function assertLockShape(parsed, path) {
 }
 function readLock() {
   const path = getLockPath();
-  if (!existsSync7(path))
+  if (!existsSync8(path))
     return { hooks: {} };
   let raw;
   try {
-    raw = readFileSync4(path, "utf-8");
+    raw = readFileSync5(path, "utf-8");
   } catch {
     throw new LockFileError(`hooks.lock (${path}) could not be read. Repair: fix permissions or move the file aside and run 'hooks sync'.`);
   }
@@ -4898,15 +4898,15 @@ function removeHookFromStore(name) {
 function checkScriptHash(name, actual) {
   const db = storeDb();
   const record = db ? getHookRecord(db, name) : null;
-  const pin = getPinnedHook(name);
-  const expected = record?.sha256 ?? pin?.sha256 ?? null;
+  const pin2 = getPinnedHook(name);
+  const expected = record?.sha256 ?? pin2?.sha256 ?? null;
   if (expected !== null && expected !== actual) {
     return { ok: false, pinned: true, expected, actual, name };
   }
   if (expected === null) {
     const now2 = new Date().toISOString();
-    const version = pin?.version ?? record?.version ?? "0.0.0";
-    const source = pin?.source ?? record?.source_type ?? "local";
+    const version = pin2?.version ?? record?.version ?? "0.0.0";
+    const source = pin2?.source ?? record?.source_type ?? "local";
     if (db) {
       upsertHookRecord(db, {
         name,
@@ -4923,9 +4923,9 @@ function checkScriptHash(name, actual) {
   if (db) {
     upsertHookRecord(db, {
       name,
-      version: record?.version ?? pin?.version ?? "0.0.0",
+      version: record?.version ?? pin2?.version ?? "0.0.0",
       sha256: expected,
-      source_type: record?.source_type ?? pin?.source ?? "local",
+      source_type: record?.source_type ?? pin2?.source ?? "local",
       last_verified_at: now
     });
   }
@@ -4935,7 +4935,7 @@ async function verifyScriptHash(name, scriptPath) {
   return checkScriptHash(name, await sha256File(scriptPath));
 }
 function retrustHook(name, scriptPath, version, source) {
-  const actual = sha256Of(readFileSync4(scriptPath));
+  const actual = sha256Of(readFileSync5(scriptPath));
   const db = storeDb();
   if (db) {
     upsertHookRecord(db, {
@@ -4974,12 +4974,12 @@ __export(exports_profiles, {
   deleteProfile: () => deleteProfile,
   createProfile: () => createProfile
 });
-import { existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync8, readdirSync as readdirSync8, rmSync, cpSync as cpSync2 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync8, readdirSync as readdirSync8, rmSync, cpSync as cpSync2 } from "fs";
+import { join as join11 } from "path";
 function getProfilesDir() {
-  const newDir = join12(getEffectiveDataRoot(), "profiles");
-  const oldDir = join12(getHomeDir(), ".hooks", "profiles");
-  if (!existsSync11(newDir) && existsSync11(oldDir)) {
+  const newDir = join11(getEffectiveDataRoot(), "profiles");
+  const oldDir = join11(getHomeDir(), ".hooks", "profiles");
+  if (!existsSync12(newDir) && existsSync12(oldDir)) {
     mkdirSync9(newDir, { recursive: true });
     cpSync2(oldDir, newDir, { recursive: true });
   }
@@ -4987,12 +4987,12 @@ function getProfilesDir() {
 }
 function ensureProfilesDir() {
   const dir = getProfilesDir();
-  if (!existsSync11(dir)) {
+  if (!existsSync12(dir)) {
     mkdirSync9(dir, { recursive: true });
   }
 }
 function profilePath(id) {
-  return join12(getProfilesDir(), `${id}.json`);
+  return join11(getProfilesDir(), `${id}.json`);
 }
 function shortUuid() {
   return crypto.randomUUID().slice(0, 8);
@@ -5018,23 +5018,23 @@ function createProfile(input2) {
 function getProfile(id) {
   const path = profilePath(id);
   try {
-    if (!existsSync11(path))
+    if (!existsSync12(path))
       return null;
-    return JSON.parse(readFileSync9(path, "utf-8"));
+    return JSON.parse(readFileSync8(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function listProfiles() {
   const dir = getProfilesDir();
-  if (!existsSync11(dir))
+  if (!existsSync12(dir))
     return [];
   try {
     const files = readdirSync8(dir).filter((f) => f.endsWith(".json"));
     const profiles = [];
     for (const file2 of files) {
       try {
-        const content = readFileSync9(join12(dir, file2), "utf-8");
+        const content = readFileSync8(join11(dir, file2), "utf-8");
         profiles.push(JSON.parse(content));
       } catch {}
     }
@@ -5057,7 +5057,7 @@ function updateProfile(id, data) {
 }
 function deleteProfile(id) {
   const path = profilePath(id);
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return false;
   try {
     rmSync(path);
@@ -5087,7 +5087,7 @@ function importProfiles(profiles) {
       continue;
     }
     const path = profilePath(profile.agent_id);
-    if (existsSync11(path)) {
+    if (existsSync12(path)) {
       skipped++;
       continue;
     }
@@ -5110,9 +5110,9 @@ import { hostname as osHostname } from "os";
 import { isAbsolute as isAbsolute7, join as join22 } from "path";
 import { createRequire as createRequire2 } from "module";
 import { fileURLToPath as fileURLToPath22 } from "url";
-import { closeSync as closeSync4, fstatSync as fstatSync3, lstatSync as lstatSync7, openSync as openSync4, readFileSync as readFileSync12, realpathSync as realpathSync7, statSync } from "fs";
+import { closeSync as closeSync5, fstatSync as fstatSync4, lstatSync as lstatSync7, openSync as openSync5, readFileSync as readFileSync9, realpathSync as realpathSync7, statSync } from "fs";
 import { O_NOFOLLOW, O_NONBLOCK, O_RDONLY } from "constants";
-import { basename as basename5, dirname as dirname11, join as join13, relative, sep as sep3 } from "path";
+import { basename as basename5, dirname as dirname11, join as join12, relative, sep as sep3 } from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 function envToken2(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -5187,15 +5187,15 @@ function o(e2, r2, t2) {
 }
 function entryPoint(directory2) {
   const root = realpathSync7(directory2);
-  const fd = openSync4(join13(root, "package.json"), O_RDONLY | O_NOFOLLOW | O_NONBLOCK);
+  const fd = openSync5(join12(root, "package.json"), O_RDONLY | O_NOFOLLOW | O_NONBLOCK);
   let pkg;
   try {
-    const stat2 = fstatSync3(fd);
+    const stat2 = fstatSync4(fd);
     if (!stat2.isFile() || stat2.size > MAX_PACKAGE_BYTES2)
       throw new Error("Invalid Secrets package metadata");
-    pkg = JSON.parse(readFileSync12(fd, "utf8"));
+    pkg = JSON.parse(readFileSync9(fd, "utf8"));
   } finally {
-    closeSync4(fd);
+    closeSync5(fd);
   }
   if (!pkg || typeof pkg !== "object" || !("name" in pkg) || pkg.name !== PACKAGE) {
     throw new Error("Invalid Secrets package identity");
@@ -5207,7 +5207,7 @@ function entryPoint(directory2) {
   if (/[\\%?#\0]/.test(target) || parts.some((part) => !part || part === "." || part === ".." || part === "node_modules")) {
     throw new Error("Invalid Secrets import export");
   }
-  const file2 = realpathSync7(join13(root, ...parts));
+  const file2 = realpathSync7(join12(root, ...parts));
   const within = relative(root, file2);
   if (!within || within === ".." || within.startsWith(`..${sep3}`) || !statSync(file2).isFile()) {
     throw new Error("Secrets import export escapes its package or is not a file");
@@ -5218,7 +5218,7 @@ function resolveInstalledSecrets(parentUrl) {
   let directory2 = dirname11(fileURLToPath3(parentUrl));
   for (;; ) {
     if (basename5(directory2) !== "node_modules") {
-      const candidate = join13(directory2, "node_modules", PACKAGE);
+      const candidate = join12(directory2, "node_modules", PACKAGE);
       let absent = false;
       try {
         lstatSync7(candidate);
@@ -5288,9 +5288,9 @@ function parseEnvFile(text3) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
       continue;
     let value = withoutExport.slice(equals + 1).trim();
-    const quote3 = value[0];
-    if (quote3 === '"' || quote3 === "'") {
-      if (value.length < 2 || !value.endsWith(quote3)) {
+    const quote4 = value[0];
+    if (quote4 === '"' || quote4 === "'") {
+      if (value.length < 2 || !value.endsWith(quote4)) {
         unusable.add(key);
         continue;
       }
@@ -5740,9 +5740,9 @@ async function completePointerCredential(name, pointerResolution, env = process.
   }
   let client;
   try {
-    const bootstrap = resolveCredential("secrets", secretsEnv);
-    if (!bootstrap || bootstrap.tier === "pointer") {
-      throw new CredentialResolutionError("secrets", "The Secrets vault requires an independent, non-reference bootstrap credential.", bootstrap ? [bootstrap.source] : []);
+    const bootstrap2 = resolveCredential("secrets", secretsEnv);
+    if (!bootstrap2 || bootstrap2.tier === "pointer") {
+      throw new CredentialResolutionError("secrets", "The Secrets vault requires an independent, non-reference bootstrap credential.", bootstrap2 ? [bootstrap2.source] : []);
     }
     client = secretsSdk.createSecretsClientFromEnv(secretsEnv);
   } catch {
@@ -6203,11 +6203,11 @@ var init_db_writer = __esm(() => {
 
 // src/lib/hook-env.ts
 import { dirname as dirname24, isAbsolute as isAbsolute21 } from "path";
-import { existsSync as existsSync14, realpathSync as realpathSync13, statSync as statSync2 } from "fs";
+import { existsSync as existsSync15, realpathSync as realpathSync13, statSync as statSync2 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 function isDeniedEnvName(name) {
   const upper = name.toUpperCase();
-  if (DENY_PREFIXES.some((prefix2) => upper.startsWith(prefix2)))
+  if (DENY_PREFIXES.some((prefix3) => upper.startsWith(prefix3)))
     return true;
   if (DENY_SUFFIXES.some((suffix) => upper.endsWith(suffix)))
     return true;
@@ -6216,7 +6216,7 @@ function isDeniedEnvName(name) {
 function isInterpreterInjectionEnvName(name) {
   if (INTERPRETER_INJECTION.has(name))
     return true;
-  return INTERPRETER_INJECTION_PREFIXES.some((prefix2) => name.startsWith(prefix2));
+  return INTERPRETER_INJECTION_PREFIXES.some((prefix3) => name.startsWith(prefix3));
 }
 function isBashFunctionEnvName(name) {
   return name.startsWith("BASH_FUNC_");
@@ -6251,7 +6251,7 @@ function isUnsafePathEntry(entry, home) {
 }
 function sanitizeHookPath(pathValue, home) {
   const baseline = PATH_BASELINE.slice();
-  if (process.platform === "darwin" && existsSync14("/opt/homebrew/bin"))
+  if (process.platform === "darwin" && existsSync15("/opt/homebrew/bin"))
     baseline.push("/opt/homebrew/bin");
   const bunDir = dirname24(process.execPath);
   const seen = new Set;
@@ -6378,7 +6378,7 @@ __export(exports_run, {
 });
 import { randomBytes as randomBytes2 } from "crypto";
 import { rmSync as rmSync4, writeFileSync as writeFileSync13 } from "fs";
-import { basename as basename11, dirname as dirname25, isAbsolute as isAbsolute23, join as join30 } from "path";
+import { basename as basename11, dirname as dirname25, isAbsolute as isAbsolute23, join as join29 } from "path";
 function extensionOf(scriptPath) {
   const base = basename11(scriptPath);
   const dot = base.lastIndexOf(".");
@@ -6449,7 +6449,7 @@ async function readPipeWithDeadline(stream, deadlineMs) {
 async function executeVerifiedScript(options) {
   const scriptDir = dirname25(options.scriptPath);
   const interpreter = interpreterFor(options.name, options.scriptPath, options.content);
-  const tempPath = join30(scriptDir, `.hooks-verified-${randomBytes2(12).toString("hex")}.${interpreter.tempExt}`);
+  const tempPath = join29(scriptDir, `.hooks-verified-${randomBytes2(12).toString("hex")}.${interpreter.tempExt}`);
   let proc = null;
   let timedOut = false;
   const timeoutTimer = options.timeout ? setTimeout(() => {
@@ -7542,9 +7542,9 @@ function getHook(name) {
   return HOOKS.find((h) => h.name === name);
 }
 // src/lib/installer.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync7, readdirSync as readdirSync4, realpathSync as realpathSync5, rmdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync7, readdirSync as readdirSync4, realpathSync as realpathSync5, rmdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "fs";
 import { join as join10, dirname as dirname7, basename as basename3, resolve as resolve7 } from "path";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/lib/resolve.ts
@@ -7769,6 +7769,169 @@ function installedNativeSafetyCommand(name) {
   return buildNativeSafetyCommand({ name, runtime, runtimeSHA256: pinEligibleFile(runtime, 200000000, true), worker: canonicalWorker, workerSHA256: pinEligibleFile(canonicalWorker, 256000), home, path: `${dirname3(runtime)}:${join7(home, ".bun/bin")}:/usr/local/bin:/usr/bin:/bin` });
 }
 
+// src/lib/native-readiness-command.ts
+import { createHash as createHash2 } from "crypto";
+import { constants as constants2, closeSync as closeSync2, existsSync as existsSync7, fstatSync as fstatSync2, lstatSync as lstatSync2, openSync as openSync2, readFileSync as readFileSync4, realpathSync as realpathSync3 } from "fs";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join8 } from "path";
+import { homedir as homedir4 } from "os";
+
+// src/lib/readiness-process.ts
+var supervisor = String.raw`
+  const {spawn}=require("node:child_process");
+  const spec=JSON.parse(process.argv.at(-1));
+  // This runtime was created detached and is its group's live leader. Its
+  // independent timer and parent pipe remain effective if the observer exits
+  // or its event loop stops responding. Only this freshly created tree is hit.
+  const cleanup=()=>{try{process.kill(-process.pid,"SIGKILL")}catch{process.exit(1)}};
+  setTimeout(cleanup,spec.timeout);
+  process.stdin.once("end",cleanup);
+  process.stdin.once("error",cleanup);
+  process.stdin.on("data",cleanup);
+  process.stdin.resume();
+  for(const signal of ["SIGTERM","SIGINT","SIGHUP"])process.once(signal,cleanup);
+  let done=false, out=Buffer.alloc(0), err=Buffer.alloc(0);
+  function report(status,error){
+    if(done)return; done=true;
+    process.stdout.write(JSON.stringify({status,error,stdout:out.toString("utf8"),stderr:err.toString("utf8")})+"\n");
+  }
+  const child=spawn(spec.command,spec.args,{stdio:["ignore","pipe","pipe"],env:process.env});
+  for(const [stream,name] of [[child.stdout,"stdout"],[child.stderr,"stderr"]]){
+    stream.on("data",bytes=>{
+      if(done)return;
+      const before=name==="stdout"?out:err;
+      if(before.length+bytes.length>spec.maxBuffer){report(null,{code:"ENOBUFS"});return}
+      if(name==="stdout")out=Buffer.concat([out,bytes]);else err=Buffer.concat([err,bytes]);
+    });
+    stream.on("error",()=>report(null,{code:"ECHILD"}));
+  }
+  child.on("error",()=>report(null,{code:"ECHILD"}));
+  // A successful observation includes complete streams. A nested client that
+  // keeps them open after its parent exits is a failure requiring group cleanup.
+  child.on("exit",()=>setTimeout(()=>report(null,{code:"ECHILD"}),100));
+  child.on("close",(status,signal)=>report(status,signal?{code:"ECHILD"}:undefined));
+`;
+
+// src/native-readiness.ts
+function isReadinessProvider(value) {
+  return value === "claude" || value === "codex" || value === "sumi";
+}
+var safeFailureCodes = new Set([
+  "unsupported_platform",
+  "station_detection_failed",
+  "station_mismatch",
+  "hosted_unavailable",
+  "authentication_refused",
+  "station_setup_required",
+  "invalid_status",
+  "deadline_exceeded",
+  "retention_mismatch",
+  "managed_instructions_refused",
+  "removal_instruction_missing",
+  "instructions_changed",
+  "native_config_changed",
+  "guard_refused",
+  "owner_refused"
+]);
+
+// src/lib/native-readiness-command.ts
+var quote2 = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+var bootstrap = String.raw`/* hasna-native-readiness-v1 */ (() => {
+  const fs = require("node:fs"), path = require("node:path"), crypto = require("node:crypto");
+  const failed = () => process.stdout.write(JSON.stringify({hookSpecificOutput:{hookEventName:"SessionStart",additionalContext:"Trash readiness needs attention (runner integrity). Preserve files; do not fall back to direct deletion."}})+"\n");
+  try {
+    const b = JSON.parse(Buffer.from(process.argv[1],"base64url").toString("utf8"));
+    if (!["claude","codex","sumi"].includes(b.provider) || process.argv[2] !== b.provider || process.env.HOME !== b.home) throw Error();
+    const check = (file, expected, maximum, executable) => {
+      if (!path.isAbsolute(file) || fs.realpathSync(file) !== file) throw Error();
+      for (let p = path.dirname(file);; p = path.dirname(p)) {
+        const s = fs.lstatSync(p);
+        if (!s.isDirectory() || ![0,process.getuid()].includes(s.uid) || s.mode & 0o022) throw Error();
+        if (p === path.dirname(p)) break;
+      }
+      const fd = fs.openSync(file,fs.constants.O_RDONLY|fs.constants.O_NOFOLLOW|fs.constants.O_NONBLOCK);
+      try {
+        const s = fs.fstatSync(fd);
+        if (!s.isFile() || ![0,process.getuid()].includes(s.uid) || s.mode & 0o022 || s.size > maximum || executable && !(s.mode & 0o100)) throw Error();
+        const bytes = Buffer.alloc(s.size+1); let length=0;
+        while (length<bytes.length) { const n=fs.readSync(fd,bytes,length,bytes.length-length,null); if(!n)break; length+=n; }
+        const after=fs.fstatSync(fd);
+        if(length!==s.size || after.size!==s.size || after.mtimeMs!==s.mtimeMs || after.ctimeMs!==s.ctimeMs)throw Error();
+        const content=bytes.subarray(0,length);
+        if(crypto.createHash("sha256").update(content).digest("hex")!==expected)throw Error();
+        return content;
+      } finally { fs.closeSync(fd); }
+    };
+    check(b.runtime,b.runtimeSHA256,200000000,true);
+    const bytes=check(b.worker,b.workerSHA256,256000,false);
+    new Function("require","process",bytes.toString("utf8"))(require,process);
+  } catch { failed(); }
+})();`;
+var prefix2 = "/usr/bin/env -i ";
+function valid(b) {
+  if (!b || Object.keys(b).sort().join() !== "home,provider,runtime,runtimeSHA256,worker,workerSHA256" || !isReadinessProvider(b.provider) || ![b.home, b.runtime, b.worker].every((p) => typeof p === "string" && isAbsolute3(p) && !/[\0\r\n]/.test(p)) || ![b.runtimeSHA256, b.workerSHA256].every((h) => typeof h === "string" && /^[a-f0-9]{64}$/.test(h)))
+    throw new Error("Invalid readiness command binding");
+}
+function buildNativeReadinessCommand(binding) {
+  valid(binding);
+  const encoded = Buffer.from(JSON.stringify(binding)).toString("base64url");
+  return prefix2 + ["HOME=" + binding.home, "PATH=/usr/bin:/bin", binding.runtime, "--config=/dev/null", "--no-env-file", "--no-macros", "--no-install", "--eval", bootstrap, encoded, binding.provider].map(quote2).join(" ");
+}
+function nativeReadinessCommandBinding(command) {
+  if (!command.startsWith(prefix2) || !command.includes(quote2(bootstrap)))
+    return;
+  const tail = command.slice(command.indexOf(quote2(bootstrap)) + quote2(bootstrap).length);
+  const match = /^ '([A-Za-z0-9_-]{1,16384})' '(claude|codex|sumi)'$/.exec(tail);
+  if (!match)
+    return;
+  try {
+    const b = JSON.parse(Buffer.from(match[1], "base64url").toString("utf8"));
+    return buildNativeReadinessCommand(b) === command ? b : undefined;
+  } catch {
+    return;
+  }
+}
+function pin(path, maximum, executable) {
+  if (realpathSync3(path) !== path)
+    throw new Error("Readiness runner requires canonical files");
+  for (let p = dirname4(path);; p = dirname4(p)) {
+    const s = lstatSync2(p);
+    if (!s.isDirectory() || ![0, process.getuid?.()].includes(s.uid) || s.mode & 18)
+      throw new Error("Readiness runner requires safe ancestry");
+    if (p === dirname4(p))
+      break;
+  }
+  const fd = openSync2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  try {
+    const s = fstatSync2(fd);
+    if (!s.isFile() || ![0, process.getuid?.()].includes(s.uid) || s.mode & 18 || s.size > maximum || executable && !(s.mode & 64))
+      throw new Error("Readiness runner requires safe regular files");
+    const bytes = readFileSync4(fd);
+    if (bytes.length > maximum)
+      throw new Error("Readiness runner is too large");
+    return createHash2("sha256").update(bytes).digest("hex");
+  } finally {
+    closeSync2(fd);
+  }
+}
+function nativeReadinessCommandVerified(command) {
+  const b = nativeReadinessCommandBinding(command);
+  if (!b)
+    return false;
+  try {
+    return pin(b.runtime, 200000000, true) === b.runtimeSHA256 && pin(b.worker, 256000, false) === b.workerSHA256;
+  } catch {
+    return false;
+  }
+}
+function installedNativeReadinessCommand(provider) {
+  const candidates = [join8(import.meta.dir, "../../bin/native-readiness-entry.js"), join8(import.meta.dir, "../bin/native-readiness-entry.js"), join8(import.meta.dir, "native-readiness-entry.js")];
+  const selected = candidates.find(existsSync7);
+  if (!selected)
+    throw new Error("Build or install the native readiness runner first");
+  const runtime = realpathSync3(process.execPath), worker = realpathSync3(selected);
+  return buildNativeReadinessCommand({ provider, home: realpathSync3(homedir4()), runtime, runtimeSHA256: pin(runtime, 200000000, true), worker, workerSHA256: pin(worker, 256000, false) });
+}
+
 // src/lib/mementos-options.ts
 function validateMementosRegistration(name, value) {
   if (value === undefined)
@@ -7833,6 +7996,8 @@ function registrationName(command) {
   const native = nativeSafetyRegistration(command);
   if (native)
     return native;
+  if (nativeReadinessCommandBinding(command))
+    return "trash-readiness";
   if (/^hooks run mementos-context(?:\s|$)/.test(command.trim())) {
     try {
       retainedMementosRegistration([command.trim()]);
@@ -7852,16 +8017,16 @@ function matchersOverlap(a, b) {
 init_store();
 
 // src/lib/codex-settings.ts
-import { closeSync as closeSync2, existsSync as existsSync8, lstatSync as lstatSync2, mkdirSync as mkdirSync4, openSync as openSync2, readFileSync as readFileSync5, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4 } from "path";
-import { createHash as createHash3, randomUUID } from "crypto";
+import { closeSync as closeSync3, existsSync as existsSync9, lstatSync as lstatSync3, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync6, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname5 } from "path";
+import { createHash as createHash4, randomUUID } from "crypto";
 var snapshots = new WeakMap;
 function current(path) {
   try {
-    const stat = lstatSync2(path);
+    const stat = lstatSync3(path);
     if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1048576)
       throw new Error("invalid_file");
-    return readFileSync5(path, "utf8");
+    return readFileSync6(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
@@ -7898,7 +8063,7 @@ function capturedCodexSettings(settings) {
 function assertSettingsPreimage(raw, expected) {
   if (expected === undefined)
     return;
-  if (!/^(?:absent|[a-f0-9]{64})$/.test(expected) || (raw === null ? "absent" : createHash3("sha256").update(raw).digest("hex")) !== expected) {
+  if (!/^(?:absent|[a-f0-9]{64})$/.test(expected) || (raw === null ? "absent" : createHash4("sha256").update(raw).digest("hex")) !== expected) {
     throw new Error("Hook settings changed since planning; no settings were written.");
   }
 }
@@ -7912,11 +8077,11 @@ function writeCodexSettings(path, settings, expectedSha256) {
 ` });
 }
 function writeHookSettingsPreimage(path, settings, before) {
-  mkdirSync4(dirname4(path), { recursive: true, mode: 448 });
+  mkdirSync4(dirname5(path), { recursive: true, mode: 448 });
   const lock = `${path}.hooks-write.lock`;
   let fd;
   try {
-    fd = openSync2(lock, "wx", 384);
+    fd = openSync3(lock, "wx", 384);
   } catch {
     throw new Error("Codex settings are being edited; retry after the active writer finishes.");
   }
@@ -7931,23 +8096,23 @@ function writeHookSettingsPreimage(path, settings, before) {
       throw new Error("Hook settings changed since reading; re-read before retrying.");
     renameSync2(temp, path);
   } finally {
-    if (existsSync8(temp))
+    if (existsSync9(temp))
       unlinkSync(temp);
-    closeSync2(fd);
+    closeSync3(fd);
     unlinkSync(lock);
   }
 }
 
 // src/lib/claude-skills-coordination.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 
 // ../../node_modules/.bun/@hasna+skills@0.9.17+a00d3064559565bb/node_modules/@hasna/skills/dist/index.js
-import { existsSync as existsSync9 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join8, resolve as resolve3 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join9, resolve as resolve3 } from "path";
 import { homedir as pathsResolverHomedir2 } from "os";
 import { join as pathsResolverJoin2 } from "path";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { existsSync as existsSync52, readdirSync as readdirSync3, readFileSync as readFileSync42, statSync as statSync3 } from "fs";
 import { join as join52, sep as sep2 } from "path";
 import { basename as basename2, isAbsolute as isAbsolute22, resolve as resolve22 } from "path";
@@ -7955,23 +8120,23 @@ import { createHash as createHash16 } from "crypto";
 import { lstatSync as lstatSync20, readFileSync as readFileSync16, readdirSync as readdirSync9, realpathSync as realpathSync4 } from "fs";
 import { basename as basename8, dirname as dirname16, isAbsolute as isAbsolute14, join as join26, resolve as resolve14, sep as sep5 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
-import { dirname as dirname32, isAbsolute as isAbsolute3, join as join72, resolve as resolve32 } from "path";
-import { lstatSync as lstatSync3, readFileSync as readFileSync6, opendirSync } from "fs";
+import { dirname as dirname32, isAbsolute as isAbsolute32, join as join72, resolve as resolve32 } from "path";
+import { lstatSync as lstatSync32, readFileSync as readFileSync62, opendirSync } from "fs";
 import { createHash as createHash22 } from "crypto";
 import { lstatSync as lstatSync4, opendirSync as opendirSync2 } from "fs";
 import { dirname as dirname42, isAbsolute as isAbsolute4, join as join82, resolve as resolve4 } from "path";
 import { createHash as createHash32 } from "crypto";
-import { closeSync as closeSync3, constants as constants2, fstatSync as fstatSync2, lstatSync as lstatSync5, openSync as openSync3, readSync } from "fs";
-import { dirname as dirname5, isAbsolute as isAbsolute5, resolve as resolve5 } from "path";
+import { closeSync as closeSync4, constants as constants3, fstatSync as fstatSync3, lstatSync as lstatSync5, openSync as openSync4, readSync } from "fs";
+import { dirname as dirname52, isAbsolute as isAbsolute5, resolve as resolve5 } from "path";
 import { createHash as createHash42 } from "crypto";
 import { lstatSync as lstatSync6, readlinkSync } from "fs";
-import { dirname as dirname6, isAbsolute as isAbsolute6, join as join9, parse, resolve as resolve6, sep as sep22 } from "path";
+import { dirname as dirname6, isAbsolute as isAbsolute6, join as join92, parse, resolve as resolve6, sep as sep22 } from "path";
 import { closeSync as closeSync12, constants as constants9, fstatSync as fstatSync12, lstatSync as lstatSync17, openSync as openSync12, opendirSync as opendirSync5, readSync as readSync8 } from "fs";
 import { basename as basename6, dirname as dirname13, isAbsolute as isAbsolute12, join as join25, resolve as resolve12 } from "path";
 import { isAbsolute as isAbsolute11, join as join23, resolve as resolve11 } from "path";
 import { createRequire } from "module";
 import { createHash as createHash10, randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync82, lstatSync as lstatSync14, statSync as statSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync11, readdirSync as readdirSync7, opendirSync as opendirSync3, readlinkSync as readlinkSync2, realpathSync as realpathSync3, renameSync as renameSync22, rmdirSync as rmdirSync2, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, chmodSync, openSync as openSync10, closeSync as closeSync10, fsyncSync as fsyncSync2, fstatSync as fstatSync10, readSync as readSync6, constants as constants7, linkSync } from "fs";
+import { existsSync as existsSync82, lstatSync as lstatSync14, statSync as statSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync11, readdirSync as readdirSync7, opendirSync as opendirSync3, readlinkSync as readlinkSync2, realpathSync as realpathSync32, renameSync as renameSync22, rmdirSync as rmdirSync2, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, chmodSync, openSync as openSync10, closeSync as closeSync10, fsyncSync as fsyncSync2, fstatSync as fstatSync10, readSync as readSync6, constants as constants7, linkSync } from "fs";
 import { dirname as dirname10, join as join16, resolve as resolve9, relative as relative4, isAbsolute as isAbsolute9, sep as sep4 } from "path";
 import { homedir as homedir22 } from "os";
 import { closeSync as closeSync8, constants as constants5, fstatSync as fstatSync8, lstatSync as lstatSync11, openSync as openSync8, readSync as readSync4 } from "fs";
@@ -8272,8 +8437,8 @@ var require_directives = __commonJS((exports) => {
             if (parts.length < 2)
               return false;
           }
-          const [handle, prefix2] = parts;
-          this.tags[handle] = prefix2;
+          const [handle, prefix3] = parts;
+          this.tags[handle] = prefix3;
           return true;
         }
         case "%YAML": {
@@ -8317,10 +8482,10 @@ var require_directives = __commonJS((exports) => {
       const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);
       if (!suffix)
         onError(`The ${source} tag has no suffix`);
-      const prefix2 = this.tags[handle];
-      if (prefix2) {
+      const prefix3 = this.tags[handle];
+      if (prefix3) {
         try {
-          return prefix2 + decodeURIComponent(suffix);
+          return prefix3 + decodeURIComponent(suffix);
         } catch (error) {
           onError(String(error));
           return null;
@@ -8332,9 +8497,9 @@ var require_directives = __commonJS((exports) => {
       return null;
     }
     tagString(tag) {
-      for (const [handle, prefix2] of Object.entries(this.tags)) {
-        if (tag.startsWith(prefix2))
-          return handle + escapeTagName(tag.substring(prefix2.length));
+      for (const [handle, prefix3] of Object.entries(this.tags)) {
+        if (tag.startsWith(prefix3))
+          return handle + escapeTagName(tag.substring(prefix3.length));
       }
       return tag[0] === "!" ? tag : `!<${tag}>`;
     }
@@ -8351,11 +8516,11 @@ var require_directives = __commonJS((exports) => {
         tagNames = Object.keys(tags);
       } else
         tagNames = [];
-      for (const [handle, prefix2] of tagEntries) {
-        if (handle === "!!" && prefix2 === "tag:yaml.org,2002:")
+      for (const [handle, prefix3] of tagEntries) {
+        if (handle === "!!" && prefix3 === "tag:yaml.org,2002:")
           continue;
-        if (!doc || tagNames.some((tn) => tn.startsWith(prefix2)))
-          lines.push(`%TAG ${handle} ${prefix2}`);
+        if (!doc || tagNames.some((tn) => tn.startsWith(prefix3)))
+          lines.push(`%TAG ${handle} ${prefix3}`);
       }
       return lines.join(`
 `);
@@ -8386,14 +8551,14 @@ var require_anchors = __commonJS((exports) => {
     });
     return anchors;
   }
-  function findNewAnchor(prefix2, exclude) {
+  function findNewAnchor(prefix3, exclude) {
     for (let i = 1;; ++i) {
-      const name = `${prefix2}${i}`;
+      const name = `${prefix3}${i}`;
       if (!exclude.has(name))
         return name;
     }
   }
-  function createNodeAnchors(doc, prefix2) {
+  function createNodeAnchors(doc, prefix3) {
     const aliasObjects = [];
     const sourceObjects = new Map;
     let prevAnchors = null;
@@ -8401,7 +8566,7 @@ var require_anchors = __commonJS((exports) => {
       onAnchor: (source) => {
         aliasObjects.push(source);
         prevAnchors ?? (prevAnchors = anchorNames(doc));
-        const anchor = findNewAnchor(prefix2, prevAnchors);
+        const anchor = findNewAnchor(prefix3, prevAnchors);
         prevAnchors.add(anchor);
         return anchor;
       },
@@ -10226,10 +10391,10 @@ var require_int = __commonJS((exports) => {
   var stringifyNumber = require_stringifyNumber();
   var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
   var intResolve = (str, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix);
-  function intStringify(node, radix, prefix2) {
+  function intStringify(node, radix, prefix3) {
     const { value } = node;
     if (intIdentify(value) && value >= 0)
-      return prefix2 + value.toString(radix);
+      return prefix3 + value.toString(radix);
     return stringifyNumber.stringifyNumber(node);
   }
   var intOct = {
@@ -10640,11 +10805,11 @@ var require_int2 = __commonJS((exports) => {
     const n = parseInt(str, radix);
     return sign === "-" ? -1 * n : n;
   }
-  function intStringify(node, radix, prefix2) {
+  function intStringify(node, radix, prefix3) {
     const { value } = node;
     if (intIdentify(value)) {
       const str = value.toString(radix);
-      return value < 0 ? "-" + prefix2 + str.substr(1) : prefix2 + str;
+      return value < 0 ? "-" + prefix3 + str.substr(1) : prefix3 + str;
     }
     return stringifyNumber.stringifyNumber(node);
   }
@@ -13558,9 +13723,9 @@ var require_lexer = __commonJS((exports) => {
       }
     }
     *parseQuotedScalar() {
-      const quote2 = this.charAt(0);
-      let end = this.buffer.indexOf(quote2, this.pos + 1);
-      if (quote2 === "'") {
+      const quote3 = this.charAt(0);
+      let end = this.buffer.indexOf(quote3, this.pos + 1);
+      if (quote3 === "'") {
         while (end !== -1 && this.buffer[end + 1] === "'")
           end = this.buffer.indexOf("'", end + 2);
       } else {
@@ -14845,10 +15010,10 @@ var SKILLS_HOME_ENV = "SKILLS_HOME";
 var DEFAULT_SQLITE_FILENAME = "server.db";
 var GLOBAL_CONFIG_FILENAME = "config.json";
 function effectiveHome() {
-  return process.env["HOME"] || process.env["USERPROFILE"] || homedir4() || "/tmp";
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir5() || "/tmp";
 }
 function legacyDataRoot() {
-  return join8(effectiveHome(), ".hasna", "skills");
+  return join9(effectiveHome(), ".hasna", "skills");
 }
 function resolverDataRoot(home = effectiveHome(), env) {
   return dataDir2({ app: "skills", home, env });
@@ -14857,7 +15022,7 @@ function adoptResolverDataRoot2(resolved, env = process.env) {
   const dataOverride = env.HASNA_DATA_HOME;
   if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
     return true;
-  return existsSync9(join8(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync9(join8(resolved, GLOBAL_CONFIG_FILENAME));
+  return existsSync10(join9(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync10(join9(resolved, GLOBAL_CONFIG_FILENAME));
 }
 function exactDataRoot() {
   for (const key of [DATA_DIR_ENV, HASNA_SKILLS_HOME_ENV, SKILLS_HOME_ENV]) {
@@ -15091,7 +15256,7 @@ function* bundleHashParts(files) {
   yield new TextEncoder().encode("\x00");
 }
 function hashBundleFiles(files) {
-  const hash = createHash4(CONTENT_HASH_ALGORITHM);
+  const hash = createHash5(CONTENT_HASH_ALGORITHM);
   for (const part of bundleHashParts(files))
     hash.update(part);
   return hash.digest("hex");
@@ -15546,10 +15711,10 @@ function quoted(value) {
     throw new Error("Invalid Hermes Skills command");
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-function hermesHookDefinitions(supervisor) {
-  if (!isAbsolute3(supervisor.runtime) || !isAbsolute3(supervisor.path))
+function hermesHookDefinitions(supervisor2) {
+  if (!isAbsolute32(supervisor2.runtime) || !isAbsolute32(supervisor2.path))
     throw new Error("Expected absolute Hermes supervisor paths");
-  const entry = (event) => ({ command: `${quoted(supervisor.runtime)} ${quoted(supervisor.path)} --event ${event}`, timeout: 15, ...event === "pre_tool_call" ? { fail_closed: true } : {} });
+  const entry = (event) => ({ command: `${quoted(supervisor2.runtime)} ${quoted(supervisor2.path)} --event ${event}`, timeout: 15, ...event === "pre_tool_call" ? { fail_closed: true } : {} });
   return { pre_llm_call: entry("pre_llm_call"), pre_tool_call: entry("pre_tool_call") };
 }
 function assertHermesEnvironment(home) {
@@ -15560,30 +15725,30 @@ function assertHermesEnvironment(home) {
       throw new Error(`NATIVE_SKILL_DRIFT: Hermes ${variable} requires a dedicated discovery adapter; unset it before using this adapter`);
   }
   const selected = process.env.HERMES_HOME?.trim();
-  if (selected && (!isAbsolute3(selected) || resolve32(selected) !== join72(resolve32(home), ".hermes")))
+  if (selected && (!isAbsolute32(selected) || resolve32(selected) !== join72(resolve32(home), ".hermes")))
     throw new Error("NATIVE_SKILL_DRIFT: custom Hermes homes/profiles require their own reviewed bridge");
   if (process.env.HERMES_ENABLE_PROJECT_PLUGINS?.trim() && !["0", "false", "no", "off"].includes(process.env.HERMES_ENABLE_PROJECT_PLUGINS.trim().toLowerCase()))
     throw new Error("NATIVE_SKILL_DRIFT: Hermes project plugins require a dedicated discovery review");
 }
 function read(path) {
   for (let current2 = path;; current2 = dirname32(current2)) {
-    if (lstatSync3(current2, { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync32(current2, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error("NATIVE_SKILL_DRIFT: symlink Hermes protection input");
     if (dirname32(current2) === current2)
       break;
   }
-  const stat = lstatSync3(path, { throwIfNoEntry: false });
+  const stat = lstatSync32(path, { throwIfNoEntry: false });
   if (!stat)
     return null;
   if (!stat.isFile() || stat.size > 1024 * 1024)
     throw new Error("NATIVE_SKILL_DRIFT: invalid Hermes protection input");
-  return readFileSync6(path, "utf8");
+  return readFileSync62(path, "utf8");
 }
-function assertHermesProtection(home, config, command, profile, supervisor) {
+function assertHermesProtection(home, config, command, profile, supervisor2) {
   assertHermesEnvironment(home);
   if (read(join72(home, ".hermes", HERMES_OPT_OUT)) === null)
     throw new Error("NATIVE_SKILL_DRIFT: Hermes bundled skill reseeding is not disabled; run skills hook install");
-  if (!supervisor || !isAbsolute3(supervisor.path) || supervisor.runtime !== process.execPath || read(supervisor.path) !== renderHermesSupervisor(command, profile))
+  if (!supervisor2 || !isAbsolute32(supervisor2.path) || supervisor2.runtime !== process.execPath || read(supervisor2.path) !== renderHermesSupervisor(command, profile))
     throw new Error("NATIVE_SKILL_DRIFT: Hermes owned supervisor changed; run skills hook install");
   const raw = read(join72(home, ".hermes/shell-hooks-allowlist.json"));
   let trust;
@@ -15592,7 +15757,7 @@ function assertHermesProtection(home, config, command, profile, supervisor) {
   } catch {
     throw new Error("NATIVE_SKILL_DRIFT: invalid Hermes native hook trust");
   }
-  for (const [event, entry] of Object.entries(hermesHookDefinitions(supervisor))) {
+  for (const [event, entry] of Object.entries(hermesHookDefinitions(supervisor2))) {
     if (!Array.isArray(config.hooks?.[event]) || config.hooks[event].filter((actual) => sameEntry(actual, entry)).length !== 1)
       throw new Error("NATIVE_SKILL_DRIFT: Hermes required native hooks changed; run skills hook install");
     if (!Array.isArray(trust?.approvals) || !trust.approvals.some((approval) => object2(approval) && approval.event === event && approval.command === entry.command))
@@ -15610,7 +15775,7 @@ function assertHermesProtection(home, config, command, profile, supervisor) {
 function assertNoHermesLegacyShadow(root) {
   let entries = 0;
   for (let cursor = resolve32(root);; cursor = dirname32(cursor)) {
-    if (lstatSync3(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync32(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error("NATIVE_SKILL_DRIFT: symlink Hermes legacy discovery root");
     if (dirname32(cursor) === cursor)
       break;
@@ -15618,7 +15783,7 @@ function assertNoHermesLegacyShadow(root) {
   function scan(path, depth) {
     if (++entries > 1e4 || depth > 64)
       throw new Error("NATIVE_SKILL_DRIFT: Hermes legacy discovery limit exceeded; review the root before continuing");
-    const stat = lstatSync3(path, { throwIfNoEntry: false });
+    const stat = lstatSync32(path, { throwIfNoEntry: false });
     if (!stat)
       return;
     if (stat.isSymbolicLink())
@@ -15628,9 +15793,9 @@ function assertNoHermesLegacyShadow(root) {
         throw new Error("NATIVE_SKILL_DRIFT: unsupported Hermes legacy discovery input");
       return;
     }
-    if (lstatSync3(join72(path, "skills-cli.md"), { throwIfNoEntry: false }))
+    if (lstatSync32(join72(path, "skills-cli.md"), { throwIfNoEntry: false }))
       throw new Error("NATIVE_SKILL_DRIFT: legacy Hermes skills-cli.md can shadow the owned bridge; preserve and retire it before continuing");
-    const hasDescriptor = Boolean(lstatSync3(join72(path, "SKILL.md"), { throwIfNoEntry: false }));
+    const hasDescriptor = Boolean(lstatSync32(join72(path, "SKILL.md"), { throwIfNoEntry: false }));
     const directory = opendirSync(path);
     try {
       for (let child = directory.readSync();child; child = directory.readSync()) {
@@ -15763,10 +15928,10 @@ function discoveryByteBudget() {
 function safe2(path) {
   if (typeof path !== "string" || !isAbsolute5(path) || path !== resolve5(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00"))
     throw new Error("Expected a canonical absolute raw discovery path");
-  for (let cursor = path;; cursor = dirname5(cursor)) {
+  for (let cursor = path;; cursor = dirname52(cursor)) {
     if (lstatSync5(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error("Refusing symlink raw discovery input");
-    if (dirname5(cursor) === cursor)
+    if (dirname52(cursor) === cursor)
       break;
   }
 }
@@ -15794,9 +15959,9 @@ function hashRawDiscoveryFile(path, budget, changes) {
     throw new Error("Unsupported or oversized raw discovery input");
   if (initial.size > budget.remaining)
     throw new Error("Raw discovery aggregate byte limit exceeded");
-  const fd = openSync3(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  const fd = openSync4(path, constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK);
   try {
-    const opened = fstatSync2(fd);
+    const opened = fstatSync3(fd);
     if (!opened.isFile() || !same2(initial, opened))
       throw new Error("Raw discovery input changed during open");
     const hash = createHash32("sha256"), buffer = Buffer.alloc(64 * 1024);
@@ -15811,13 +15976,13 @@ function hashRawDiscoveryFile(path, budget, changes) {
       consume(budget, count);
       hash.update(buffer.subarray(0, count));
     }
-    const final = fstatSync2(fd), current2 = lstatSync5(path, { throwIfNoEntry: false });
+    const final = fstatSync3(fd), current2 = lstatSync5(path, { throwIfNoEntry: false });
     safe2(path);
     if (!current2?.isFile() || !same2(opened, final) || !same2(final, current2) || bytes !== final.size)
       throw new Error("Raw discovery input changed during read");
     return hash.digest("hex");
   } finally {
-    closeSync3(fd);
+    closeSync4(fd);
   }
 }
 function identity2(stat, mutable = false) {
@@ -15863,7 +16028,7 @@ function trace(path) {
       cursor = dirname6(cursor);
       continue;
     }
-    const candidate = join9(cursor, component);
+    const candidate = join92(cursor, component);
     if (candidate.length > AGENT_POLICY_LIMITS.pathCharacters)
       throw new Error("Discovery resolved path length limit exceeded");
     const stat = lstatSync6(candidate, { bigint: true, throwIfNoEntry: false });
@@ -16873,7 +17038,7 @@ function assertSafePath(path) {
 }
 function readRootAlias(home, agent) {
   assertSafePath(home);
-  const realHome = realpathSync3(home), alias = join16(realHome, `.${agent}`);
+  const realHome = realpathSync32(home), alias = join16(realHome, `.${agent}`);
   const stat = lstatSync14(alias, { throwIfNoEntry: false, bigint: true });
   if (!stat?.isSymbolicLink())
     throw new Error(`Agent root alias changed after planning: ${alias}`);
@@ -16882,7 +17047,7 @@ function readRootAlias(home, agent) {
   const targetStat = lstatSync14(targetPath, { throwIfNoEntry: false });
   if (!targetStat?.isDirectory())
     throw new Error(`Agent root alias must target an existing directory: ${alias}`);
-  const target = realpathSync3(targetPath), inside = relative4(realHome, target);
+  const target = realpathSync32(targetPath), inside = relative4(realHome, target);
   if (!inside || inside === ".." || inside.startsWith(`..${sep4}`) || isAbsolute9(inside))
     throw new Error(`Agent root alias target must be inside the real home: ${alias}`);
   return { agent, home: realHome, alias, target, link, aliasIdentity: `${stat.dev}:${stat.ino}:${stat.ctimeNs}`, targetIdentity: `${targetStat.dev}:${targetStat.ino}` };
@@ -17416,10 +17581,10 @@ function assertManagedAgentBridge(agent, options = {}) {
   if (options.profileId !== undefined && options.profileId !== profile)
     throw new Error("NATIVE_SKILL_DRIFT: the hook selection profile differs from its managed binding; restart the native client after reviewing skills hook install");
   if (agent === "hermes") {
-    const supervisor = binding.supervisors?.hermes;
-    if (supervisor?.path !== join16(dataDir22, "agent-hooks", "hermes.js") || supervisor?.sha256 !== sha(renderHermesSupervisor(command, profile)))
+    const supervisor2 = binding.supervisors?.hermes;
+    if (supervisor2?.path !== join16(dataDir22, "agent-hooks", "hermes.js") || supervisor2?.sha256 !== sha(renderHermesSupervisor(command, profile)))
       throw new Error("NATIVE_SKILL_DRIFT: Hermes supervisor binding changed; run skills hook install");
-    assertHermesProtection(home, config, command, profile, supervisor);
+    assertHermesProtection(home, config, command, profile, supervisor2);
   } else if (agent === "opencode") {
     if (JSON.stringify(config.permission?.skill) !== JSON.stringify({ "*": "deny", [CLI_BRIDGE_NAME]: "allow" }) || readOptional(join16(home, ".config", "opencode", "plugins", "skills-cli.js")) !== renderOpenCodePlugin(command, profile))
       throw new Error("NATIVE_SKILL_DRIFT: OpenCode bridge protection changed; run skills hook install");
@@ -17711,9 +17876,9 @@ function snapshotPluginTree(root, options = {}) {
         const pins = directoryNames(absolute);
         pluginNeed(pins.length <= 1024, "Native plugin pin count exceeds its limit");
         directories.push({ path: absolute, stat: entryStat, names: pins });
-        for (const pin of pins) {
-          pluginNeed(/^[1-9][0-9]{0,9}$/.test(pin) && Number(pin) <= 2147483647, "Unrecognized native plugin pin name");
-          const pinPath = join21(absolute, pin), pinStat = stat(pinPath);
+        for (const pin2 of pins) {
+          pluginNeed(/^[1-9][0-9]{0,9}$/.test(pin2) && Number(pin2) <= 2147483647, "Unrecognized native plugin pin name");
+          const pinPath = join21(absolute, pin2), pinStat = stat(pinPath);
           pluginNeed(pinStat, "Native plugin pin disappeared");
           const bytes2 = readBytes(pinPath, 4096, "native-pin");
           let value;
@@ -17723,7 +17888,7 @@ function snapshotPluginTree(root, options = {}) {
             pluginRefusal("Malformed native plugin process pin");
           }
           pluginKeys(value, ["pid", "procStart", "procStartFt"]);
-          pluginNeed(value.pid === Number(pin), "Native plugin pin identity differs from its name");
+          pluginNeed(value.pid === Number(pin2), "Native plugin pin identity differs from its name");
           for (const key of ["procStart", "procStartFt"])
             pluginNeed(value[key] === undefined || typeof value[key] === "string" && value[key].length <= 128 && !/[\x00-\x1f\x7f]/.test(value[key]), "Invalid native plugin process-start witness");
           same3(pinStat, stat(pinPath));
@@ -17931,10 +18096,10 @@ function validatePlan(value) {
   pluginNeed(observedEvidenceDigest(plan.observation) === plan.evidenceDigest, "Plugin receipt observed evidence changed");
   pluginNeed(identityDigest(plan) === plan.planDigest, "Plugin receipt immutable identity changed");
 }
-var quote2 = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+var quote3 = (value) => `'${value.replaceAll("'", "'\\''")}'`;
 var resolverGuard = 'exec 9<"$1"; actual=$(/usr/bin/sha256sum /proc/self/fd/9); actual=${actual%% *}; [ "sha256:$actual" = "$2" ]; exec /proc/self/fd/9 integration plugin resolve --binding "$3"';
 function pluginResolverCommand(binding) {
-  return `${quote2("/bin/sh")} -eu -c ${quote2(resolverGuard)} plugin-resolver ${quote2(binding.target.resolver.executable)} ${quote2(binding.target.resolver.digest)} ${quote2(bindingId(binding))}`;
+  return `${quote3("/bin/sh")} -eu -c ${quote3(resolverGuard)} plugin-resolver ${quote3(binding.target.resolver.executable)} ${quote3(binding.target.resolver.digest)} ${quote3(bindingId(binding))}`;
 }
 function pluginBindingPath(storeRoot, id) {
   pluginNeed(/^[a-f0-9]{64}$/.test(id), "Invalid plugin binding identifier");
@@ -21661,11 +21826,11 @@ function isValidCIDRv6(value) {
   const parts = value.split("/");
   if (parts.length !== 2)
     return false;
-  const [address, prefix2] = parts;
-  if (!prefix2)
+  const [address, prefix3] = parts;
+  if (!prefix3)
     return false;
-  const prefixNum = Number(prefix2);
-  if (`${prefixNum}` !== prefix2)
+  const prefixNum = Number(prefix3);
+  if (`${prefixNum}` !== prefix3)
     return false;
   if (prefixNum < 0 || prefixNum > 128)
     return false;
@@ -31547,8 +31712,8 @@ function generateStringFormatCheck(doc, ctx, def, accessor) {
       doc.write(`if (!${accessor}.includes(${esc(def.includes)})) return INVALID;`);
       break;
     case "starts_with": {
-      const prefix2 = def.prefix;
-      doc.write(`if (${accessor}.slice(0, ${prefix2.length}) !== ${esc(prefix2)}) return INVALID;`);
+      const prefix3 = def.prefix;
+      doc.write(`if (${accessor}.slice(0, ${prefix3.length}) !== ${esc(prefix3)}) return INVALID;`);
       break;
     }
     case "ends_with": {
@@ -32281,8 +32446,8 @@ function generateDiscriminatedUnionCheck(doc, ctx, def, accessor) {
       claimed.add(value);
     }
     const conditions = Array.from(values, (value) => literalEquality(ctx, discVar, value));
-    const prefix2 = firstBranch ? "if" : "else if";
-    doc.write(`${prefix2} (${conditions.join(" || ")}) {`);
+    const prefix3 = firstBranch ? "if" : "else if";
+    doc.write(`${prefix3} (${conditions.join(" || ")}) {`);
     doc.indented((d) => {
       const branchOutput = generateCheck(d, ctx, option, accessor);
       d.write(`${outputVar} = ${branchOutput};`);
@@ -33136,12 +33301,12 @@ function _includes(includes, params) {
     includes
   });
 }
-function _startsWith(prefix2, params) {
+function _startsWith(prefix3, params) {
   return new $ZodCheckStartsWith({
     check: "string_format",
     format: "starts_with",
     ...normalizeParams2(params),
-    prefix: prefix2
+    prefix: prefix3
   });
 }
 function _endsWith(suffix, params) {
@@ -39109,7 +39274,7 @@ function coordinateClaudeSettings(before, replacement, options) {
   const plan = planClaudeHookEventsUpdate({
     ...options,
     events: selected,
-    expectedSettingsSha256: before === null ? "absent" : createHash5("sha256").update(before).digest("hex"),
+    expectedSettingsSha256: before === null ? "absent" : createHash6("sha256").update(before).digest("hex"),
     replacement
   });
   if (!plan)
@@ -39120,7 +39285,7 @@ function coordinateClaudeSettings(before, replacement, options) {
 
 // src/lib/installer.ts
 var __dirname2 = dirname7(fileURLToPath2(import.meta.url));
-var HOOKS_DIR = existsSync10(join10(__dirname2, "..", "..", "hooks", "hook-gitguard")) ? join10(__dirname2, "..", "..", "hooks") : join10(__dirname2, "..", "hooks");
+var HOOKS_DIR = existsSync11(join10(__dirname2, "..", "..", "hooks", "hook-gitguard")) ? join10(__dirname2, "..", "..", "hooks") : join10(__dirname2, "..", "hooks");
 function normalizeHookName(name) {
   return name.startsWith("hook-") ? name : `hook-${name}`;
 }
@@ -39208,11 +39373,11 @@ function getSettingsPath(scope = "global", target = "claude", codewithConfigPath
     return globalOverride;
   const dir = getTargetSettingsDir(target);
   if (target === "codex")
-    return join10(scope === "project" ? process.cwd() : homedir5(), dir, "hooks.json");
+    return join10(scope === "project" ? process.cwd() : homedir6(), dir, "hooks.json");
   if (scope === "project") {
     return target === "codewith" ? join10(process.cwd(), dir, "config.toml") : join10(process.cwd(), dir, "settings.json");
   }
-  return target === "codewith" ? join10(homedir5(), dir, "config.toml") : join10(homedir5(), dir, "settings.json");
+  return target === "codewith" ? join10(homedir6(), dir, "config.toml") : join10(homedir6(), dir, "settings.json");
 }
 function getHookPath(name) {
   const shortName = shortHookName(name);
@@ -39222,7 +39387,7 @@ function getHookPath(name) {
   return join10(HOOKS_DIR, normalizeHookName(shortName));
 }
 function hookExists(name) {
-  return existsSync10(getHookPath(name));
+  return existsSync11(getHookPath(name));
 }
 var settingsPreimages = new WeakMap;
 function readSettings2(scope = "global", target = "claude") {
@@ -39230,7 +39395,7 @@ function readSettings2(scope = "global", target = "claude") {
   if (target === "codex")
     return readCodexSettings(path);
   try {
-    if (existsSync10(path)) {
+    if (existsSync11(path)) {
       const text3 = readFileSync7(path, "utf-8"), value = JSON.parse(text3);
       settingsPreimages.set(value, { path, text: text3 });
       return value;
@@ -39239,14 +39404,14 @@ function readSettings2(scope = "global", target = "claude") {
     console.warn("[hooks] Cannot read hook settings; repair the selected file before installation.");
   }
   const empty = {};
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     settingsPreimages.set(empty, { path, text: null });
   return empty;
 }
 function settingsIdentity(path) {
-  if (existsSync10(path))
+  if (existsSync11(path))
     return realpathSync5(path);
-  return existsSync10(dirname7(path)) ? join10(realpathSync5(dirname7(path)), basename3(path)) : resolve7(path);
+  return existsSync11(dirname7(path)) ? join10(realpathSync5(dirname7(path)), basename3(path)) : resolve7(path);
 }
 function writeSettings(settings, scope = "global", target = "claude", expectedSettingsSha256) {
   const path = getSettingsPath(scope, target);
@@ -39258,21 +39423,21 @@ function writeSettings(settings, scope = "global", target = "claude", expectedSe
       throw new Error("Hook settings require a valid captured preimage.");
     assertSettingsPreimage(captured.text, expectedSettingsSha256);
   }
-  if (target === "claude" && settingsIdentity(path) === settingsIdentity(join10(homedir5(), ".claude/settings.json"))) {
+  if (target === "claude" && settingsIdentity(path) === settingsIdentity(join10(homedir6(), ".claude/settings.json"))) {
     const before = settingsPreimages.get(settings);
     if (!before || before.path !== path)
       throw new Error("Claude settings require a valid captured preimage before installation.");
-    const current2 = existsSync10(path) ? readFileSync7(path, "utf8") : null;
+    const current2 = existsSync11(path) ? readFileSync7(path, "utf8") : null;
     if (current2 !== before.text)
       throw new Error("Claude settings changed during installation; no settings were written.");
     if (coordinateClaudeSettings(before.text, JSON.stringify(settings, null, 2) + `
-`, { home: homedir5() }))
+`, { home: homedir6() }))
       return;
   }
   if (expectedSettingsSha256 !== undefined)
     return writeHookSettingsPreimage(path, settings, captured.text);
   const dir = dirname7(path);
-  if (!existsSync10(dir)) {
+  if (!existsSync11(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
   writeFileSync5(path, JSON.stringify(settings, null, 2) + `
@@ -39371,7 +39536,7 @@ function buildCodewithTomlFragment(name, profile, mementos) {
 function readCodewithConfig(scope, configPath) {
   const path = getSettingsPath(scope, "codewith", configPath);
   try {
-    return existsSync10(path) ? readFileSync7(path, "utf-8") : "";
+    return existsSync11(path) ? readFileSync7(path, "utf-8") : "";
   } catch {
     return "";
   }
@@ -39379,9 +39544,9 @@ function readCodewithConfig(scope, configPath) {
 function appendCodewithFragment(fragment, scope, configPath) {
   const path = getSettingsPath(scope, "codewith", configPath);
   const dir = dirname7(path);
-  if (!existsSync10(dir))
+  if (!existsSync11(dir))
     mkdirSync6(dir, { recursive: true });
-  const existing = existsSync10(path) ? readFileSync7(path, "utf-8") : "";
+  const existing = existsSync11(path) ? readFileSync7(path, "utf-8") : "";
   const sep3 = existing.trim() ? `
 
 ` : "";
@@ -39577,8 +39742,40 @@ function previewNativeSafetyRegistration(target, scope = "global") {
     throw new Error("Native safety registration could not be rendered.");
   return result;
 }
+function previewNativeReadinessRegistration(target) {
+  let result;
+  registerHook("trash-readiness", "global", target, undefined, undefined, (settings) => {
+    const before = target === "codex" ? capturedCodexSettings(settings) : settingsPreimages.get(settings)?.text;
+    if (before === undefined)
+      throw new Error("Hook settings require a valid captured preimage.");
+    result = { before, after: JSON.stringify(settings, null, 2) + `
+`, command: installedNativeReadinessCommand(target) };
+  });
+  if (!result)
+    throw new Error("Native readiness registration could not be rendered.");
+  return result;
+}
+function installNativeReadinessRegistration(target, expectedSettingsSha256) {
+  if (!/^(?:absent|[a-f0-9]{64})$/.test(expectedSettingsSha256))
+    throw new Error("Exact predecessor required");
+  registerHook("trash-readiness", "global", target, undefined, undefined, (settings, scope, selected) => writeSettings(settings, scope, selected, expectedSettingsSha256));
+  return { success: true };
+}
 function registerHook(name, scope = "global", target = "claude", profile, mementos, write = writeSettings) {
-  const meta3 = isNativeSafetyName(name) ? getHook(name) : resolveHookMeta(name);
+  const readiness = name === "trash-readiness";
+  if (readiness && (target === "gemini" || profile || scope !== "global"))
+    throw new Error("Unsupported readiness target");
+  const meta3 = readiness ? {
+    name,
+    event: "SessionStart",
+    matcher: "^(startup|resume|clear|fork)$",
+    timeoutSeconds: 20,
+    displayName: "Trash Readiness",
+    description: "Read-only native startup readiness",
+    version: "0.1.0",
+    category: "Environment",
+    tags: ["trash", "startup"]
+  } : isNativeSafetyName(name) ? getHook(name) : resolveHookMeta(name);
   if (!meta3)
     return;
   const eventKeys = getHookEvents(meta3).map((event) => {
@@ -39595,18 +39792,20 @@ function registerHook(name, scope = "global", target = "claude", profile, mement
   const settings = readSettings2(scope, target);
   if (!settings.hooks)
     settings.hooks = {};
-  if (isNativeSafetyName(name)) {
+  if (isNativeSafetyName(name) || readiness) {
     for (const groups of Object.values(settings.hooks))
       for (const group of groups)
         for (const hook of group.hooks ?? []) {
           if (typeof hook.command === "string" && /(?:^|\s)hasna-native-safety-v\d+(?:\s|$)/.test(hook.command) && !registrationName(hook.command)) {
             throw new Error("Unknown managed safety definition; reconcile its exact version before replacing it.");
           }
+          if (readiness && typeof hook.command === "string" && hook.command.includes("hasna-native-readiness-v") && registrationName(hook.command) !== "trash-readiness")
+            throw new Error("Unknown managed readiness definition");
         }
   }
   const retained = name === "mementos-context" && mementos === undefined ? retainedMementosRegistration(Object.values(settings.hooks).flatMap((groups) => Array.isArray(groups) ? groups.flatMap((group) => Array.isArray(group.hooks) ? group.hooks.map((hook) => hook.command).filter((command) => typeof command === "string") : []) : [])) : undefined;
-  const hookCommand = isNativeSafetyName(name) ? installedNativeSafetyCommand(name) : (profile ? `hooks run ${name} --profile ${profile}` : `hooks run ${name}`) + mementosCommandSuffix(mementos ?? retained);
-  if (target === "codex" || target === "claude" && isNativeSafetyName(name)) {
+  const hookCommand = readiness ? installedNativeReadinessCommand(target) : isNativeSafetyName(name) ? installedNativeSafetyCommand(name) : (profile ? `hooks run ${name} --profile ${profile}` : `hooks run ${name}`) + mementosCommandSuffix(mementos ?? retained);
+  if (target === "codex" || target === "claude" && (isNativeSafetyName(name) || readiness)) {
     const positions = [];
     for (const [event, groups] of Object.entries(settings.hooks)) {
       for (const entry of groups) {
@@ -39616,8 +39815,8 @@ function registerHook(name, scope = "global", target = "claude", profile, mement
           if (match && (match[1] ?? match[2]) === name || registrationName(command) === name) {
             if (registrationName(command) !== name)
               throw new Error("Unrecognized Codex registration; reconcile it before updating this hook.");
-            if (isNativeSafetyName(name) && entry.hooks[index].async !== undefined && entry.hooks[index].async !== false)
-              throw new Error("Asynchronous safety hooks cannot block; reconcile this registration before updating it.");
+            if ((isNativeSafetyName(name) || readiness) && (entry.hooks[index].async !== undefined && entry.hooks[index].async !== false || entry.hooks[index].asyncRewake === true))
+              throw new Error("Asynchronous managed native hooks are refused; synchronous registration is required");
             positions.push({ event, entry, index });
           }
         }
@@ -39795,7 +39994,7 @@ function codewithHasHookEntryInText(configText, name) {
 }
 function codewithHasHookEntry(name, scope = "global") {
   const path = getSettingsPath(scope, "codewith");
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     return false;
   try {
     return codewithHasHookEntryInText(readFileSync7(path, "utf-8"), name);
@@ -39843,7 +40042,7 @@ function uninstallHook(name, scope = "global", target = "claude") {
   const registrationsRemaining = [];
   if (target === "codewith" || target === "all") {
     const codewithPath = getSettingsPath(scope, "codewith");
-    if (existsSync10(codewithPath)) {
+    if (existsSync11(codewithPath)) {
       const before = readFileSync7(codewithPath, "utf-8");
       const after = removeCodewithHookEntry(before, shortName);
       if (after.removed) {
@@ -39886,7 +40085,7 @@ function uninstallHook(name, scope = "global", target = "claude") {
 // src/index.ts
 init_profiles();
 init_config();
-import { existsSync as existsSync15, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync25 } from "fs";
 
 // src/lib/transport.ts
 init_transport();
@@ -40026,15 +40225,15 @@ init_manifest();
 // src/lib/custom-install.ts
 init_config();
 init_manifest();
-import { existsSync as existsSync12, mkdirSync as mkdirSync11, mkdtempSync, readFileSync as readFileSync14, rmSync as rmSync2 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync11, mkdtempSync, readFileSync as readFileSync12, rmSync as rmSync2 } from "fs";
+import { join as join13 } from "path";
 import { tmpdir } from "os";
 function manifestAt(dir) {
-  const path = join17(dir, "manifest.json");
-  if (!existsSync12(path))
+  const path = join13(dir, "manifest.json");
+  if (!existsSync13(path))
     return;
   try {
-    return parseManifest(readFileSync14(path, "utf-8"));
+    return parseManifest(readFileSync12(path, "utf-8"));
   } catch {
     return;
   }
@@ -40053,8 +40252,8 @@ function writeFromManifest(manifest, srcDir, source, kind) {
   return { name, version: manifest.version, kind, source, dir, scriptPath };
 }
 async function cloneToTemp(gitUrl) {
-  const tmp = mkdtempSync(join17(tmpdir(), "hooks-install-"));
-  const proc = Bun.spawn(["git", "clone", "--depth", "1", "--quiet", gitUrl, join17(tmp, "repo")], {
+  const tmp = mkdtempSync(join13(tmpdir(), "hooks-install-"));
+  const proc = Bun.spawn(["git", "clone", "--depth", "1", "--quiet", gitUrl, join13(tmp, "repo")], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -40067,7 +40266,7 @@ async function cloneToTemp(gitUrl) {
     rmSync2(tmp, { recursive: true, force: true });
     throw new Error(`git clone failed (${exitCode}): ${stderr.trim()}`);
   }
-  return join17(tmp, "repo");
+  return join13(tmp, "repo");
 }
 function isGitUrl(value) {
   return value.startsWith("git@") || value.startsWith("ssh://") || value.startsWith("file://") || value.endsWith(".git");
@@ -40077,7 +40276,7 @@ function isCustomSource(value) {
     return true;
   if (value.startsWith("http://") || value.startsWith("https://"))
     return true;
-  return existsSync12(value);
+  return existsSync13(value);
 }
 async function installCustomSource(source) {
   if (isGitUrl(source)) {
@@ -40091,11 +40290,11 @@ async function installCustomSource(source) {
   if (source.startsWith("http://") || source.startsWith("https://")) {
     return installManifestUrl(source);
   }
-  if (!existsSync12(source)) {
+  if (!existsSync13(source)) {
     throw new Error(`No such local path: ${source}`);
   }
   if (source.endsWith("manifest.json")) {
-    const manifest = parseManifest(readFileSync14(source, "utf-8"));
+    const manifest = parseManifest(readFileSync12(source, "utf-8"));
     return writeFromManifest(manifest, source.substring(0, source.lastIndexOf("/")), source, "local");
   }
   return copyManifestDir(source, source, "local");
@@ -40125,16 +40324,16 @@ async function installManifestUrl(url2) {
   return { name, version: manifest.version, kind: "url", source: url2, dir, scriptPath };
 }
 // src/lib/sync.ts
-import { createHash as createHash6 } from "crypto";
-import { readFileSync as readFileSync15 } from "fs";
+import { createHash as createHash7 } from "crypto";
+import { readFileSync as readFileSync14 } from "fs";
 init_db();
 init_store();
 init_manifest();
 function sha256OfText(text3) {
-  return createHash6("sha256").update(text3).digest("hex");
+  return createHash7("sha256").update(text3).digest("hex");
 }
 function sha256OfPath(path) {
-  return createHash6("sha256").update(readFileSync15(path)).digest("hex");
+  return createHash7("sha256").update(readFileSync14(path)).digest("hex");
 }
 function collectBundledCatalog() {
   const out = [];
@@ -40189,13 +40388,13 @@ async function fetchRemoteState(apiUrl, apiKey) {
   }
   return { catalog: catalog.hooks, remoteLock };
 }
-function classifyRemotePin(pin, remoteVersion, remoteSha) {
-  const pinnedLocally = pin !== undefined && pin.version === remoteVersion && pin.sha256 === remoteSha;
+function classifyRemotePin(pin2, remoteVersion, remoteSha) {
+  const pinnedLocally = pin2 !== undefined && pin2.version === remoteVersion && pin2.sha256 === remoteSha;
   if (pinnedLocally)
     return "unchanged";
-  if (pin !== undefined && pin.pinned === true && pin.version !== remoteVersion)
+  if (pin2 !== undefined && pin2.pinned === true && pin2.version !== remoteVersion)
     return "unchanged";
-  if (pin !== undefined)
+  if (pin2 !== undefined)
     return "updated";
   return "added";
 }
@@ -40205,7 +40404,7 @@ function computeDiff(catalog, remoteLock) {
   for (const entry of catalog) {
     if (!entry.name || !entry.version || !entry.sha256)
       continue;
-    const pin = local.hooks[entry.name];
+    const pin2 = local.hooks[entry.name];
     if (remoteLock) {
       const remotePin = remoteLock.hooks[entry.name];
       if (!remotePin) {
@@ -40215,9 +40414,9 @@ function computeDiff(catalog, remoteLock) {
       if (remotePin.version !== entry.version) {
         throw new Error(`remote registry is ambiguous for '${entry.name}': lock pins ${remotePin.version} but catalog latest is ${entry.version}. ` + `Fix the registry (or its lock) before syncing \u2014 nothing was changed.`);
       }
-      diff[classifyRemotePin(pin, remotePin.version, remotePin.sha256)].push(entry.name);
+      diff[classifyRemotePin(pin2, remotePin.version, remotePin.sha256)].push(entry.name);
     } else {
-      diff[classifyRemotePin(pin, entry.version, entry.sha256)].push(entry.name);
+      diff[classifyRemotePin(pin2, entry.version, entry.sha256)].push(entry.name);
     }
   }
   return diff;
@@ -40435,8 +40634,8 @@ async function installPinnedFromBundled(name, version2) {
 // src/serve.ts
 init_manifest();
 init_store();
-import { readFileSync as readFileSync17 } from "fs";
-import { dirname as dirname17, join as join19 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname17, join as join17 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/lib/secure-compare.ts
@@ -40811,8 +41010,8 @@ var SERVE_HOST = "127.0.0.1";
 var SERVE_SERVICE_NAME = "hooks-registry";
 function packageVersion() {
   try {
-    const pkgPath = join19(dirname17(fileURLToPath4(import.meta.url)), "..", "package.json");
-    return JSON.parse(readFileSync17(pkgPath, "utf-8")).version || "0.0.0";
+    const pkgPath = join17(dirname17(fileURLToPath4(import.meta.url)), "..", "package.json");
+    return JSON.parse(readFileSync15(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -40913,8 +41112,8 @@ function handleServeRequest(req, apiKey) {
       for (const entry of catalog)
         byVersion[entry.name] = entry.versions;
       const hooks = {};
-      for (const [name, pin] of Object.entries(lock.hooks)) {
-        hooks[name] = { ...pin, versions: byVersion[name] ?? [pin.version] };
+      for (const [name, pin2] of Object.entries(lock.hooks)) {
+        hooks[name] = { ...pin2, versions: byVersion[name] ?? [pin2.version] };
       }
       return json2({ hooks });
     });
@@ -41057,23 +41256,23 @@ async function provisionCloudflareResources(options) {
   return result;
 }
 // src/lib/codex-safety-trust.ts
-import { createHash as createHash12, randomUUID as randomUUID3 } from "crypto";
-import { constants as constants12, closeSync as closeSync7, fsyncSync as fsyncSync5, fstatSync as fstatSync6, lstatSync as lstatSync15, mkdirSync as mkdirSync13, openSync as openSync7, readFileSync as readFileSync21, realpathSync as realpathSync10, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname21, isAbsolute as isAbsolute18, join as join24, relative as relative2 } from "path";
-import { homedir as homedir7 } from "os";
+import { createHash as createHash17, randomUUID as randomUUID3 } from "crypto";
+import { constants as constants14, closeSync as closeSync15, fsyncSync as fsyncSync5, fstatSync as fstatSync7, lstatSync as lstatSync15, mkdirSync as mkdirSync13, openSync as openSync15, readFileSync as readFileSync20, realpathSync as realpathSync10, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname21, isAbsolute as isAbsolute18, join as join20, relative as relative2 } from "path";
+import { homedir as homedir8 } from "os";
 
 // src/lib/codex-safety-check.ts
 import { spawn, execFile as execFile2 } from "child_process";
-import { createHash as createHash7 } from "crypto";
-import { constants as constants4, openSync as openSync6, closeSync as closeSync6, fstatSync as fstatSync5, lstatSync as lstatSync10, readFileSync as readFileSync20, realpathSync as realpathSync9 } from "fs";
+import { createHash as createHash12 } from "crypto";
+import { constants as constants12, openSync as openSync7, closeSync as closeSync7, fstatSync as fstatSync6, lstatSync as lstatSync10, readFileSync as readFileSync19, realpathSync as realpathSync9 } from "fs";
 import { dirname as dirname20, isAbsolute as isAbsolute17, resolve as resolve17 } from "path";
 import { promisify } from "util";
 
 // src/native-safety.ts
 import { execFile } from "child_process";
-import { closeSync as closeSync5, constants as constants3, existsSync as existsSync13, fstatSync as fstatSync4, fsyncSync, linkSync as linkSync3, lstatSync as lstatSync9, mkdirSync as mkdirSync12, openSync as openSync5, readFileSync as readFileSync19, realpathSync as realpathSync8, renameSync as renameSync3, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname19, isAbsolute as isAbsolute15, join as join20, resolve as resolve15 } from "path";
+import { closeSync as closeSync6, constants as constants4, existsSync as existsSync14, fstatSync as fstatSync5, fsyncSync, linkSync as linkSync3, lstatSync as lstatSync9, mkdirSync as mkdirSync12, openSync as openSync6, readFileSync as readFileSync17, realpathSync as realpathSync8, renameSync as renameSync3, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname19, isAbsolute as isAbsolute15, join as join19, resolve as resolve15 } from "path";
 class NativeSafetyError extends Error {
   code;
   reason;
@@ -41143,7 +41342,7 @@ async function evaluateRecord(event, record3, signal, executionAgent) {
   } catch {}
   throw new NativeSafetyError("guard_failed");
 }
-async function verifyNativeSafetyCommand(command, home = homedir6()) {
+async function verifyNativeSafetyCommand(command, home = homedir7()) {
   home = canonicalHome(home);
   const record3 = parseRecord(JSON.stringify({ schema: "hasna.hooks.native-safety.v1", harness: "sumi", command }), home);
   const verdict = await evaluateRecord({ hook_event_name: "PreToolUse", tool_name: "Bash", cwd: home, tool_input: { command: "rm -- .hasna-trash-verification-only" } }, record3);
@@ -41167,7 +41366,7 @@ function need5(condition, code2) {
   if (!condition)
     throw new CodexSafetyError(code2);
 }
-var digest3 = (bytes) => createHash7("sha256").update(bytes).digest("hex");
+var digest3 = (bytes) => createHash12("sha256").update(bytes).digest("hex");
 function nativeHeader(bytes) {
   if (bytes.length < 64 || !["arm64", "x64"].includes(process.arch))
     return false;
@@ -41192,16 +41391,16 @@ function executable(command) {
       if (parent === dirname20(parent))
         break;
     }
-    const fd = openSync6(path, constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK);
+    const fd = openSync7(path, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
     try {
-      const stat2 = fstatSync5(fd);
+      const stat2 = fstatSync6(fd);
       need5(stat2.isFile() && [0, process.getuid?.()].includes(stat2.uid) && !(stat2.mode & 18) && !!(stat2.mode & 64) && stat2.size <= 256000000, "native_unsafe_executable");
-      const bytes = readFileSync20(fd);
+      const bytes = readFileSync19(fd);
       need5(bytes.length <= 256000000, "native_unavailable");
       need5(nativeHeader(bytes), "native_executable_required");
       return { path, sha256: digest3(bytes) };
     } finally {
-      closeSync6(fd);
+      closeSync7(fd);
     }
   } catch (error61) {
     if (error61 instanceof CodexSafetyError)
@@ -41346,7 +41545,7 @@ function supportedDiscoveryWarnings(hooks, warnings) {
   }
   return warnings.every((warning) => typeof warning === "string" && allowed.delete(warning));
 }
-function selectCodexSafety(discovery, configuration, home, cwd, featureEnabled, requireReady = true) {
+function selectCodexSafety(discovery, configuration, home, cwd, featureEnabled, requireReady = true, readiness = false) {
   const data = discovery?.data;
   need5(Array.isArray(data) && data.length === 1 && data[0]?.cwd === cwd && Array.isArray(data[0]?.hooks) && data[0].hooks.length <= 1e4 && Array.isArray(data[0].errors) && data[0].errors.length === 0 && Array.isArray(data[0].warnings) && supportedDiscoveryWarnings(data[0].hooks, data[0].warnings), "native_discovery_failed");
   const config2 = configuration?.config;
@@ -41357,12 +41556,14 @@ function selectCodexSafety(discovery, configuration, home, cwd, featureEnabled,
       if (/\bhasna-native-safety-v\d+\b/.test(hook2.command))
         need5(nativeSafetyCommandBinding(hook2.command), "guard_definition_invalid");
       need5(!/^(?:hooks run trash-guard|hook-trash-guard)(?:\s|$)/.test(hook2.command.trim()), "guard_definition_invalid");
+      if (readiness && hook2.command.includes("hasna-native-readiness-v"))
+        need5(nativeReadinessCommandBinding(hook2.command), "guard_definition_invalid");
     }
-  const selected = data[0].hooks.filter((hook2) => typeof hook2?.command === "string" && nativeSafetyCommandBinding(hook2.command)?.name === "trash-guard");
+  const selected = data[0].hooks.filter((hook2) => typeof hook2?.command === "string" && (readiness ? !!nativeReadinessCommandBinding(hook2.command) : nativeSafetyCommandBinding(hook2.command)?.name === "trash-guard"));
   need5(selected.length !== 0, "guard_missing");
   need5(selected.length === 1, "guard_ambiguous");
-  const hook = selected[0], binding = nativeSafetyCommandBinding(hook.command);
-  need5(binding.home === home && hook.eventName === "preToolUse" && hook.handlerType === "command" && hook.matcher === matcher && hook.timeoutSec === 10 && hook.async === false && hook.statusMessage === null && hook.additionalContextLimit === null && typeof hook.key === "string" && hook.key.length <= 4096 && typeof hook.sourcePath === "string" && isAbsolute17(hook.sourcePath) && hook.pluginId === null && hook.isManaged === false && ["user", "project"].includes(hook.source) && typeof hook.currentHash === "string" && /^sha256:[a-f0-9]{64}$/.test(hook.currentHash), "guard_definition_invalid");
+  const hook = selected[0], binding = readiness ? nativeReadinessCommandBinding(hook.command) : nativeSafetyCommandBinding(hook.command);
+  need5(binding.home === home && (!readiness || binding?.provider === "codex") && hook.eventName === (readiness ? "sessionStart" : "preToolUse") && hook.handlerType === "command" && hook.matcher === (readiness ? "^(startup|resume|clear|fork)$" : matcher) && hook.timeoutSec === (readiness ? 20 : 10) && hook.async === false && hook.statusMessage === null && hook.additionalContextLimit === null && typeof hook.key === "string" && hook.key.length <= 4096 && typeof hook.sourcePath === "string" && isAbsolute17(hook.sourcePath) && hook.pluginId === null && hook.isManaged === false && ["user", "project"].includes(hook.source) && typeof hook.currentHash === "string" && /^sha256:[a-f0-9]{64}$/.test(hook.currentHash), "guard_definition_invalid");
   need5(typeof hook.enabled === "boolean" && ["trusted", "untrusted", "modified"].includes(hook.trustStatus), "guard_definition_invalid");
   if (requireReady) {
     need5(hook.enabled === true, "guard_disabled");
@@ -41395,7 +41596,7 @@ async function readCodexSafety(rpc, home, cwd, options = {}) {
       }
     } while (cursor !== null);
   }
-  return { guard: selectCodexSafety(hooks, configuration, home, cwd, enabled, options.requireReady ?? true), discovery: hooks, configuration };
+  return { guard: selectCodexSafety(hooks, configuration, home, cwd, enabled, options.requireReady ?? true, options.readiness ?? false), discovery: hooks, configuration };
 }
 
 // src/lib/codex-safety-trust.ts
@@ -41413,7 +41614,7 @@ function need7(value, code2 = "native_changed") {
   if (!value)
     throw new CodexTrustError(code2);
 }
-var sha4 = (value) => createHash12("sha256").update(value).digest("hex");
+var sha4 = (value) => createHash17("sha256").update(value).digest("hex");
 function canonical4(value) {
   if (Array.isArray(value))
     return "[" + value.map(canonical4).join(",") + "]";
@@ -41454,37 +41655,37 @@ function safeDirectory2(path) {
 }
 function readPrivate(path) {
   safeDirectory2(dirname21(path));
-  const fd = openSync7(path, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
+  const fd = openSync15(path, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
   try {
-    const s = fstatSync6(fd);
+    const s = fstatSync7(fd);
     need7(s.isFile() && s.uid === process.getuid?.() && !(s.mode & 63) && s.size <= 4194304, "preimage_unsafe");
-    const bytes = readFileSync21(fd);
+    const bytes = readFileSync20(fd);
     need7(bytes.length <= 4194304, "preimage_unsafe");
     return bytes;
   } finally {
-    closeSync7(fd);
+    closeSync15(fd);
   }
 }
 function syncDirectory(path) {
-  const fd = openSync7(path, constants12.O_RDONLY | constants12.O_DIRECTORY | constants12.O_NOFOLLOW);
+  const fd = openSync15(path, constants14.O_RDONLY | constants14.O_DIRECTORY | constants14.O_NOFOLLOW);
   try {
     fsyncSync5(fd);
   } finally {
-    closeSync7(fd);
+    closeSync15(fd);
   }
 }
 function exclusive(path, bytes) {
-  const fd = openSync7(path, constants12.O_CREAT | constants12.O_EXCL | constants12.O_WRONLY | constants12.O_NOFOLLOW, 384);
+  const fd = openSync15(path, constants14.O_CREAT | constants14.O_EXCL | constants14.O_WRONLY | constants14.O_NOFOLLOW, 384);
   try {
     writeFileSync11(fd, bytes);
     fsyncSync5(fd);
   } finally {
-    closeSync7(fd);
+    closeSync15(fd);
   }
   syncDirectory(dirname21(path));
 }
-async function inspect(rpc, home, cwd) {
-  const observed = await readCodexSafety(rpc, home, cwd, { includeLayers: true, requireReady: false });
+async function inspect(rpc, home, cwd, readiness = false) {
+  const observed = await readCodexSafety(rpc, home, cwd, { includeLayers: true, requireReady: false, readiness });
   const { guard, configuration, discovery } = observed;
   const layers = configuration?.layers;
   need7(Array.isArray(layers) && layers.length <= 1000, "native_config_invalid");
@@ -41501,7 +41702,7 @@ async function inspect(rpc, home, cwd) {
   need7(rawState === undefined || rawState && typeof rawState === "object" && !Array.isArray(rawState), "native_config_invalid");
   const desired = { ...rawState, enabled: true, trusted_hash: guard.currentHash };
   const planBase = {
-    schema: "hasna.hooks.codex-safety-trust/v1",
+    schema: readiness ? "hasna.hooks.codex-readiness-trust/v1" : "hasna.hooks.codex-safety-trust/v1",
     nativeVersion: rpc.version,
     cwd,
     key: guard.key,
@@ -41509,37 +41710,44 @@ async function inspect(rpc, home, cwd) {
     configPath: path,
     configVersion: layer.version,
     action: guard.enabled && guard.trustStatus === "trusted" ? "unchanged" : "trust_and_enable",
-    guardVerified: true,
+    guardVerified: !readiness,
+    ...readiness ? { readinessRunnerVerified: true } : {},
     nativeAdoptionVerified: false
   };
   const plan = { ...planBase, planDigest: sha4(canonical4({ planBase, configuration, discovery, raw: sha4(before) })) };
   return { ...observed, layer, layers, canonicalPath, before, desired, plan };
 }
 async function context2(options, dependencies) {
-  const home = realpathSync10(options.home ?? homedir7()), cwd = realpathSync10(options.cwd ?? process.cwd());
+  const home = realpathSync10(options.home ?? homedir8()), cwd = realpathSync10(options.cwd ?? process.cwd());
   need7(isAbsolute18(home) && isAbsolute18(cwd), "input_invalid");
   return { home, cwd, rpc: await (dependencies.connect ?? connectCodexSafety)({ ...options, home }) };
 }
-async function planCodexSafetyTrust(options = {}, dependencies = {}) {
+async function verify(command, home, readiness, dependencies) {
+  if (readiness)
+    need7(nativeReadinessCommandVerified(command));
+  else
+    await (dependencies.verify ?? verifyNativeSafetyCommand)(command, home);
+}
+async function planTrust(options = {}, dependencies = {}) {
   const { home, cwd, rpc } = await context2(options, dependencies);
   try {
-    const before = await inspect(rpc, home, cwd);
-    await (dependencies.verify ?? verifyNativeSafetyCommand)(before.guard.command, home);
-    need7((await inspect(rpc, home, cwd)).plan.planDigest === before.plan.planDigest);
+    const before = await inspect(rpc, home, cwd, options.readiness);
+    await verify(before.guard.command, home, !!options.readiness, dependencies);
+    need7((await inspect(rpc, home, cwd, options.readiness)).plan.planDigest === before.plan.planDigest);
     return before.plan;
   } finally {
     await rpc.close();
   }
 }
-async function applyCodexSafetyTrust(options, dependencies = {}) {
+async function applyTrust(options, dependencies = {}) {
   need7(/^[a-f0-9]{64}$/.test(options.expectedPlanDigest), "input_invalid");
   const selected = { ...options }, { home, cwd, rpc } = await context2(selected, dependencies);
   let operationId;
   try {
-    const before = await inspect(rpc, home, cwd);
+    const before = await inspect(rpc, home, cwd, selected.readiness);
     need7(before.plan.planDigest === selected.expectedPlanDigest);
-    await (dependencies.verify ?? verifyNativeSafetyCommand)(before.guard.command, home);
-    need7((await inspect(rpc, home, cwd)).plan.planDigest === before.plan.planDigest);
+    await verify(before.guard.command, home, !!selected.readiness, dependencies);
+    need7((await inspect(rpc, home, cwd, selected.readiness)).plan.planDigest === before.plan.planDigest);
     if (before.plan.action === "unchanged")
       return { ok: true, changed: false, ...before.plan };
     const expectedConfiguration = structuredClone(before.configuration);
@@ -41555,8 +41763,8 @@ async function applyCodexSafetyTrust(options, dependencies = {}) {
     expectedGuard.trustStatus = "trusted";
     operationId = randomUUID3();
     let directory2 = home;
-    for (const part of [".hasna", "hooks", "native", "codex-trash-trust", operationId]) {
-      directory2 = join24(directory2, part);
+    for (const part of [".hasna", "hooks", "native", selected.readiness ? "codex-readiness-trust" : "codex-trash-trust", operationId]) {
+      directory2 = join20(directory2, part);
       try {
         mkdirSync13(directory2, { mode: 448 });
         syncDirectory(dirname21(directory2));
@@ -41566,8 +41774,8 @@ async function applyCodexSafetyTrust(options, dependencies = {}) {
       }
       safeDirectory2(directory2);
     }
-    exclusive(join24(directory2, "config.before"), before.before);
-    exclusive(join24(directory2, "intent.json"), JSON.stringify({ operationId, plan: before.plan, configSHA256: sha4(before.before) }) + `
+    exclusive(join20(directory2, "config.before"), before.before);
+    exclusive(join20(directory2, "intent.json"), JSON.stringify({ operationId, plan: before.plan, configSHA256: sha4(before.before) }) + `
 `);
     need7(sha4(readPrivate(before.canonicalPath)) === sha4(before.before));
     const result = await rpc.request("config/batchWrite", {
@@ -41577,7 +41785,7 @@ async function applyCodexSafetyTrust(options, dependencies = {}) {
       edits: [{ keyPath: "hooks.state." + JSON.stringify(before.guard.key), value: before.desired, mergeStrategy: "replace" }]
     });
     need7(result?.status === "ok" && result.filePath === before.plan.configPath && result.overriddenMetadata === null && /^sha256:[a-f0-9]{64}$/.test(result.version));
-    const after = await inspect(rpc, home, cwd);
+    const after = await inspect(rpc, home, cwd, selected.readiness);
     expectedLayer.version = result.version;
     need7(after.layer.version === result.version && after.plan.action === "unchanged" && mergedConfiguration(after.configuration.config) === mergedConfiguration(expectedConfiguration.config) && canonical4(after.configuration.layers) === canonical4(expectedConfiguration.layers) && canonical4(after.discovery) === canonical4(expectedDiscovery));
     const receipt = {
@@ -41586,12 +41794,13 @@ async function applyCodexSafetyTrust(options, dependencies = {}) {
       operationId,
       planDigest: before.plan.planDigest,
       configVersion: result.version,
-      guardVerified: true,
+      guardVerified: !selected.readiness,
+      ...selected.readiness ? { readinessRunnerVerified: true } : {},
       nativeDiscoveryVerified: true,
       nativeAdoptionVerified: false,
       unrelatedConfigurationPreserved: true
     };
-    exclusive(join24(directory2, "receipt.json"), JSON.stringify(receipt) + `
+    exclusive(join20(directory2, "receipt.json"), JSON.stringify(receipt) + `
 `);
     return receipt;
   } catch (error61) {
@@ -41602,11 +41811,13 @@ async function applyCodexSafetyTrust(options, dependencies = {}) {
     await rpc.close();
   }
 }
+var planCodexSafetyTrust = (options = {}, dependencies = {}) => planTrust({ ...options, readiness: false }, dependencies);
+var applyCodexSafetyTrust = (options, dependencies = {}) => applyTrust({ ...options, readiness: false }, dependencies);
 // src/lib/claude-safety-check.ts
-import { constants as constants14, closeSync as closeSync15, fstatSync as fstatSync7, lstatSync as lstatSync21, openSync as openSync15, readFileSync as readFileSync23, realpathSync as realpathSync11 } from "fs";
-import { createHash as createHash17 } from "crypto";
-import { dirname as dirname22, isAbsolute as isAbsolute19, join as join27, resolve as resolve18 } from "path";
-import { homedir as homedir8 } from "os";
+import { constants as constants15, closeSync as closeSync17, fstatSync as fstatSync15, lstatSync as lstatSync21, openSync as openSync17, readFileSync as readFileSync21, realpathSync as realpathSync11 } from "fs";
+import { createHash as createHash19 } from "crypto";
+import { dirname as dirname22, isAbsolute as isAbsolute19, join as join24, resolve as resolve18 } from "path";
+import { homedir as homedir9 } from "os";
 class ClaudeSafetyError extends Error {
   code;
   constructor(code2) {
@@ -41619,7 +41830,7 @@ function need8(value, code2) {
   if (!value)
     throw new ClaudeSafetyError(code2);
 }
-var sha6 = (value) => createHash17("sha256").update(value).digest("hex");
+var sha6 = (value) => createHash19("sha256").update(value).digest("hex");
 function read3(path) {
   try {
     const resolved = realpathSync11(path);
@@ -41629,15 +41840,15 @@ function read3(path) {
       if (dirname22(parent) === parent)
         break;
     }
-    const fd = openSync15(resolved, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
+    const fd = openSync17(resolved, constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK);
     try {
-      const s = fstatSync7(fd);
+      const s = fstatSync15(fd);
       need8(s.isFile() && [0, process.getuid?.()].includes(s.uid) && !(s.mode & 18) && s.size <= 1048576, "settings_unsafe");
-      const raw = readFileSync23(fd, "utf8");
+      const raw = readFileSync21(fd, "utf8");
       need8(Buffer.byteLength(raw) <= 1048576, "settings_unsafe");
       return { path, resolved, sha256: sha6(raw), raw };
     } finally {
-      closeSync15(fd);
+      closeSync17(fd);
     }
   } catch (error61) {
     if (error61.code === "ENOENT")
@@ -41648,11 +41859,11 @@ function read3(path) {
   }
 }
 async function verifyClaudeSafetyConfiguration(options = {}, dependencies = {}) {
-  const home = realpathSync11(options.home ?? homedir8()), cwd = realpathSync11(options.cwd ?? process.cwd());
+  const home = realpathSync11(options.home ?? homedir9()), cwd = realpathSync11(options.cwd ?? process.cwd());
   const paths = [
-    options.userSettingsPath ?? join27(home, ".claude/settings.json"),
-    join27(cwd, ".claude/settings.json"),
-    options.localSettingsPath ?? join27(cwd, ".claude/settings.local.json")
+    options.userSettingsPath ?? join24(home, ".claude/settings.json"),
+    join24(cwd, ".claude/settings.json"),
+    options.localSettingsPath ?? join24(cwd, ".claude/settings.local.json")
   ];
   need8(paths.every((path) => isAbsolute19(path) && resolve18(path) === path), "settings_unsafe");
   const inspect2 = () => [...new Set(paths)].map(read3);
@@ -41713,10 +41924,10 @@ async function verifyClaudeSafetyConfiguration(options = {}, dependencies = {})
   };
 }
 // src/lib/native-safety-registration.ts
-import { createHash as createHash19, randomUUID as randomUUID5 } from "crypto";
-import { constants as constants15, closeSync as closeSync17, fstatSync as fstatSync15, fsyncSync as fsyncSync7, lstatSync as lstatSync23, mkdirSync as mkdirSync14, openSync as openSync17, readFileSync as readFileSync25, realpathSync as realpathSync12, writeFileSync as writeFileSync12 } from "fs";
-import { basename as basename9, dirname as dirname23, isAbsolute as isAbsolute20, join as join29, relative as relative3, resolve as resolve19 } from "path";
-import { homedir as homedir9 } from "os";
+import { createHash as createHash21, randomUUID as randomUUID5 } from "crypto";
+import { constants as constants16, closeSync as closeSync18, fstatSync as fstatSync17, fsyncSync as fsyncSync7, lstatSync as lstatSync23, mkdirSync as mkdirSync14, openSync as openSync18, readFileSync as readFileSync23, realpathSync as realpathSync12, writeFileSync as writeFileSync12 } from "fs";
+import { basename as basename9, dirname as dirname23, isAbsolute as isAbsolute20, join as join27, relative as relative3, resolve as resolve19 } from "path";
+import { homedir as homedir10 } from "os";
 class NativeRegistrationError extends Error {
   code;
   operationId;
@@ -41731,7 +41942,7 @@ var need9 = (value, code2) => {
   if (!value)
     throw new NativeRegistrationError(code2);
 };
-var sha7 = (value) => createHash19("sha256").update(value).digest("hex");
+var sha7 = (value) => createHash21("sha256").update(value).digest("hex");
 function canonical6(value) {
   if (Array.isArray(value))
     return "[" + value.map(canonical6).join(",") + "]";
@@ -41765,7 +41976,7 @@ function read5(path) {
     const suffix = [basename9(path)];
     for (;; ) {
       try {
-        resolved = join29(realpathSync12(ancestor), ...suffix);
+        resolved = join27(realpathSync12(ancestor), ...suffix);
         break;
       } catch (missing2) {
         if (missing2.code !== "ENOENT" || dirname23(ancestor) === ancestor || suffix.length >= 64)
@@ -41787,22 +41998,22 @@ function read5(path) {
   safeDirectory3(dirname23(resolved));
   let fd;
   try {
-    fd = openSync17(resolved, constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK);
+    fd = openSync18(resolved, constants16.O_RDONLY | constants16.O_NOFOLLOW | constants16.O_NONBLOCK);
   } catch (error61) {
     if (error61.code === "ENOENT")
       return { resolved, raw: null, sha256: "absent" };
     throw new NativeRegistrationError("settings_unsafe");
   }
   try {
-    const s = fstatSync15(fd);
+    const s = fstatSync17(fd);
     need9(s.isFile() && s.uid === process.getuid?.() && !(s.mode & 18) && s.nlink === 1 && s.size <= 1048576, "settings_unsafe");
-    const bytes = readFileSync25(fd);
+    const bytes = readFileSync23(fd);
     need9(bytes.length <= 1048576, "settings_unsafe");
     const raw = bytes.toString("utf8");
     need9(Buffer.from(raw).equals(bytes), "settings_invalid");
     return { resolved, raw, sha256: sha7(bytes) };
   } finally {
-    closeSync17(fd);
+    closeSync18(fd);
   }
 }
 function assertLosslessJson(raw) {
@@ -41860,7 +42071,7 @@ function validateSettings(raw) {
         need9(group && Array.isArray(group.hooks), "settings_invalid");
         for (const hook of group.hooks) {
           need9(hook && typeof hook === "object", "settings_invalid");
-          if (registrationName(hook.command) === "trash-guard") {
+          if (["trash-guard", "trash-readiness"].includes(registrationName(hook.command) ?? "")) {
             need9((hook.async === undefined || hook.async === false) && hook.asyncRewake !== true, "registration_conflict");
           }
         }
@@ -41871,7 +42082,7 @@ function validateSettings(raw) {
 }
 function inspect2(options) {
   need9(options?.target === "codex" || options?.target === "claude", "input_invalid");
-  const home = realpathSync12(homedir9()), path = getSettingsPath("global", options.target);
+  const home = realpathSync12(homedir10()), path = getSettingsPath("global", options.target);
   need9(isAbsolute20(path) && resolve19(path) === path, "input_invalid");
   const nativeHome = options.target === "codex" ? process.env.CODEX_HOME : process.env.CLAUDE_CONFIG_DIR;
   if (nativeHome !== undefined) {
@@ -41884,7 +42095,7 @@ function inspect2(options) {
   const parsed = validateSettings(before.raw);
   let preview2;
   try {
-    preview2 = previewNativeSafetyRegistration(options.target);
+    preview2 = (options.readiness ? previewNativeReadinessRegistration : previewNativeSafetyRegistration)(options.target);
   } catch {
     throw new NativeRegistrationError("registration_conflict");
   }
@@ -41892,7 +42103,7 @@ function inspect2(options) {
   validateSettings(preview2.after);
   const changed = canonical6(parsed) !== canonical6(JSON.parse(preview2.after));
   const base = {
-    schema: "hasna.hooks.native-safety-registration/v1",
+    schema: options.readiness ? "hasna.hooks.native-readiness-registration/v1" : "hasna.hooks.native-safety-registration/v1",
     target: options.target,
     settingsPath: path,
     resolvedPath: before.resolved,
@@ -41900,7 +42111,8 @@ function inspect2(options) {
     desiredSHA256: changed ? sha7(preview2.after) : before.sha256,
     commandSHA256: sha7(preview2.command),
     action: changed ? "register" : "unchanged",
-    guardVerified: true,
+    guardVerified: !options.readiness,
+    ...options.readiness ? { readinessRunnerVerified: true } : {},
     nativeAdoptionVerified: false
   };
   const plan = { ...base, planDigest: sha7(canonical6(base)) };
@@ -41908,37 +42120,40 @@ function inspect2(options) {
   return { home, before, preview: preview2, plan };
 }
 function syncDirectory2(path) {
-  const fd = openSync17(path, constants15.O_RDONLY | constants15.O_DIRECTORY | constants15.O_NOFOLLOW);
+  const fd = openSync18(path, constants16.O_RDONLY | constants16.O_DIRECTORY | constants16.O_NOFOLLOW);
   try {
     fsyncSync7(fd);
   } finally {
-    closeSync17(fd);
+    closeSync18(fd);
   }
 }
 function exclusive2(path, bytes) {
-  const fd = openSync17(path, constants15.O_CREAT | constants15.O_EXCL | constants15.O_WRONLY | constants15.O_NOFOLLOW, 384);
+  const fd = openSync18(path, constants16.O_CREAT | constants16.O_EXCL | constants16.O_WRONLY | constants16.O_NOFOLLOW, 384);
   try {
     writeFileSync12(fd, bytes);
     fsyncSync7(fd);
   } finally {
-    closeSync17(fd);
+    closeSync18(fd);
   }
   syncDirectory2(dirname23(path));
 }
-async function planNativeSafetyRegistration(options, dependencies = {}) {
+async function planRegistration(options, dependencies = {}) {
   const selected = { ...options }, before = inspect2(selected);
   try {
-    await (dependencies.verify ?? verifyNativeSafetyCommand)(before.preview.command, before.home);
+    if (selected.readiness)
+      need9(nativeReadinessCommandVerified(before.preview.command), "guard_failed");
+    else
+      await (dependencies.verify ?? verifyNativeSafetyCommand)(before.preview.command, before.home);
   } catch {
     throw new NativeRegistrationError("guard_failed");
   }
   need9(inspect2(selected).plan.planDigest === before.plan.planDigest, "settings_changed");
   return before.plan;
 }
-async function applyNativeSafetyRegistration(options, dependencies = {}) {
+async function applyRegistration(options, dependencies = {}) {
   const selected = { ...options };
   need9(/^[a-f0-9]{64}$/.test(selected.expectedPlanDigest), "input_invalid");
-  const plan = await planNativeSafetyRegistration(selected, dependencies);
+  const plan = await planRegistration(selected, dependencies);
   need9(plan.planDigest === selected.expectedPlanDigest, "settings_changed");
   const before = inspect2(selected);
   need9(before.plan.planDigest === plan.planDigest, "settings_changed");
@@ -41946,8 +42161,8 @@ async function applyNativeSafetyRegistration(options, dependencies = {}) {
     return { ok: true, changed: false, ...plan };
   const operationId = randomUUID5();
   let directory2 = before.home;
-  for (const part of [".hasna", "hooks", "native", "trash-registration", operationId]) {
-    directory2 = join29(directory2, part);
+  for (const part of [".hasna", "hooks", "native", selected.readiness ? "trash-readiness-registration" : "trash-registration", operationId]) {
+    directory2 = join27(directory2, part);
     try {
       mkdirSync14(directory2, { mode: 448 });
       syncDirectory2(dirname23(directory2));
@@ -41958,12 +42173,12 @@ async function applyNativeSafetyRegistration(options, dependencies = {}) {
     safeDirectory3(directory2);
   }
   if (before.before.raw !== null)
-    exclusive2(join29(directory2, "settings.before"), before.before.raw);
-  exclusive2(join29(directory2, "intent.json"), JSON.stringify({ operationId, plan }) + `
+    exclusive2(join27(directory2, "settings.before"), before.before.raw);
+  exclusive2(join27(directory2, "intent.json"), JSON.stringify({ operationId, plan }) + `
 `);
   try {
     need9(inspect2(selected).plan.planDigest === plan.planDigest, "settings_changed");
-    const result = installHook("trash-guard", { target: selected.target, overwrite: true, expectedSettingsSha256: plan.beforeSHA256 });
+    const result = selected.readiness ? installNativeReadinessRegistration(selected.target, plan.beforeSHA256) : installHook("trash-guard", { target: selected.target, overwrite: true, expectedSettingsSha256: plan.beforeSHA256 });
     need9(result.success, "apply_outcome_uncertain");
     const after = inspect2(selected);
     need9(after.before.sha256 === plan.desiredSHA256 && after.plan.resolvedPath === plan.resolvedPath && after.plan.action === "unchanged" && after.plan.commandSHA256 === plan.commandSHA256, "apply_outcome_uncertain");
@@ -41973,16 +42188,19 @@ async function applyNativeSafetyRegistration(options, dependencies = {}) {
       operationId,
       planDigest: plan.planDigest,
       settingsSHA256: after.before.sha256,
-      guardVerified: true,
+      guardVerified: !selected.readiness,
+      ...selected.readiness ? { readinessRunnerVerified: true } : {},
       nativeAdoptionVerified: false
     };
-    exclusive2(join29(directory2, "receipt.json"), JSON.stringify(receipt) + `
+    exclusive2(join27(directory2, "receipt.json"), JSON.stringify(receipt) + `
 `);
     return receipt;
   } catch {
     throw new NativeRegistrationError("apply_outcome_uncertain", operationId);
   }
 }
+var planNativeSafetyRegistration = (options, dependencies = {}) => planRegistration({ target: options.target }, dependencies);
+var applyNativeSafetyRegistration = (options, dependencies = {}) => applyRegistration({ target: options.target, expectedPlanDigest: options.expectedPlanDigest }, dependencies);
 
 // src/index.ts
 function installHookForProject(name, options = {}) {
@@ -42005,11 +42223,11 @@ async function runHook(name, input2, options = {}) {
     throw new Error(`Hook '${name}' not found`);
   const hookScript = getHookPath(name) + "/src/hook.ts";
   const resolvedScript = custom3?.scriptPath;
-  const script = resolvedScript ?? (existsSync15(hookScript) ? hookScript : undefined);
+  const script = resolvedScript ?? (existsSync16(hookScript) ? hookScript : undefined);
   if (!script)
     throw new Error(`Hook script not found: ${name}`);
   const { sha256Of: sha256Of2, checkScriptHash: checkScriptHash2 } = await Promise.resolve().then(() => (init_store(), exports_store));
-  const content = readFileSync26(script);
+  const content = readFileSync25(script);
   const check2 = checkScriptHash2(name, sha256Of2(content));
   if (!check2.ok) {
     throw new Error(`Hook '${name}' script changed since it was trusted (sha256 ${check2.expected} != ${check2.actual}). Run 'hooks trust ${name}' to trust the new content.`);