@hasna/hooks 0.10.3 → 0.10.5

package/bin/index.js

@@ -4519,6 +4519,9 @@ function buildNativeSafetyCommand(binding) {
   return prefix + [encoded, binding.runtime, binding.home, binding.path].map(quote).join(" ");
 }
 function nativeSafetyRegistration(command) {
+  return nativeSafetyCommandBinding(command)?.name;
+}
+function nativeSafetyCommandBinding(command) {
   if (!command.startsWith(prefix))
     return;
   const encoded = command.slice(prefix.length).match(/^'([A-Za-z0-9_-]+)' /)?.[1];
@@ -4526,7 +4529,7 @@ function nativeSafetyRegistration(command) {
     return;
   try {
     const binding = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
-    return buildNativeSafetyCommand(binding) === command ? binding.name : undefined;
+    return buildNativeSafetyCommand(binding) === command ? binding : undefined;
   } catch {
     return;
   }
@@ -37385,25 +37388,25 @@ var init_redact = __esm(() => {
 });
 
 // src/lib/profiles.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync8, readdirSync as readdirSync8, rmSync, cpSync as cpSync2 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync10, readdirSync as readdirSync8, rmSync, cpSync as cpSync2 } from "fs";
+import { join as join19 } from "path";
 function getProfilesDir() {
-  const newDir = join13(getEffectiveDataRoot(), "profiles");
-  const oldDir = join13(getHomeDir(), ".hooks", "profiles");
-  if (!existsSync14(newDir) && existsSync14(oldDir)) {
-    mkdirSync9(newDir, { recursive: true });
+  const newDir = join19(getEffectiveDataRoot(), "profiles");
+  const oldDir = join19(getHomeDir(), ".hooks", "profiles");
+  if (!existsSync15(newDir) && existsSync15(oldDir)) {
+    mkdirSync11(newDir, { recursive: true });
     cpSync2(oldDir, newDir, { recursive: true });
   }
   return newDir;
 }
 function ensureProfilesDir() {
   const dir = getProfilesDir();
-  if (!existsSync14(dir)) {
-    mkdirSync9(dir, { recursive: true });
+  if (!existsSync15(dir)) {
+    mkdirSync11(dir, { recursive: true });
   }
 }
 function profilePath(id) {
-  return join13(getProfilesDir(), `${id}.json`);
+  return join19(getProfilesDir(), `${id}.json`);
 }
 function shortUuid() {
   return crypto.randomUUID().slice(0, 8);
@@ -37422,30 +37425,30 @@ function createProfile(input2) {
   if (input2.name) {
     profile.name = input2.name;
   }
-  writeFileSync8(profilePath(id), JSON.stringify(profile, null, 2) + `
+  writeFileSync10(profilePath(id), JSON.stringify(profile, null, 2) + `
 `);
   return profile;
 }
 function getProfile(id) {
   const path = profilePath(id);
   try {
-    if (!existsSync14(path))
+    if (!existsSync15(path))
       return null;
-    return JSON.parse(readFileSync9(path, "utf-8"));
+    return JSON.parse(readFileSync14(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function listProfiles() {
   const dir = getProfilesDir();
-  if (!existsSync14(dir))
+  if (!existsSync15(dir))
     return [];
   try {
     const files = readdirSync8(dir).filter((f) => f.endsWith(".json"));
     const profiles = [];
     for (const file2 of files) {
       try {
-        const content = readFileSync9(join13(dir, file2), "utf-8");
+        const content = readFileSync14(join19(dir, file2), "utf-8");
         profiles.push(JSON.parse(content));
       } catch {}
     }
@@ -37459,7 +37462,7 @@ function touchProfile(id) {
   if (!profile)
     return;
   profile.last_seen_at = new Date().toISOString();
-  writeFileSync8(profilePath(id), JSON.stringify(profile, null, 2) + `
+  writeFileSync10(profilePath(id), JSON.stringify(profile, null, 2) + `
 `);
 }
 function exportProfiles() {
@@ -37475,11 +37478,11 @@ function importProfiles(profiles) {
       continue;
     }
     const path = profilePath(profile.agent_id);
-    if (existsSync14(path)) {
+    if (existsSync15(path)) {
       skipped++;
       continue;
     }
-    writeFileSync8(path, JSON.stringify(profile, null, 2) + `
+    writeFileSync10(path, JSON.stringify(profile, null, 2) + `
 `);
     imported++;
   }
@@ -37491,16 +37494,16 @@ var init_profiles = __esm(() => {
 
 // ../../node_modules/.bun/@hasna+contracts@1.2.2+944b86d8024e79fa/node_modules/@hasna/contracts/dist/client/transport.js
 import { isIP as isIP2 } from "net";
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 import { closeSync as closeSync22, fstatSync as fstatSync22, openSync as openSync22, readFileSync as readFileSync22 } from "fs";
 import { O_NOFOLLOW as O_NOFOLLOW2, O_NONBLOCK as O_NONBLOCK2, O_RDONLY as O_RDONLY2 } from "constants";
 import { hostname as osHostname } from "os";
-import { isAbsolute as isAbsolute7, join as join22 } from "path";
+import { isAbsolute as isAbsolute17, join as join22 } from "path";
 import { createRequire as createRequire3 } 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 closeSync6, fstatSync as fstatSync5, lstatSync as lstatSync10, openSync as openSync6, readFileSync as readFileSync15, realpathSync as realpathSync9, statSync as statSync2 } from "fs";
 import { O_NOFOLLOW, O_NONBLOCK, O_RDONLY } from "constants";
-import { basename as basename5, dirname as dirname11, join as join17, relative, sep as sep3 } from "path";
+import { basename as basename5, dirname as dirname19, join as join20, relative, sep as sep3 } from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 function envToken2(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -37574,16 +37577,16 @@ function o(e2, r2, t2) {
   }
 }
 function entryPoint(directory2) {
-  const root = realpathSync7(directory2);
-  const fd = openSync4(join17(root, "package.json"), O_RDONLY | O_NOFOLLOW | O_NONBLOCK);
+  const root = realpathSync9(directory2);
+  const fd = openSync6(join20(root, "package.json"), O_RDONLY | O_NOFOLLOW | O_NONBLOCK);
   let pkg;
   try {
-    const stat2 = fstatSync3(fd);
+    const stat2 = fstatSync5(fd);
     if (!stat2.isFile() || stat2.size > MAX_PACKAGE_BYTES3)
       throw new Error("Invalid Secrets package metadata");
-    pkg = JSON.parse(readFileSync12(fd, "utf8"));
+    pkg = JSON.parse(readFileSync15(fd, "utf8"));
   } finally {
-    closeSync4(fd);
+    closeSync6(fd);
   }
   if (!pkg || typeof pkg !== "object" || !("name" in pkg) || pkg.name !== PACKAGE) {
     throw new Error("Invalid Secrets package identity");
@@ -37595,21 +37598,21 @@ 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(join17(root, ...parts));
+  const file2 = realpathSync9(join20(root, ...parts));
   const within = relative(root, file2);
-  if (!within || within === ".." || within.startsWith(`..${sep3}`) || !statSync(file2).isFile()) {
+  if (!within || within === ".." || within.startsWith(`..${sep3}`) || !statSync2(file2).isFile()) {
     throw new Error("Secrets import export escapes its package or is not a file");
   }
   return pathToFileURL(file2).href;
 }
 function resolveInstalledSecrets(parentUrl) {
-  let directory2 = dirname11(fileURLToPath3(parentUrl));
+  let directory2 = dirname19(fileURLToPath3(parentUrl));
   for (;; ) {
     if (basename5(directory2) !== "node_modules") {
-      const candidate = join17(directory2, "node_modules", PACKAGE);
+      const candidate = join20(directory2, "node_modules", PACKAGE);
       let absent = false;
       try {
-        lstatSync7(candidate);
+        lstatSync10(candidate);
       } catch (error61) {
         if (error61.code !== "ENOENT")
           throw error61;
@@ -37618,7 +37621,7 @@ function resolveInstalledSecrets(parentUrl) {
       if (!absent)
         return entryPoint(candidate);
     }
-    const parent = dirname11(directory2);
+    const parent = dirname19(directory2);
     if (parent === directory2)
       throw new Error("Secrets SDK is not installed for this consumer");
     directory2 = parent;
@@ -37630,7 +37633,7 @@ function homeDir(env) {
 }
 function absoluteOverride(env, key) {
   const value = env[key]?.trim();
-  return value && isAbsolute7(value) ? value : null;
+  return value && isAbsolute17(value) ? value : null;
 }
 function hasnaHomeDir(env) {
   const override = absoluteOverride(env, HASNA_HOME_ENV_KEY);
@@ -37858,7 +37861,7 @@ function isAmbientEnvironment(env) {
   return env === process.env || env[AMBIENT_ENVIRONMENT3] === true;
 }
 function defaultKeychainRunner(argv) {
-  const result = spawnSync(KEYCHAIN_SECURITY_BIN, [...argv], {
+  const result = spawnSync2(KEYCHAIN_SECURITY_BIN, [...argv], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: KEYCHAIN_SPAWN_TIMEOUT_MS
@@ -38737,8 +38740,8 @@ var init_db_writer = __esm(() => {
 });
 
 // src/lib/hook-env.ts
-import { dirname as dirname17, isAbsolute as isAbsolute15 } from "path";
-import { existsSync as existsSync15, realpathSync as realpathSync8, statSync as statSync2 } from "fs";
+import { dirname as dirname20, isAbsolute as isAbsolute18 } from "path";
+import { existsSync as existsSync16, realpathSync as realpathSync10, statSync as statSync4 } from "fs";
 import { tmpdir } from "os";
 function isDeniedEnvName(name) {
   const upper = name.toUpperCase();
@@ -38757,7 +38760,7 @@ function isBashFunctionEnvName(name) {
   return name.startsWith("BASH_FUNC_");
 }
 function isUnsafePathEntry(entry, home) {
-  if (entry === "" || !isAbsolute15(entry))
+  if (entry === "" || !isAbsolute18(entry))
     return true;
   if (home && (entry === home || entry.startsWith(home + "/")))
     return true;
@@ -38767,7 +38770,7 @@ function isUnsafePathEntry(entry, home) {
     return true;
   const canonical4 = (path) => {
     try {
-      return realpathSync8(path);
+      return realpathSync10(path);
     } catch {
       return path;
     }
@@ -38779,16 +38782,16 @@ function isUnsafePathEntry(entry, home) {
       return true;
   }
   try {
-    if ((statSync2(entry).mode & 2) !== 0)
+    if ((statSync4(entry).mode & 2) !== 0)
       return true;
   } catch {}
   return false;
 }
 function sanitizeHookPath(pathValue, home) {
   const baseline = PATH_BASELINE.slice();
-  if (process.platform === "darwin" && existsSync15("/opt/homebrew/bin"))
+  if (process.platform === "darwin" && existsSync16("/opt/homebrew/bin"))
     baseline.push("/opt/homebrew/bin");
-  const bunDir = dirname17(process.execPath);
+  const bunDir = dirname20(process.execPath);
   const seen = new Set;
   const out = [];
   for (const dir of baseline) {
@@ -38912,8 +38915,8 @@ __export(exports_run, {
   HookTimeoutError: () => HookTimeoutError
 });
 import { randomBytes as randomBytes2 } from "crypto";
-import { rmSync as rmSync2, writeFileSync as writeFileSync10 } from "fs";
-import { basename as basename9, dirname as dirname19, isAbsolute as isAbsolute17, join as join19 } from "path";
+import { rmSync as rmSync2, writeFileSync as writeFileSync11 } from "fs";
+import { basename as basename9, dirname as dirname21, isAbsolute as isAbsolute19, join as join24 } from "path";
 function extensionOf(scriptPath) {
   const base = basename9(scriptPath);
   const dot = base.lastIndexOf(".");
@@ -38982,9 +38985,9 @@ async function readPipeWithDeadline(stream, deadlineMs) {
   return chunks.join("");
 }
 async function executeVerifiedScript(options) {
-  const scriptDir = dirname19(options.scriptPath);
+  const scriptDir = dirname21(options.scriptPath);
   const interpreter = interpreterFor(options.name, options.scriptPath, options.content);
-  const tempPath = join19(scriptDir, `.hooks-verified-${randomBytes2(12).toString("hex")}.${interpreter.tempExt}`);
+  const tempPath = join24(scriptDir, `.hooks-verified-${randomBytes2(12).toString("hex")}.${interpreter.tempExt}`);
   let proc = null;
   let timedOut = false;
   const timeoutTimer = options.timeout ? setTimeout(() => {
@@ -38992,8 +38995,8 @@ async function executeVerifiedScript(options) {
     killGroup(proc, { leaderAlive: proc !== null && proc.exitCode === null });
   }, options.timeout) : null;
   try {
-    writeFileSync10(tempPath, options.content, { flag: "wx", mode: 384 });
-    proc = Bun.spawn([...interpreter.command, isAbsolute17(tempPath) ? tempPath : `./${tempPath}`, ...options.args ?? []], {
+    writeFileSync11(tempPath, options.content, { flag: "wx", mode: 384 });
+    proc = Bun.spawn([...interpreter.command, isAbsolute19(tempPath) ? tempPath : `./${tempPath}`, ...options.args ?? []], {
       stdin: new Response(options.stdin),
       stdout: "pipe",
       stderr: "pipe",
@@ -39075,15 +39078,15 @@ __export(exports_custom_install, {
   installCustomSource: () => installCustomSource,
   ensureCustomDir: () => ensureCustomDir
 });
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, mkdtempSync, readFileSync as readFileSync14, rmSync as rmSync4 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync12, mkdtempSync, readFileSync as readFileSync17, rmSync as rmSync4 } from "fs";
+import { join as join27 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 function manifestAt(dir) {
-  const path = join20(dir, "manifest.json");
-  if (!existsSync16(path))
+  const path = join27(dir, "manifest.json");
+  if (!existsSync17(path))
     return;
   try {
-    return parseManifest(readFileSync14(path, "utf-8"));
+    return parseManifest(readFileSync17(path, "utf-8"));
   } catch {
     return;
   }
@@ -39102,8 +39105,8 @@ function writeFromManifest(manifest, srcDir, source, kind) {
   return { name, version: manifest.version, kind, source, dir, scriptPath };
 }
 async function cloneToTemp(gitUrl) {
-  const tmp = mkdtempSync(join20(tmpdir2(), "hooks-install-"));
-  const proc = Bun.spawn(["git", "clone", "--depth", "1", "--quiet", gitUrl, join20(tmp, "repo")], {
+  const tmp = mkdtempSync(join27(tmpdir2(), "hooks-install-"));
+  const proc = Bun.spawn(["git", "clone", "--depth", "1", "--quiet", gitUrl, join27(tmp, "repo")], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -39116,7 +39119,7 @@ async function cloneToTemp(gitUrl) {
     rmSync4(tmp, { recursive: true, force: true });
     throw new Error(`git clone failed (${exitCode}): ${stderr.trim()}`);
   }
-  return join20(tmp, "repo");
+  return join27(tmp, "repo");
 }
 function isGitUrl(value) {
   return value.startsWith("git@") || value.startsWith("ssh://") || value.startsWith("file://") || value.endsWith(".git");
@@ -39126,7 +39129,7 @@ function isCustomSource(value) {
     return true;
   if (value.startsWith("http://") || value.startsWith("https://"))
     return true;
-  return existsSync16(value);
+  return existsSync17(value);
 }
 async function installCustomSource(source) {
   if (isGitUrl(source)) {
@@ -39140,11 +39143,11 @@ async function installCustomSource(source) {
   if (source.startsWith("http://") || source.startsWith("https://")) {
     return installManifestUrl(source);
   }
-  if (!existsSync16(source)) {
+  if (!existsSync17(source)) {
     throw new Error(`No such local path: ${source}`);
   }
   if (source.endsWith("manifest.json")) {
-    const manifest = parseManifest(readFileSync14(source, "utf-8"));
+    const manifest = parseManifest(readFileSync17(source, "utf-8"));
     return writeFromManifest(manifest, source.substring(0, source.lastIndexOf("/")), source, "local");
   }
   return copyManifestDir(source, source, "local");
@@ -39175,7 +39178,7 @@ async function installManifestUrl(url2) {
 }
 function ensureCustomDir() {
   const dir = getCustomHooksDir();
-  mkdirSync11(dir, { recursive: true });
+  mkdirSync12(dir, { recursive: true });
   return dir;
 }
 var init_custom_install = __esm(() => {
@@ -39193,13 +39196,13 @@ __export(exports_sync, {
   fetchPinnedHook: () => fetchPinnedHook,
   commitSyncArtifacts: () => commitSyncArtifacts
 });
-import { createHash as createHash7 } from "crypto";
-import { readFileSync as readFileSync15 } from "fs";
+import { createHash as createHash12 } from "crypto";
+import { readFileSync as readFileSync19 } from "fs";
 function sha256OfText(text3) {
-  return createHash7("sha256").update(text3).digest("hex");
+  return createHash12("sha256").update(text3).digest("hex");
 }
 function sha256OfPath(path) {
-  return createHash7("sha256").update(readFileSync15(path)).digest("hex");
+  return createHash12("sha256").update(readFileSync19(path)).digest("hex");
 }
 function collectBundledCatalog() {
   const out = [];
@@ -40354,13 +40357,13 @@ __export(exports_serve, {
   SERVE_HOST: () => SERVE_HOST,
   DEFAULT_SERVE_PORT: () => DEFAULT_SERVE_PORT
 });
-import { readFileSync as readFileSync17 } from "fs";
-import { dirname as dirname20, join as join24 } from "path";
+import { readFileSync as readFileSync20 } from "fs";
+import { dirname as dirname22, join as join29 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function packageVersion() {
   try {
-    const pkgPath = join24(dirname20(fileURLToPath4(import.meta.url)), "..", "package.json");
-    return JSON.parse(readFileSync17(pkgPath, "utf-8")).version || "0.0.0";
+    const pkgPath = join29(dirname22(fileURLToPath4(import.meta.url)), "..", "package.json");
+    return JSON.parse(readFileSync20(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -40660,17 +40663,17 @@ import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z3 } from "zod";
 import { createServer } from "http";
-import { existsSync as existsSync17, readFileSync as readFileSync19 } from "fs";
-import { join as join27, dirname as dirname21 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync21 } from "fs";
+import { join as join30, dirname as dirname23 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 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 || !existsSync17(hookScript)) {
+  if (!resolved || !hookScript || !existsSync18(hookScript)) {
     throw new Error(`Hook '${name}' not found`);
   }
-  const content = readFileSync19(hookScript);
+  const content = readFileSync21(hookScript);
   const sha4 = sha256Of(content);
   const check2 = checkScriptHash(name, sha4);
   if (!check2.ok) {
@@ -40875,7 +40878,7 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     const issues = [];
     const healthy = [];
-    const settingsExist = existsSync17(settingsPath);
+    const settingsExist = existsSync18(settingsPath);
     if (!settingsExist) {
       issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
     }
@@ -40885,7 +40888,7 @@ function createHooksServer() {
       const meta3 = custom2 ? resolveHookMeta(name) : getHook(name);
       let hookHealthy = true;
       if (custom2) {
-        if (!existsSync17(custom2.scriptPath)) {
+        if (!existsSync18(custom2.scriptPath)) {
           issues.push({ hook: name, issue: `Custom hook script missing: ${custom2.scriptPath}`, severity: "error" });
           hookHealthy = false;
         }
@@ -40895,14 +40898,14 @@ function createHooksServer() {
           continue;
         }
         const hookDir = getHookPath(name);
-        if (!existsSync17(join27(hookDir, "src", "hook.ts"))) {
+        if (!existsSync18(join30(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(readFileSync19(settingsPath, "utf-8"));
+          const settings = JSON.parse(readFileSync21(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" });
@@ -40939,10 +40942,10 @@ function createHooksServer() {
         return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
       }
       const hookPath = getHookPath(name);
-      const readmePath = join27(hookPath, "README.md");
+      const readmePath = join30(hookPath, "README.md");
       let readme = "";
-      if (existsSync17(readmePath)) {
-        readme = readFileSync19(readmePath, "utf-8");
+      if (existsSync18(readmePath)) {
+        readme = readFileSync21(readmePath, "utf-8");
       }
       if (verbose) {
         return { content: [{ type: "text", text: JSON.stringify({ ...meta3, readme }) }] };
@@ -41125,7 +41128,7 @@ function createHooksServer() {
     const ctx = {
       scope,
       settings_path: settingsPath,
-      settings_exists: existsSync17(settingsPath),
+      settings_exists: existsSync18(settingsPath),
       registered_hooks: hooks,
       hook_count: hooks.length,
       healthy,
@@ -41271,8 +41274,8 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     let settings = {};
     try {
-      if (existsSync17(settingsPath))
-        settings = JSON.parse(readFileSync19(settingsPath, "utf-8"));
+      if (existsSync18(settingsPath))
+        settings = JSON.parse(readFileSync21(settingsPath, "utf-8"));
     } catch {}
     if (!settings.hooks)
       settings.hooks = {};
@@ -41294,8 +41297,8 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     let settings = {};
     try {
-      if (existsSync17(settingsPath))
-        settings = JSON.parse(readFileSync19(settingsPath, "utf-8"));
+      if (existsSync18(settingsPath))
+        settings = JSON.parse(readFileSync21(settingsPath, "utf-8"));
     } catch {}
     if (settings.hooks?.__disabled) {
       settings.hooks.__disabled = settings.hooks.__disabled.filter((n2) => n2 !== name);
@@ -41665,13 +41668,13 @@ var init_server = __esm(() => {
   init_redact();
   init_authority();
   init_storage();
-  __dirname3 = dirname21(fileURLToPath5(import.meta.url));
+  __dirname3 = dirname23(fileURLToPath5(import.meta.url));
   pkg = { name: "@hasna/hooks", version: "0.0.0" };
   try {
     for (const rel of ["../../package.json", "../package.json", "../../../package.json"]) {
-      const p = join27(__dirname3, rel);
-      if (existsSync17(p)) {
-        pkg = JSON.parse(readFileSync19(p, "utf-8"));
+      const p = join30(__dirname3, rel);
+      if (existsSync18(p)) {
+        pkg = JSON.parse(readFileSync21(p, "utf-8"));
         break;
       }
     }
@@ -43413,8 +43416,8 @@ var {
 
 // src/cli/index.tsx
 import chalk2 from "chalk";
-import { existsSync as existsSync18, readFileSync as readFileSync20, rmSync as rmSync6 } from "fs";
-import { join as join29, dirname as dirname22 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync23, rmSync as rmSync6 } from "fs";
+import { join as join31, dirname as dirname24 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 
 // src/cli/components/App.tsx
@@ -44588,6 +44591,439 @@ function App({ initialHooks, overwrite = false }) {
 
 // src/cli/index.tsx
 init_native_safety();
+
+// src/native-safety.ts
+init_native_safety();
+import { execFile } from "child_process";
+import { createHash as createHash7, randomUUID as randomUUID5 } from "crypto";
+import { closeSync as closeSync4, constants as constants3, existsSync as existsSync14, fstatSync as fstatSync3, fsyncSync, linkSync as linkSync3, lstatSync as lstatSync7, mkdirSync as mkdirSync9, openSync as openSync4, readFileSync as readFileSync9, realpathSync as realpathSync7, renameSync as renameSync3, unlinkSync as unlinkSync5, writeFileSync as writeFileSync8 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname11, isAbsolute as isAbsolute7, join as join13, resolve as resolve15 } from "path";
+
+class NativeSafetyError extends Error {
+  code;
+  reason;
+  constructor(code2, reason) {
+    super(`Native deletion safety refused (${code2}). Run the reviewed Hooks safety setup before using shell or patch tools.`);
+    this.code = code2;
+    this.reason = reason;
+    this.name = "NativeSafetyError";
+  }
+}
+var executionSchema = "hasna.hooks.execution.v1";
+var hash = (value) => createHash7("sha256").update(value).digest("hex");
+var filename = "sumi-trash-guard.json";
+var owner2 = (uid2) => uid2 === 0 || uid2 === process.getuid?.();
+function safeDirectory(path) {
+  for (let cursor = path;; cursor = dirname11(cursor)) {
+    const stat2 = lstatSync7(cursor);
+    if (!stat2.isDirectory() || !owner2(stat2.uid) || stat2.mode & 18)
+      throw new NativeSafetyError("binding_invalid");
+    if (dirname11(cursor) === cursor)
+      return;
+  }
+}
+function canonicalHome(home) {
+  if (!isAbsolute7(home) || home.includes("\x00") || realpathSync7(home) !== resolve15(home))
+    throw new NativeSafetyError("binding_invalid");
+  safeDirectory(home);
+  return resolve15(home);
+}
+function readOwned(path) {
+  safeDirectory(dirname11(path));
+  const fd = openSync4(path, constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK);
+  try {
+    const stat2 = fstatSync3(fd);
+    if (!stat2.isFile() || !owner2(stat2.uid) || stat2.mode & 63 || stat2.size > 32768)
+      throw new NativeSafetyError("binding_invalid");
+    const value = readFileSync9(fd, "utf8");
+    if (Buffer.byteLength(value) > 32768)
+      throw new NativeSafetyError("binding_invalid");
+    return value;
+  } finally {
+    closeSync4(fd);
+  }
+}
+function parseRecord(text3, home) {
+  const record3 = JSON.parse(text3);
+  if (!record3 || Array.isArray(record3) || Object.keys(record3).sort().join() !== "command,harness,schema" || record3.schema !== "hasna.hooks.native-safety.v1" || record3.harness !== "sumi" || typeof record3.command !== "string")
+    throw new NativeSafetyError("binding_invalid");
+  const binding = nativeSafetyCommandBinding(record3.command);
+  if (binding?.name !== "trash-guard" || binding.home !== home)
+    throw new NativeSafetyError("binding_invalid");
+  return record3;
+}
+function syncDirectory(path) {
+  const fd = openSync4(path, constants3.O_RDONLY | constants3.O_DIRECTORY | constants3.O_NOFOLLOW);
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync4(fd);
+  }
+}
+function readNativeSafetyRegistration(home = homedir7()) {
+  try {
+    home = canonicalHome(home);
+    const path = join13(home, ".hasna/hooks/native", filename), text3 = readOwned(path);
+    return { record: parseRecord(text3, home), sha256: hash(text3), path };
+  } catch (error61) {
+    if (error61 instanceof NativeSafetyError)
+      throw error61;
+    throw new NativeSafetyError(error61?.code === "ENOENT" ? "binding_missing" : "binding_invalid");
+  }
+}
+function registerNativeSafety(options = {}) {
+  const home = canonicalHome(options.home ?? homedir7());
+  const record3 = { schema: "hasna.hooks.native-safety.v1", harness: "sumi", command: options.command ?? installedNativeSafetyCommand("trash-guard") };
+  const text3 = JSON.stringify(record3) + `
+`;
+  parseRecord(text3, home);
+  for (const dir of [join13(home, ".hasna"), join13(home, ".hasna/hooks"), join13(home, ".hasna/hooks/native")]) {
+    try {
+      mkdirSync9(dir, { mode: 448 });
+      syncDirectory(dirname11(dir));
+    } catch (error61) {
+      if (error61.code !== "EEXIST")
+        throw error61;
+    }
+    safeDirectory(dir);
+  }
+  const directory2 = join13(home, ".hasna/hooks/native"), path = join13(directory2, filename), lock = path + ".lock";
+  let lockFD;
+  try {
+    lockFD = openSync4(lock, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
+  } catch {
+    throw new NativeSafetyError("binding_busy");
+  }
+  const lockIdentity = fstatSync3(lockFD);
+  let temporaryIdentity;
+  const temporary = join13(directory2, `.${filename}.${randomUUID5()}`);
+  try {
+    writeFileSync8(lockFD, JSON.stringify({ pid: process.pid, expectedSHA256: options.expectedSHA256 ?? "absent" }));
+    fsyncSync(lockFD);
+    syncDirectory(directory2);
+    let before;
+    try {
+      before = readNativeSafetyRegistration(home);
+    } catch (error61) {
+      if (!(error61 instanceof NativeSafetyError) || error61.code !== "binding_missing")
+        throw error61;
+    }
+    if (before?.sha256 === hash(text3))
+      return { ok: true, changed: false, path, sha256: before.sha256 };
+    if (before ? options.expectedSHA256 !== before.sha256 : options.expectedSHA256 !== undefined && options.expectedSHA256 !== "absent")
+      throw new NativeSafetyError("binding_changed");
+    if (before) {
+      const backup = path + ".before-" + before.sha256;
+      if (existsSync14(backup)) {
+        if (hash(readOwned(backup)) !== before.sha256)
+          throw new NativeSafetyError("binding_changed");
+      } else {
+        const original = readOwned(path);
+        if (hash(original) !== before.sha256)
+          throw new NativeSafetyError("binding_changed");
+        const fd2 = openSync4(backup, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
+        try {
+          writeFileSync8(fd2, original);
+          fsyncSync(fd2);
+        } finally {
+          closeSync4(fd2);
+        }
+        syncDirectory(directory2);
+      }
+    }
+    const fd = openSync4(temporary, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
+    try {
+      temporaryIdentity = fstatSync3(fd);
+      writeFileSync8(fd, text3);
+      fsyncSync(fd);
+    } finally {
+      closeSync4(fd);
+    }
+    if (before) {
+      if (hash(readOwned(path)) !== before.sha256)
+        throw new NativeSafetyError("binding_changed");
+      renameSync3(temporary, path);
+    } else {
+      linkSync3(temporary, path);
+      unlinkSync5(temporary);
+    }
+    syncDirectory(directory2);
+    const after = readNativeSafetyRegistration(home);
+    if (after.sha256 !== hash(text3))
+      throw new NativeSafetyError("binding_changed");
+    return { ok: true, changed: true, path, sha256: after.sha256 };
+  } finally {
+    closeSync4(lockFD);
+    const currentTemporary = lstatSync7(temporary, { throwIfNoEntry: false });
+    if (temporaryIdentity && currentTemporary?.dev === temporaryIdentity.dev && currentTemporary.ino === temporaryIdentity.ino)
+      unlinkSync5(temporary);
+    const currentLock = lstatSync7(lock, { throwIfNoEntry: false });
+    if (currentLock?.dev !== lockIdentity.dev || currentLock.ino !== lockIdentity.ino)
+      throw new NativeSafetyError("binding_changed");
+    unlinkSync5(lock);
+    syncDirectory(directory2);
+  }
+}
+async function evaluateNativeSafetyForExecution(event, options) {
+  if (!options || typeof options.agent !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:@-]{0,127}$/.test(options.agent))
+    throw new NativeSafetyError("input_invalid");
+  let snapshot2;
+  try {
+    snapshot2 = JSON.parse(JSON.stringify(event));
+  } catch {
+    throw new NativeSafetyError("input_invalid");
+  }
+  if (snapshot2?.tool_input && Object.hasOwn(snapshot2.tool_input, "hasna_execution"))
+    throw new NativeSafetyError("input_invalid");
+  const before = readNativeSafetyRegistration(options.home);
+  const binding = nativeSafetyCommandBinding(before.record.command);
+  const decision = await evaluateRecord(snapshot2, before.record, options.signal, options.agent);
+  if (readNativeSafetyRegistration(options.home).sha256 !== before.sha256)
+    throw new NativeSafetyError("binding_changed");
+  return decision.decision === "rewrite" ? {
+    decision: "rewrite",
+    execution: { command: decision.command, shell: "/bin/sh", cwd: snapshot2.cwd, env: { HOME: binding.home, PATH: binding.path } }
+  } : decision;
+}
+async function evaluateRecord(event, record3, signal, executionAgent) {
+  if (!event || event.hook_event_name !== "PreToolUse" || !["Bash", "apply_patch"].includes(event.tool_name) || typeof event.cwd !== "string" || !isAbsolute7(event.cwd) || !event.tool_input || typeof event.tool_input !== "object" || Array.isArray(event.tool_input))
+    throw new NativeSafetyError("input_invalid");
+  const input2 = JSON.stringify(executionAgent === undefined ? event : { ...event, hasna_execution: { schema: executionSchema, agent: executionAgent } });
+  if (Buffer.byteLength(input2) > 1048576)
+    throw new NativeSafetyError("input_invalid");
+  const output2 = await new Promise((accept, reject) => {
+    const child = execFile("/bin/sh", ["-c", record3.command], { cwd: "/", env: {}, encoding: "utf8", timeout: 8000, maxBuffer: 1048576, signal }, (error61, stdout, stderr) => {
+      if (error61 || stderr) {
+        reject(new NativeSafetyError("guard_failed"));
+        return;
+      }
+      accept(stdout);
+    });
+    child.stdin?.on("error", () => {});
+    child.stdin?.end(input2);
+  });
+  if (!output2)
+    return { decision: "continue" };
+  try {
+    const value = JSON.parse(output2);
+    if (Object.keys(value).join() !== "hookSpecificOutput")
+      throw new Error;
+    const verdict = value.hookSpecificOutput;
+    if (verdict.hookEventName !== "PreToolUse")
+      throw new Error;
+    if (verdict.permissionDecision === "deny" && Object.keys(verdict).sort().join() === "hookEventName,permissionDecision,permissionDecisionReason" && typeof verdict.permissionDecisionReason === "string" && verdict.permissionDecisionReason.trim())
+      return { decision: "deny", reason: verdict.permissionDecisionReason };
+    if (event.tool_name === "Bash" && verdict.permissionDecision === "allow" && Object.keys(verdict).sort().join() === "hookEventName,permissionDecision,updatedInput" && typeof verdict.updatedInput?.command === "string" && verdict.updatedInput.command.trim() && (executionAgent === undefined || verdict.updatedInput.hasna_execution === executionSchema))
+      return { decision: "rewrite", command: verdict.updatedInput.command };
+  } catch {}
+  throw new NativeSafetyError("guard_failed");
+}
+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);
+  if (verdict.decision !== "rewrite")
+    throw new NativeSafetyError("guard_failed", verdict.decision === "deny" ? verdict.reason.slice(0, 512) : undefined);
+}
+async function verifyNativeSafetyRegistration(home = homedir7()) {
+  const before = readNativeSafetyRegistration(home);
+  await verifyNativeSafetyCommand(before.record.command, home);
+  const after = readNativeSafetyRegistration(home);
+  if (after.sha256 !== before.sha256)
+    throw new NativeSafetyError("binding_changed");
+  return { path: before.path, sha256: before.sha256 };
+}
+async function verifyNativeSafetyExecutionRegistration(home = homedir7()) {
+  const before = readNativeSafetyRegistration(home);
+  const verdict = await evaluateNativeSafetyForExecution({
+    hook_event_name: "PreToolUse",
+    tool_name: "Bash",
+    cwd: home,
+    tool_input: { command: "rm -- .hasna-trash-verification-only" }
+  }, { home, agent: "native-safety-verification" });
+  if (verdict.decision !== "rewrite")
+    throw new NativeSafetyError("guard_failed", verdict.decision === "deny" ? verdict.reason.slice(0, 512) : undefined);
+  if (readNativeSafetyRegistration(home).sha256 !== before.sha256)
+    throw new NativeSafetyError("binding_changed");
+  return { path: before.path, sha256: before.sha256 };
+}
+
+// hooks/hook-trash-guard/src/binary.ts
+import { dirname as dirname17, isAbsolute as isAbsolute15, join as join17, resolve as resolve17 } from "path";
+import { accessSync, closeSync as closeSync5, constants as constants4, fstatSync as fstatSync4, lstatSync as lstatSync9, openSync as openSync5, readFileSync as readFileSync12, readlinkSync as readlinkSync3, readSync as readSync2, realpathSync as realpathSync8, statSync } from "fs";
+import { spawnSync } from "child_process";
+function trustedOwner(uid2) {
+  return uid2 === 0 || uid2 === process.getuid?.();
+}
+function safeExecutableFile(path, systemBinAlias = false) {
+  let current2 = path;
+  for (let hop = 0;hop < 32; hop++) {
+    if (!isAbsolute15(current2) || current2.length > 4096 || !safeBinaryDirectory("/"))
+      return false;
+    const parts = current2.split("/"), name = parts.pop();
+    if (!name || name === "." || name === "..")
+      return false;
+    let parent = "/";
+    for (const part of parts) {
+      if (!part || part === ".")
+        continue;
+      if (part === "..") {
+        parent = dirname17(parent);
+        continue;
+      }
+      const next = join17(parent, part), info2 = lstatSync9(next);
+      if (systemBinAlias && next === "/bin" && info2.isSymbolicLink() && info2.uid === 0) {
+        const target = realpathSync8(next);
+        if (!safeBinaryDirectory(target))
+          return false;
+        parent = target;
+        continue;
+      }
+      if (!info2.isDirectory() || !trustedOwner(info2.uid) || info2.mode & 18)
+        return false;
+      parent = next;
+    }
+    const candidate = join17(parent, name), info = lstatSync9(candidate);
+    if (!trustedOwner(info.uid))
+      return false;
+    if (info.isSymbolicLink()) {
+      const target = readlinkSync3(candidate);
+      current2 = isAbsolute15(target) ? target : parent + "/" + target;
+      continue;
+    }
+    return info.isFile() && Boolean(info.mode & 73) && !(info.mode & 18);
+  }
+  return false;
+}
+function safeInterpreterSearchDirectory(path) {
+  if (!isAbsolute15(path) || resolve17(path) !== (path.replace(/\/+$/, "") || "/"))
+    return false;
+  for (let cursor = resolve17(path);; cursor = dirname17(cursor)) {
+    try {
+      lstatSync9(cursor);
+      return safeBinaryDirectory(cursor);
+    } catch (error61) {
+      if (error61.code !== "ENOENT")
+        return false;
+    }
+    if (dirname17(cursor) === cursor)
+      return false;
+  }
+}
+function safeScriptInterpreter(executable, pathValue) {
+  const fd = openSync5(executable, constants4.O_RDONLY | constants4.O_NONBLOCK | constants4.O_NOFOLLOW);
+  let header;
+  try {
+    if (!fstatSync4(fd).isFile())
+      return false;
+    const bytes = Buffer.alloc(256), length = readSync2(fd, bytes, 0, bytes.length, 0);
+    header = bytes.subarray(0, length).toString("utf8").split(`
+`)[0];
+  } finally {
+    closeSync5(fd);
+  }
+  const direct = /^#!(\/[A-Za-z0-9_./-]+)$/.exec(header);
+  if (direct && direct[1] !== "/usr/bin/env")
+    return safeExecutableFile(direct[1], true);
+  if (header !== "#!/usr/bin/env bun" || !safeExecutableFile("/usr/bin/env", true))
+    return false;
+  for (const dir of pathValue.split(":").slice(0, 64)) {
+    if (!safeInterpreterSearchDirectory(dir))
+      return false;
+    const interpreter = resolve17(dir, "bun");
+    try {
+      if (!statSync(interpreter).isFile())
+        continue;
+      accessSync(interpreter, constants4.X_OK);
+    } catch {
+      continue;
+    }
+    return safeExecutableFile(interpreter, true);
+  }
+  return false;
+}
+function safeBinaryDirectory(path) {
+  let current2 = path;
+  for (;; ) {
+    const info = lstatSync9(current2);
+    if (!info.isDirectory() || !trustedOwner(info.uid) || (info.mode & 18) !== 0)
+      return false;
+    const parent = dirname17(current2);
+    if (parent === current2)
+      return true;
+    current2 = parent;
+  }
+}
+function inspectTrashBinary(env = process.env) {
+  const pathValue = env.PATH ?? "";
+  const deadline = Date.now() + 2000;
+  let failure = "missing";
+  const reject = (code2) => {
+    if (failure === "missing" || failure === "unrecognized_package" || code2.startsWith("unsafe_"))
+      failure = code2;
+  };
+  for (const dir of pathValue.split(":").slice(0, 64)) {
+    if (!isAbsolute15(dir) || Date.now() >= deadline)
+      continue;
+    const candidate = resolve17(dir, "trash");
+    try {
+      const stat2 = statSync(candidate);
+      if (!stat2.isFile() || !trustedOwner(stat2.uid) || (stat2.mode & 73) === 0 || (stat2.mode & 18) !== 0) {
+        reject("unsafe_executable");
+        continue;
+      }
+      const executable = realpathSync8(candidate);
+      if (!safeBinaryDirectory(resolve17(dir)) || !safeBinaryDirectory(dirname17(executable))) {
+        reject("unsafe_directory");
+        continue;
+      }
+      if (!safeExecutableFile(candidate)) {
+        reject("unsafe_directory");
+        continue;
+      }
+      const packageRoot = resolve17(dirname17(executable), "../..");
+      const manifestPath = join17(packageRoot, "package.json");
+      const manifestStat = statSync(manifestPath);
+      if (!manifestStat.isFile() || !trustedOwner(manifestStat.uid) || manifestStat.size > 16384 || (manifestStat.mode & 18) !== 0 || lstatSync9(manifestPath).isSymbolicLink()) {
+        reject("unsafe_manifest");
+        continue;
+      }
+      const manifest = JSON.parse(readFileSync12(manifestPath, "utf8"));
+      if (manifest.name !== "@hasna/trash" || typeof manifest.version !== "string" || typeof manifest.bin?.trash !== "string" || realpathSync8(resolve17(packageRoot, manifest.bin.trash)) !== executable) {
+        reject("unrecognized_package");
+        continue;
+      }
+      try {
+        if (!safeScriptInterpreter(executable, pathValue)) {
+          reject("unsafe_interpreter");
+          continue;
+        }
+      } catch {
+        reject("unsafe_interpreter");
+        continue;
+      }
+      const probe = spawnSync(candidate, ["--identity"], {
+        encoding: "utf8",
+        timeout: Math.max(1, Math.min(500, deadline - Date.now())),
+        maxBuffer: 2048,
+        env: { PATH: pathValue },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      if (probe.error || probe.status !== 0) {
+        reject("identity_failed");
+        continue;
+      }
+      const identity3 = JSON.parse(probe.stdout);
+      if (identity3.name === "@hasna/trash" && identity3.version === manifest.version && identity3.guardProtocol === "hasna.trash.guard.v1")
+        return { ok: true, path: candidate, version: manifest.version };
+      reject("unsupported_protocol");
+    } catch {}
+  }
+  return { ok: false, code: failure };
+}
+
+// src/cli/index.tsx
 init_registry();
 init_installer();
 init_registration();
@@ -44603,9 +45039,9 @@ init_local_opt_in();
 init_transport2();
 init_db();
 import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
-var __dirname4 = dirname22(fileURLToPath6(import.meta.url));
-var pkgPath = existsSync18(join29(__dirname4, "..", "package.json")) ? join29(__dirname4, "..", "package.json") : join29(__dirname4, "..", "..", "package.json");
-var pkg2 = JSON.parse(readFileSync20(pkgPath, "utf-8"));
+var __dirname4 = dirname24(fileURLToPath6(import.meta.url));
+var pkgPath = existsSync19(join31(__dirname4, "..", "package.json")) ? join31(__dirname4, "..", "package.json") : join31(__dirname4, "..", "..", "package.json");
+var pkg2 = JSON.parse(readFileSync23(pkgPath, "utf-8"));
 var program3 = new Command;
 function resolveScope(options) {
   if (options.project)
@@ -44685,7 +45121,7 @@ async function openLocalStoreOrExit(json3) {
 function readToken(tokenFile) {
   if (tokenFile) {
     try {
-      return readFileSync20(tokenFile, "utf-8").trim();
+      return readFileSync23(tokenFile, "utf-8").trim();
     } catch {
       return;
     }
@@ -44823,7 +45259,7 @@ program3.command("init").description("Register a new agent profile with a unique
   if (profile.name) {
     console.log(`  ${chalk2.dim("Name:")}       ${profile.name}`);
   }
-  console.log(`  ${chalk2.dim("Profile:")}    ${join29(getProfilesDir(), `${profile.agent_id}.json`)}`);
+  console.log(`  ${chalk2.dim("Profile:")}    ${join31(getProfilesDir(), `${profile.agent_id}.json`)}`);
   console.log();
   console.log(chalk2.dim("  Install hooks with this profile:"));
   console.log(`    hooks install gitguard --profile ${profile.agent_id}`);
@@ -44847,11 +45283,11 @@ program3.command("run").argument("<hook>", "Hook to run").option("--profile <id>
     process.exit(1);
   }
   const hookScript = resolveScriptPath2(hook);
-  if (!hookScript || !existsSync18(hookScript)) {
+  if (!hookScript || !existsSync19(hookScript)) {
     console.error(JSON.stringify({ error: `Hook script not found: ${hookScript ?? hook}` }));
     process.exit(1);
   }
-  const content = readFileSync20(hookScript);
+  const content = readFileSync23(hookScript);
   const sha4 = sha256Of2(content);
   const check2 = checkScriptHash2(hook, sha4);
   if (!check2.ok) {
@@ -45445,7 +45881,7 @@ program3.command("doctor").option("-g, --global", "Check global settings", false
     });
   }
   const staleNames = new Set(stale.map((finding) => finding.hook));
-  const settingsExist = existsSync18(settingsPath);
+  const settingsExist = existsSync19(settingsPath);
   if (!settingsExist) {
     issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
   }
@@ -45453,7 +45889,7 @@ program3.command("doctor").option("-g, --global", "Check global settings", false
   let wiringCount = 0;
   if (settingsExist) {
     try {
-      const settings = JSON.parse(readFileSync20(settingsPath, "utf-8"));
+      const settings = JSON.parse(readFileSync23(settingsPath, "utf-8"));
       wiringCount = countSettingsWiring(settings);
     } catch {}
   }
@@ -45464,7 +45900,7 @@ program3.command("doctor").option("-g, --global", "Check global settings", false
     const meta3 = custom2 ? resolveHookMeta(name) : getHook(name);
     let hookHealthy = true;
     if (custom2) {
-      if (!existsSync18(custom2.scriptPath)) {
+      if (!existsSync19(custom2.scriptPath)) {
         issues.push({ hook: name, issue: `Custom hook script missing: ${custom2.scriptPath}`, severity: "error" });
         hookHealthy = false;
       }
@@ -45475,15 +45911,15 @@ program3.command("doctor").option("-g, --global", "Check global settings", false
         continue;
       }
       const hookDir = getHookPath(name);
-      const hookScript = join29(hookDir, "src", "hook.ts");
-      if (!existsSync18(hookScript)) {
+      const hookScript = join31(hookDir, "src", "hook.ts");
+      if (!existsSync19(hookScript)) {
         issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
         hookHealthy = false;
       }
     }
     if (meta3 && settingsExist) {
       try {
-        const settings = JSON.parse(readFileSync20(settingsPath, "utf-8"));
+        const settings = JSON.parse(readFileSync23(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" });
@@ -45633,18 +46069,18 @@ program3.command("update").argument("[hooks...]", "Hooks to update (defaults to
     const result = installHook(arg, { scope, overwrite: true });
     const resolved = resolveHook2(arg);
     if (result.success && resolved) {
-      const hash = await sha256File2(resolved.scriptPath);
-      setPinnedHook2(resolved.name, { version: resolved.version, sha256: hash, source: resolved.source });
+      const hash4 = await sha256File2(resolved.scriptPath);
+      setPinnedHook2(resolved.name, { version: resolved.version, sha256: hash4, source: resolved.source });
       if (!isLocalStoreRefused2()) {
         upsertHookRecord2(getDb2(), {
           name: resolved.name,
           version: resolved.version,
-          sha256: hash,
+          sha256: hash4,
           source_type: resolved.source,
           last_verified_at: new Date().toISOString()
         });
       }
-      results2.push({ ...result, pinned: { version: resolved.version, sha256: hash } });
+      results2.push({ ...result, pinned: { version: resolved.version, sha256: hash4 } });
       continue;
     }
     results2.push(result);
@@ -45686,10 +46122,10 @@ program3.command("docs").argument("[hook]", "Hook name (shows general docs if om
       return;
     }
     const hookPath = getHookPath(hook);
-    const readmePath = join29(hookPath, "README.md");
+    const readmePath = join31(hookPath, "README.md");
     let readme = "";
-    if (existsSync18(readmePath)) {
-      readme = readFileSync20(readmePath, "utf-8");
+    if (existsSync19(readmePath)) {
+      readme = readFileSync23(readmePath, "utf-8");
     }
     if (options.json) {
       console.log(JSON.stringify({ ...meta3, readme }));
@@ -46317,7 +46753,38 @@ program3.command("mcp").option("-s, --stdio", "Use stdio transport (one process
   }
 });
 registerEventsCommands(program3, { source: "hooks" });
-program3.command("safety").description("Register bundled native deletion guards without a registry credential").command("install <guard>").option("--target <target>", "codex or claude", "codex").option("--scope <scope>", "global or project", "global").option("--overwrite", "Replace this guard in place; native trust is still required").action((guard, options) => {
+var safety = program3.command("safety").description("Inspect and register bundled native deletion guards without a registry credential");
+safety.command("inspect").description("Check the installed Trash guard identity and filesystem safety without app credentials").action(() => {
+  const result = inspectTrashBinary();
+  console.log(JSON.stringify({ guard: "trash-guard", ...result }));
+  if (!result.ok)
+    process.exitCode = 1;
+});
+safety.command("install <guard>").option("--target <target>", "codex, claude or sumi", "codex").option("--scope <scope>", "global or project", "global").option("--overwrite", "Replace this guard in place; native trust is still required").option("--expected-binding-sha256 <sha256>", "Exact existing Sumi binding digest required for an upgrade").action(async (guard, options) => {
+  if (options.target === "sumi") {
+    try {
+      if (guard !== "trash-guard" || options.scope !== "global" || options.overwrite)
+        throw new NativeSafetyError("input_invalid");
+      const command = installedNativeSafetyCommand("trash-guard");
+      const binding = nativeSafetyCommandBinding(command);
+      const installed = inspectTrashBinary({ PATH: binding.path });
+      if (!installed.ok) {
+        console.log(JSON.stringify({ ok: false, target: "sumi", code: installed.code }));
+        process.exitCode = 1;
+        return;
+      }
+      await verifyNativeSafetyCommand(command);
+      const registered = registerNativeSafety({ command, expectedSHA256: options.expectedBindingSha256 });
+      const verified = await verifyNativeSafetyRegistration();
+      if (verified.sha256 !== registered.sha256)
+        throw new NativeSafetyError("binding_changed");
+      console.log(JSON.stringify({ target: "sumi", ...registered }));
+    } catch (error61) {
+      console.log(JSON.stringify({ ok: false, target: "sumi", code: error61 instanceof NativeSafetyError ? error61.code : "binding_invalid", ...error61 instanceof NativeSafetyError && error61.reason ? { reason: error61.reason } : {} }));
+      process.exitCode = 1;
+    }
+    return;
+  }
   if (!isNativeSafetyName(guard) || !["codex", "claude"].includes(options.target) || !["global", "project"].includes(options.scope)) {
     console.error("Unsupported bundled safety registration");
     process.exitCode = 1;
@@ -46328,6 +46795,17 @@ program3.command("safety").description("Register bundled native deletion guards
   if (!result.success)
     process.exitCode = 1;
 });
+safety.command("verify").requiredOption("--target <target>", "sumi").option("--execution", "Also require the pinned native execution capability; no file operation is run").description("Verify a required native binding and its supervisor without running a file operation").action(async (options) => {
+  try {
+    if (options.target !== "sumi")
+      throw new NativeSafetyError("input_invalid");
+    const current2 = await (options.execution ? verifyNativeSafetyExecutionRegistration() : verifyNativeSafetyRegistration());
+    console.log(JSON.stringify({ ok: true, target: "sumi", sha256: current2.sha256, guardVerified: true, ...options.execution ? { executionCapabilityVerified: true } : {}, nativeAdoptionVerified: false }));
+  } catch (error61) {
+    console.log(JSON.stringify({ ok: false, target: "sumi", code: error61 instanceof NativeSafetyError ? error61.code : "guard_failed", ...error61 instanceof NativeSafetyError && error61.reason ? { reason: error61.reason } : {} }));
+    process.exitCode = 1;
+  }
+});
 var API_INDEPENDENT_COMMANDS = new Set([
   "safety",
   "serve",