@hasna/hooks 0.10.9 → 0.11.0

package/bin/hooks-mcp.js

@@ -1130,9 +1130,9 @@ var init_migrations = __esm(() => {
 });
 
 // src/db/legacy-import.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir4 } from "os";
 function ensureMetaTable(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS _meta (
@@ -1155,7 +1155,7 @@ function nanoid() {
 function importJsonlFile(db, filePath) {
   let count = 0;
   try {
-    const lines = readFileSync3(filePath, "utf-8").split(`
+    const lines = readFileSync4(filePath, "utf-8").split(`
 `).filter(Boolean);
     for (const line of lines) {
       try {
@@ -1181,7 +1181,7 @@ function importJsonlFile(db, filePath) {
 function importErrorsLog(db, filePath) {
   let count = 0;
   try {
-    const lines = readFileSync3(filePath, "utf-8").split(`
+    const lines = readFileSync4(filePath, "utf-8").split(`
 `).filter(Boolean);
     const linePattern = /^\[(.+?)\]\s+(?:\[session:(\S+)\]\s+)?(.+?)\s+\u2014\s+(.+)$/;
     for (const line of lines) {
@@ -1206,25 +1206,25 @@ function importErrorsLog(db, filePath) {
   } catch {}
   return count;
 }
-function runLegacyImport(db, homeDir = homedir3()) {
+function runLegacyImport(db, homeDir = homedir4()) {
   try {
     if (isAlreadyDone(db))
       return;
     let total = 0;
-    const claudeProjectsDir = join6(homeDir, ".claude", "projects");
-    if (existsSync5(claudeProjectsDir)) {
+    const claudeProjectsDir = join7(homeDir, ".claude", "projects");
+    if (existsSync6(claudeProjectsDir)) {
       try {
         const projectDirs = readdirSync2(claudeProjectsDir);
         for (const dir of projectDirs) {
-          const projectDir = join6(claudeProjectsDir, dir);
+          const projectDir = join7(claudeProjectsDir, dir);
           try {
             const files = readdirSync2(projectDir);
             for (const file of files) {
               if (file.match(/^session-log-\d{4}-\d{2}-\d{2}\.jsonl$/)) {
-                total += importJsonlFile(db, join6(projectDir, file));
+                total += importJsonlFile(db, join7(projectDir, file));
               }
               if (file === "errors.log") {
-                total += importErrorsLog(db, join6(projectDir, file));
+                total += importErrorsLog(db, join7(projectDir, file));
               }
             }
           } catch {}
@@ -1271,8 +1271,8 @@ __export(exports_db, {
   allowLocalStore: () => allowLocalStore
 });
 import { Database } from "bun:sqlite";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, cpSync } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, cpSync } from "fs";
+import { join as join8 } from "path";
 function refuseLocalStore(message) {
   localStoreRefusal = message;
 }
@@ -1287,8 +1287,8 @@ function localStoreRefusalMessage() {
 }
 function resolveDataDir() {
   const effective = getEffectiveDataRoot();
-  const oldDir = join7(getHomeDir(), ".hooks");
-  if (!existsSync6(effective) && existsSync6(oldDir)) {
+  const oldDir = join8(getHomeDir(), ".hooks");
+  if (!existsSync7(effective) && existsSync7(oldDir)) {
     mkdirSync2(effective, { recursive: true });
     cpSync(oldDir, effective, { recursive: true });
   }
@@ -1299,11 +1299,11 @@ function getDbPath() {
   if (explicitDb)
     return explicitDb;
   const dataDir2 = resolveDataDir();
-  return join7(dataDir2, "hooks.db");
+  return join8(dataDir2, "hooks.db");
 }
 function ensureDir(dbPath) {
   const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
-  if (dir && !existsSync6(dir)) {
+  if (dir && !existsSync7(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
 }
@@ -1313,7 +1313,7 @@ function getDb() {
   if (instance)
     return instance;
   const dbPath = getDbPath();
-  const isNew = dbPath === ":memory:" || !existsSync6(dbPath);
+  const isNew = dbPath === ":memory:" || !existsSync7(dbPath);
   ensureDir(dbPath);
   instance = new Database(dbPath);
   instance.exec("PRAGMA busy_timeout=5000");
@@ -1495,9 +1495,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;
       }
@@ -2230,11 +2230,11 @@ var init_local_opt_in = __esm(() => {
 
 // src/lib/hook-env.ts
 import { dirname as dirname11, isAbsolute as isAbsolute15 } from "path";
-import { existsSync as existsSync12, realpathSync as realpathSync7, statSync } from "fs";
+import { existsSync as existsSync13, realpathSync as realpathSync7, statSync } from "fs";
 import { tmpdir } 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;
@@ -2243,7 +2243,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_");
@@ -2278,7 +2278,7 @@ function isUnsafePathEntry(entry, home) {
 }
 function sanitizeHookPath(pathValue, home) {
   const baseline = PATH_BASELINE.slice();
-  if (process.platform === "darwin" && existsSync12("/opt/homebrew/bin"))
+  if (process.platform === "darwin" && existsSync13("/opt/homebrew/bin"))
     baseline.push("/opt/homebrew/bin");
   const bunDir = dirname11(process.execPath);
   const seen = new Set;
@@ -2405,7 +2405,7 @@ __export(exports_run, {
 });
 import { randomBytes as randomBytes2 } from "crypto";
 import { rmSync as rmSync2, writeFileSync as writeFileSync10 } from "fs";
-import { basename as basename5, dirname as dirname17, isAbsolute as isAbsolute17, join as join13 } from "path";
+import { basename as basename5, dirname as dirname17, isAbsolute as isAbsolute17, join as join12 } from "path";
 function extensionOf(scriptPath) {
   const base = basename5(scriptPath);
   const dot = base.lastIndexOf(".");
@@ -2476,7 +2476,7 @@ async function readPipeWithDeadline(stream, deadlineMs) {
 async function executeVerifiedScript(options) {
   const scriptDir = dirname17(options.scriptPath);
   const interpreter = interpreterFor(options.name, options.scriptPath, options.content);
-  const tempPath = join13(scriptDir, `.hooks-verified-${randomBytes2(12).toString("hex")}.${interpreter.tempExt}`);
+  const tempPath = join12(scriptDir, `.hooks-verified-${randomBytes2(12).toString("hex")}.${interpreter.tempExt}`);
   let proc = null;
   let timedOut = false;
   const timeoutTimer = options.timeout ? setTimeout(() => {
@@ -2684,17 +2684,17 @@ import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z3 } from "zod";
 init_registry();
-import { existsSync as existsSync13, readFileSync as readFileSync12 } from "fs";
-import { join as join17, dirname as dirname19 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync9 } from "fs";
+import { join as join13, dirname as dirname19 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/installer.ts
 init_registry();
 init_resolve();
 init_manifest();
-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/native-safety.ts
@@ -2831,6 +2831,159 @@ function installedNativeSafetyCommand(name) {
   return buildNativeSafetyCommand({ name, runtime, runtimeSHA256: pinEligibleFile(runtime, 200000000, true), worker: canonicalWorker, workerSHA256: pinEligibleFile(canonicalWorker, 256000), home, path: `${dirname3(runtime)}:${join5(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 existsSync5, fstatSync as fstatSync2, lstatSync as lstatSync2, openSync as openSync2, readFileSync as readFileSync3, realpathSync as realpathSync3 } from "fs";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join6 } from "path";
+import { homedir as homedir3 } 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 = readFileSync3(fd);
+    if (bytes.length > maximum)
+      throw new Error("Readiness runner is too large");
+    return createHash2("sha256").update(bytes).digest("hex");
+  } finally {
+    closeSync2(fd);
+  }
+}
+function installedNativeReadinessCommand(provider) {
+  const candidates = [join6(import.meta.dir, "../../bin/native-readiness-entry.js"), join6(import.meta.dir, "../bin/native-readiness-entry.js"), join6(import.meta.dir, "native-readiness-entry.js")];
+  const selected = candidates.find(existsSync5);
+  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(homedir3()), runtime, runtimeSHA256: pin(runtime, 200000000, true), worker, workerSHA256: pin(worker, 256000, false) });
+}
+
 // src/lib/registration.ts
 init_resolve();
 
@@ -2898,6 +3051,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()]);
@@ -2964,13 +3119,13 @@ function hookRegisteredInSettings(settings, name, eventSpec, hookMatcher) {
 }
 
 // src/lib/store.ts
-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";
 init_db();
 init_config();
 import { randomBytes } from "crypto";
 function sha256Of(input) {
-  return createHash2("sha256").update(input).digest("hex");
+  return createHash3("sha256").update(input).digest("hex");
 }
 function storeDb() {
   return isLocalStoreRefused() ? null : getDb();
@@ -3026,11 +3181,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'.`);
   }
@@ -3067,15 +3222,15 @@ function getPinnedHook(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,
@@ -3092,9 +3247,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
     });
   }
@@ -3102,16 +3257,16 @@ function checkScriptHash(name, actual) {
 }
 
 // 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;
@@ -3142,7 +3297,7 @@ function readCodexSettings(path) {
 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.");
   }
 }
@@ -3156,11 +3311,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.");
   }
@@ -3175,23 +3330,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";
@@ -3199,23 +3354,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";
@@ -3516,8 +3671,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": {
@@ -3561,10 +3716,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;
@@ -3576,9 +3731,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}>`;
     }
@@ -3595,11 +3750,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(`
 `);
@@ -3630,14 +3785,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;
@@ -3645,7 +3800,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;
       },
@@ -5470,10 +5625,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 = {
@@ -5884,11 +6039,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);
   }
@@ -8802,9 +8957,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 {
@@ -10089,10 +10244,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 });
@@ -10101,7 +10256,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]) {
@@ -10335,7 +10490,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");
@@ -10790,10 +10945,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) {
@@ -10804,30 +10959,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;
@@ -10836,7 +10991,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))
@@ -10854,7 +11009,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;
@@ -10862,7 +11017,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())
@@ -10872,9 +11027,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()) {
@@ -11007,10 +11162,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;
   }
 }
@@ -11038,9 +11193,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);
@@ -11055,13 +11210,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) {
@@ -11107,7 +11262,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 });
@@ -12117,7 +12272,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}`);
@@ -12126,7 +12281,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}` };
@@ -12660,10 +12815,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");
@@ -12955,9 +13110,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;
@@ -12967,7 +13122,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));
@@ -13175,10 +13330,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");
@@ -16905,11 +17060,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;
@@ -26791,8 +26946,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": {
@@ -27525,8 +27680,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};`);
@@ -28380,12 +28535,12 @@ function _includes(includes, params) {
     includes
   });
 }
-function _startsWith(prefix2, params) {
+function _startsWith(prefix3, params) {
   return new $ZodCheckStartsWith({
     check: "string_format",
     format: "starts_with",
     ...normalizeParams(params),
-    prefix: prefix2
+    prefix: prefix3
   });
 }
 function _endsWith(suffix, params) {
@@ -34353,7 +34508,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)
@@ -34364,7 +34519,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}`;
 }
@@ -34452,11 +34607,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);
@@ -34466,7 +34621,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") {
@@ -34474,7 +34629,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;
@@ -34483,14 +34638,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);
@@ -34502,21 +34657,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) + `
@@ -34615,7 +34770,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 "";
   }
@@ -34623,9 +34778,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() ? `
 
 ` : "";
@@ -34805,7 +34960,20 @@ function installHook(name, options = {}) {
   return installForTarget(name, scope, overwrite, target, profile, codewithMode, codewithConfigPath, mementos, expectedSettingsSha256);
 }
 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) => {
@@ -34822,18 +34990,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) {
@@ -34843,8 +35013,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 });
           }
         }
@@ -34964,12 +35134,12 @@ function removeHookForTarget(name, scope, target) {
 
 // src/lib/profiles.ts
 init_app_home();
-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 });
   }
@@ -34977,12 +35147,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);
@@ -35008,23 +35178,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 {}
     }
@@ -35563,9 +35733,9 @@ var __dirname3 = dirname19(fileURLToPath3(import.meta.url));
 var pkg = { name: "@hasna/hooks", version: "0.0.0" };
 try {
   for (const rel of ["../../package.json", "../package.json", "../../../package.json"]) {
-    const p = join17(__dirname3, rel);
-    if (existsSync13(p)) {
-      pkg = JSON.parse(readFileSync12(p, "utf-8"));
+    const p = join13(__dirname3, rel);
+    if (existsSync14(p)) {
+      pkg = JSON.parse(readFileSync9(p, "utf-8"));
       break;
     }
   }
@@ -35574,10 +35744,10 @@ async function runVerifiedHook(name, stdin, timeoutMs) {
   const { resolveHook: resolveHook2, resolveScriptPath: resolveScriptPath2 } = await Promise.resolve().then(() => (init_resolve(), exports_resolve));
   const resolved = resolveHook2(name);
   const hookScript = resolveScriptPath2(name);
-  if (!resolved || !hookScript || !existsSync13(hookScript)) {
+  if (!resolved || !hookScript || !existsSync14(hookScript)) {
     throw new Error(`Hook '${name}' not found`);
   }
-  const content = readFileSync12(hookScript);
+  const content = readFileSync9(hookScript);
   const sha4 = sha256Of(content);
   const check2 = checkScriptHash(name, sha4);
   if (!check2.ok) {
@@ -35783,7 +35953,7 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     const issues = [];
     const healthy = [];
-    const settingsExist = existsSync13(settingsPath);
+    const settingsExist = existsSync14(settingsPath);
     if (!settingsExist) {
       issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
     }
@@ -35793,7 +35963,7 @@ function createHooksServer() {
       const meta3 = custom2 ? resolveHookMeta(name) : getHook(name);
       let hookHealthy = true;
       if (custom2) {
-        if (!existsSync13(custom2.scriptPath)) {
+        if (!existsSync14(custom2.scriptPath)) {
           issues.push({ hook: name, issue: `Custom hook script missing: ${custom2.scriptPath}`, severity: "error" });
           hookHealthy = false;
         }
@@ -35803,14 +35973,14 @@ function createHooksServer() {
           continue;
         }
         const hookDir = getHookPath(name);
-        if (!existsSync13(join17(hookDir, "src", "hook.ts"))) {
+        if (!existsSync14(join13(hookDir, "src", "hook.ts"))) {
           issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
           hookHealthy = false;
         }
       }
       if (meta3 && settingsExist) {
         try {
-          const settings = JSON.parse(readFileSync12(settingsPath, "utf-8"));
+          const settings = JSON.parse(readFileSync9(settingsPath, "utf-8"));
           if (!hookRegisteredInSettings(settings, name, meta3.event, meta3.matcher)) {
             const eventName = meta3.event.split(":")[0];
             issues.push({ hook: name, issue: `Not registered under correct event (${eventName})`, severity: "error" });
@@ -35847,10 +36017,10 @@ function createHooksServer() {
         return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
       }
       const hookPath = getHookPath(name);
-      const readmePath = join17(hookPath, "README.md");
+      const readmePath = join13(hookPath, "README.md");
       let readme = "";
-      if (existsSync13(readmePath)) {
-        readme = readFileSync12(readmePath, "utf-8");
+      if (existsSync14(readmePath)) {
+        readme = readFileSync9(readmePath, "utf-8");
       }
       if (verbose) {
         return { content: [{ type: "text", text: JSON.stringify({ ...meta3, readme }) }] };
@@ -36033,7 +36203,7 @@ function createHooksServer() {
     const ctx = {
       scope,
       settings_path: settingsPath,
-      settings_exists: existsSync13(settingsPath),
+      settings_exists: existsSync14(settingsPath),
       registered_hooks: hooks,
       hook_count: hooks.length,
       healthy,
@@ -36179,8 +36349,8 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     let settings = {};
     try {
-      if (existsSync13(settingsPath))
-        settings = JSON.parse(readFileSync12(settingsPath, "utf-8"));
+      if (existsSync14(settingsPath))
+        settings = JSON.parse(readFileSync9(settingsPath, "utf-8"));
     } catch {}
     if (!settings.hooks)
       settings.hooks = {};
@@ -36202,8 +36372,8 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     let settings = {};
     try {
-      if (existsSync13(settingsPath))
-        settings = JSON.parse(readFileSync12(settingsPath, "utf-8"));
+      if (existsSync14(settingsPath))
+        settings = JSON.parse(readFileSync9(settingsPath, "utf-8"));
     } catch {}
     if (settings.hooks?.__disabled) {
       settings.hooks.__disabled = settings.hooks.__disabled.filter((n) => n !== name);