@hasna/hooks 0.6.5 → 0.6.8

package/bin/index.js

@@ -4119,24 +4119,30 @@ function resolveApiUrl() {
   const cfg = readConfig();
   return cfg.api_url ? cfg.api_url.replace(/\/+$/, "") : undefined;
 }
-function resolveApiKey(flagKey) {
-  if (flagKey && flagKey.length > 0)
-    return flagKey;
+function resolveApiKey() {
   return process.env.HASNA_HOOKS_API_KEY ?? process.env.HOOKS_API_KEY;
 }
 var init_config = () => {};
 
+// src/lib/semver.ts
+var NUMERIC_ID = "(0|[1-9]\\d{0,15})", ALNUM_ID = "\\d*[A-Za-z-][0-9A-Za-z-]*", SEMVER_PATTERN;
+var init_semver = __esm(() => {
+  SEMVER_PATTERN = new RegExp(`^${NUMERIC_ID}\\.${NUMERIC_ID}\\.${NUMERIC_ID}` + `(?:-(?:${NUMERIC_ID}|${ALNUM_ID})(?:\\.(?:${NUMERIC_ID}|${ALNUM_ID}))*)?` + `(?:\\+[0-9A-Za-z.-]+)?$`);
+});
+
 // src/lib/manifest.ts
 var exports_manifest = {};
 __export(exports_manifest, {
   writeCustomHook: () => writeCustomHook,
   shortManifestName: () => shortManifestName,
+  scriptRelFor: () => scriptRelFor,
   resolveScript: () => resolveScript,
   readCustomManifest: () => readCustomManifest,
   parseManifest: () => parseManifest,
   normalizeManifestName: () => normalizeManifestName,
   manifestSchema: () => manifestSchema,
   listCustomHooks: () => listCustomHooks,
+  isInlineScript: () => isInlineScript,
   customHookDir: () => customHookDir,
   assertContained: () => assertContained,
   ScriptContainmentError: () => ScriptContainmentError,
@@ -4190,16 +4196,25 @@ function assertContained(target, root, raw) {
   assertContainedReal(root, lexical, raw);
   return lexical;
 }
-function resolveScript(manifest, manifestDir) {
-  if (manifest.script.includes(`
-`)) {
+function isInlineScript(manifest) {
+  return manifest.script_kind === "inline" || manifest.script_kind === undefined && manifest.script.includes(`
+`);
+}
+function scriptRelFor(manifest) {
+  if (isInlineScript(manifest)) {
     const ext = manifest.script.trim().startsWith("#!") ? ".sh" : ".ts";
-    return { path: `script${ext}`, content: manifest.script };
+    return `script${ext}`;
   }
   const rel = normalize(manifest.script);
   if (isAbsolute(rel)) {
     throw new Error(`manifest script must be relative or inline, got absolute path '${manifest.script}'`);
   }
+  return rel;
+}
+function resolveScript(manifest, manifestDir) {
+  if (isInlineScript(manifest))
+    return { path: scriptRelFor(manifest), content: manifest.script };
+  const rel = scriptRelFor(manifest);
   const resolved = assertContained(join3(manifestDir, rel), manifestDir, manifest.script);
   if (!existsSync3(resolved)) {
     throw new Error(`manifest script file not found: ${resolved}`);
@@ -4217,8 +4232,8 @@ function readCustomManifest(name) {
   try {
     const manifest = parseManifest(readFileSync2(manifestPath, "utf-8"));
     const script = resolveScript(manifest, dir);
-    return { manifest, scriptPath: join3(dir, script.path), scriptContent: script.content, scriptIsInline: manifest.script.includes(`
-`) };
+    const scriptIsInline = isInlineScript(manifest);
+    return { manifest, scriptPath: join3(dir, script.path), scriptContent: script.content, scriptIsInline };
   } catch (err) {
     if (err instanceof ScriptContainmentError)
       throw err;
@@ -4264,15 +4279,18 @@ function readdirSafe(dir) {
 var HOOK_NAME_RE, manifestSchema, ScriptContainmentError;
 var init_manifest = __esm(() => {
   init_config();
+  init_semver();
   HOOK_NAME_RE = /^[\w-]+$/;
   manifestSchema = z.object({
     name: z.string().regex(HOOK_NAME_RE, "hook name must be /^[\\w-]+$/"),
-    version: z.string().regex(/^\d+\.\d+\.\d+/, "version must be semver (e.g. 1.2.3)"),
+    version: z.string().regex(SEMVER_PATTERN, "version must be full semver (e.g. 1.2.3 or 1.2.3-beta.1)"),
     description: z.string().optional(),
     events: z.array(z.string()).min(1, "at least one event is required"),
     script: z.string().min(1, "script must name a relative path or inline content"),
+    script_kind: z.enum(["inline", "file"]).optional(),
     args: z.array(z.string()).optional(),
-    timeout_ms: z.number().int().positive().optional()
+    timeout_ms: z.number().int().positive().optional(),
+    env: z.record(z.string(), z.string()).optional()
   });
   ScriptContainmentError = class ScriptContainmentError extends Error {
     constructor(path, hookDir, raw) {
@@ -4799,11 +4817,13 @@ __export(exports_store, {
   listHookRecords: () => listHookRecords,
   getPinnedHook: () => getPinnedHook,
   getHookRecord: () => getHookRecord,
-  checkScriptHash: () => checkScriptHash
+  checkScriptHash: () => checkScriptHash,
+  LockFileError: () => LockFileError
 });
 import { createHash } from "crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync } from "fs";
 import { readFile as readFile2 } from "fs/promises";
+import { randomBytes } from "crypto";
 function sha256Of(input) {
   return createHash("sha256").update(input).digest("hex");
 }
@@ -4846,16 +4866,39 @@ function removeHookRecord(db, name) {
   const res = db.run("DELETE FROM hooks WHERE name = ?", [name]);
   return res.changes > 0;
 }
+function assertLockShape(parsed, path) {
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new LockFileError(`hooks.lock (${path}) is malformed: expected a JSON object with a "hooks" map. ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it. ` + `Nothing was trusted or rewritten \u2014 hooks are left in the refuse-to-run state until the lock is repaired.`);
+  }
+  const hooks = parsed.hooks;
+  if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks)) {
+    throw new LockFileError(`hooks.lock (${path}) is malformed: missing or invalid "hooks" map. ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it. ` + `Nothing was trusted or rewritten \u2014 hooks are left in the refuse-to-run state until the lock is repaired.`);
+  }
+  for (const [name, entry] of Object.entries(hooks)) {
+    const e = entry;
+    if (e === null || typeof e !== "object" || typeof e.version !== "string" || typeof e.sha256 !== "string") {
+      throw new LockFileError(`hooks.lock (${path}) is malformed: entry for '${name}' is not a valid pin (version and sha256 strings required). ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it.`);
+    }
+  }
+}
 function readLock() {
+  const path = getLockPath();
+  if (!existsSync7(path))
+    return { hooks: {} };
+  let raw;
   try {
-    const path = getLockPath();
-    if (!existsSync7(path))
-      return { hooks: {} };
-    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
-    return { hooks: parsed.hooks ?? {} };
+    raw = readFileSync4(path, "utf-8");
   } catch {
-    return { hooks: {} };
+    throw new LockFileError(`hooks.lock (${path}) could not be read. Repair: fix permissions or move the file aside and run 'hooks sync'.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new LockFileError(`hooks.lock (${path}) is malformed: not valid JSON (${String((raw ?? "").slice(0, 80))}). ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it. ` + `Nothing was trusted or rewritten \u2014 hooks are left in the refuse-to-run state until the lock is repaired.`);
   }
+  assertLockShape(parsed, path);
+  return parsed;
 }
 function writeLock(lock) {
   const path = getLockPath();
@@ -4864,8 +4907,10 @@ function writeLock(lock) {
   for (const name of Object.keys(lock.hooks).sort()) {
     sorted[name] = lock.hooks[name];
   }
-  writeFileSync3(path, JSON.stringify({ hooks: sorted }, null, 2) + `
+  const tmp = `${path}.tmp-${randomBytes(8).toString("hex")}`;
+  writeFileSync3(tmp, JSON.stringify({ hooks: sorted }, null, 2) + `
 `, "utf-8");
+  renameSync(tmp, path);
   return path;
 }
 function setPinnedHook(name, entry) {
@@ -4951,9 +4996,16 @@ function retrustHook(name, scriptPath, version, source) {
   setPinnedHook(name, { version, sha256: actual, source });
   return { ok: true, pinned: true, expected: actual, actual, name };
 }
+var LockFileError;
 var init_store = __esm(() => {
   init_db();
   init_config();
+  LockFileError = class LockFileError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "LockFileError";
+    }
+  };
 });
 
 // src/lib/installer.ts
@@ -5006,7 +5058,7 @@ function getGlobalSettingsPathOverride(target) {
 function getSettingsPath(scope = "global", target = "claude", codewithConfigPath) {
   if (target === "codewith" && codewithConfigPath)
     return codewithConfigPath;
-  if (target === "codewith" && process.env.HASNA_HOOKS_CODEWITH_CONFIG_PATH) {
+  if (target === "codewith" && scope === "global" && process.env.HASNA_HOOKS_CODEWITH_CONFIG_PATH) {
     return process.env.HASNA_HOOKS_CODEWITH_CONFIG_PATH;
   }
   const globalOverride = scope === "global" ? getGlobalSettingsPathOverride(target) : undefined;
@@ -5439,8 +5491,8 @@ function escapeRegExp(value) {
 function codewithHasHookEntryInText(configText, name) {
   return new RegExp(`hooks run ${escapeRegExp(name)}(?:\\s+--profile\\s+[\\w-]+)?(?:$|\\s|")`).test(configText);
 }
-function codewithHasHookEntry(name) {
-  const path = getSettingsPath("global", "codewith");
+function codewithHasHookEntry(name, scope = "global") {
+  const path = getSettingsPath(scope, "codewith");
   if (!existsSync8(path))
     return false;
   try {
@@ -5457,7 +5509,7 @@ function uninstallHook(name, scope = "global", target = "claude") {
   const registeredClaudeOrGemini = target === "all" ? existsInTarget("claude") || existsInTarget("gemini") : false;
   const registeredGlobal = registeredClaudeOrGemini || getRegisteredHooksForTarget("global", target === "all" ? "claude" : target).includes(shortName);
   const registeredProject = registeredClaudeOrGemini || getRegisteredHooksForTarget("project", target === "all" ? "claude" : target).includes(shortName);
-  const codewithOnly = (target === "codewith" || target === "all") && codewithHasHookEntry(shortName);
+  const codewithOnly = (target === "codewith" || target === "all") && codewithHasHookEntry(shortName, scope);
   if (!custom && !bundledMeta && !registeredGlobal && !registeredProject && !codewithOnly) {
     return { name: shortName, removed: false, source: null, settingsScopes: [], storeDirRemoved: false, pinRemoved: false, dbRecordRemoved: false, registrationsRemaining: [], error: `Hook '${shortName}' not found` };
   }
@@ -5474,7 +5526,7 @@ function uninstallHook(name, scope = "global", target = "claude") {
   }
   const registrationsRemaining = [];
   if (target === "codewith" || target === "all") {
-    const codewithPath = getSettingsPath("global", "codewith");
+    const codewithPath = getSettingsPath(scope, "codewith");
     if (existsSync8(codewithPath)) {
       const before = readFileSync5(codewithPath, "utf-8");
       const after = removeCodewithHookEntry(before, shortName);
@@ -5566,6 +5618,22 @@ function safeMatcherTest(pattern, value) {
     return false;
   }
 }
+function countSettingsWiring(settings) {
+  const hooks = settings.hooks;
+  if (!hooks || typeof hooks !== "object")
+    return 0;
+  let count = 0;
+  for (const eventKey of Object.keys(hooks)) {
+    const entries = hooks[eventKey];
+    if (!Array.isArray(entries))
+      continue;
+    for (const entry of entries) {
+      if (Array.isArray(entry?.hooks))
+        count += entry.hooks.length;
+    }
+  }
+  return count;
+}
 function hookRegisteredInSettings(settings, name, eventSpec, hookMatcher) {
   const separator = eventSpec.indexOf(":");
   const eventName = separator === -1 ? eventSpec : eventSpec.slice(0, separator);
@@ -5587,6 +5655,71 @@ function hookRegisteredInSettings(settings, name, eventSpec, hookMatcher) {
   }));
 }
 
+// src/lib/redact.ts
+function redactText(value) {
+  let out = value;
+  for (const pattern of SECRET_SHAPES) {
+    out = out.replace(pattern, REDACTED);
+  }
+  return out;
+}
+function redactValue2(value) {
+  if (typeof value === "string")
+    return redactText(value);
+  if (Array.isArray(value))
+    return value.map(redactValue2);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      out[key] = SECRET_KEY_NAMES.test(key) ? REDACTED : redactValue2(child);
+    }
+    return out;
+  }
+  return value;
+}
+function redactEventPayload(text) {
+  if (text === null || text === undefined)
+    return null;
+  try {
+    const parsed = JSON.parse(text);
+    return redactText(JSON.stringify(redactValue2(parsed)));
+  } catch {
+    return redactText(text);
+  }
+}
+function projectEventRowForRead(row) {
+  const out = { ...row };
+  for (const field of ["tool_input", "error", "metadata"]) {
+    const value = out[field];
+    if (typeof value === "string")
+      out[field] = redactEventPayload(value);
+    else if (value === null)
+      out[field] = null;
+  }
+  return out;
+}
+var REDACTED = "[REDACTED]", SECRET_KEY_NAMES, SECRET_SHAPES;
+var init_redact = __esm(() => {
+  SECRET_KEY_NAMES = /^(key|keys|token|tokens|secret|secrets|password|passwd|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret|refresh[_-]?token|authorization|auth|cookie|credential|credentials|session[_-]?id|otp|mfa[_-]?code|two[_-]?fa[_-]?code|verification[_-]?code|database_url|db_url|connection_string|dsn)$/i;
+  SECRET_SHAPES = [
+    /\bsk-(?:proj|svc|ant)-[A-Za-z0-9_-]{10,}/g,
+    /\bsk-[A-Za-z0-9]{16,}/g,
+    /\btpe_[A-Za-z0-9]{8,}/g,
+    /\b(?:rk|sk)_(?:live|test)_[A-Za-z0-9]{8,}/g,
+    /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+    /gh[pousr]_[A-Za-z0-9]{20,}/g,
+    /xox[baprs]-[A-Za-z0-9-]{20,}/g,
+    /AKIA[0-9A-Z]{16}/g,
+    /ASIA[0-9A-Z]{16}/g,
+    /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+    /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----/g,
+    /-----BEGIN OPENSSH PRIVATE KEY-----/g,
+    /\bBearer\s+[A-Za-z0-9._~+/=-]{6,}/g,
+    /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]+:[^/\s@]+@/gi,
+    /\b(?:password|passwd|pwd|token|api[_-]?key|secret|access[_-]?key|client[_-]?secret|authorization|auth|credential|database_url|db_url|connection_string|dsn)\s*[:=]\s*(?:"[^"]*"|'[^']*'|[^\s,;"']{6,})/gi
+  ];
+});
+
 // src/lib/profiles.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync3, rmSync as rmSync2, cpSync as cpSync2 } from "fs";
 import { join as join8 } from "path";
@@ -5708,6 +5841,9 @@ function writeHookEvent(event) {
     const db = getDb();
     const id = nanoid2();
     const timestamp = event.timestamp ?? new Date().toISOString();
+    const toolInput = redactEventPayload(event.tool_input);
+    const error = redactEventPayload(event.error);
+    const metadata = redactEventPayload(event.metadata);
     db.run(`INSERT INTO hook_events
         (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
@@ -5717,12 +5853,12 @@ function writeHookEvent(event) {
       event.hook_name,
       event.event_type,
       event.tool_name ?? null,
-      event.tool_input ? event.tool_input.slice(0, 500) : null,
+      toolInput ? toolInput.slice(0, 500) : null,
       event.result ?? null,
-      event.error ?? null,
+      error ?? null,
       event.duration_ms ?? null,
       event.project_dir ?? null,
-      event.metadata ?? null
+      metadata ?? null
     ]);
   } catch (err) {
     process.stderr.write(`[hooks db-writer] failed to write event: ${err}
@@ -5772,6 +5908,7 @@ function recordHookRun(record) {
 var ALLOWED_EVENT_TYPES;
 var init_db_writer = __esm(() => {
   init_db();
+  init_redact();
   ALLOWED_EVENT_TYPES = new Set([
     "PreToolUse",
     "PostToolUse",
@@ -5784,15 +5921,169 @@ var init_db_writer = __esm(() => {
   ]);
 });
 
+// src/lib/hook-env.ts
+import { dirname as dirname4, isAbsolute as isAbsolute2 } from "path";
+import { existsSync as existsSync10, statSync } from "fs";
+function isDeniedEnvName(name) {
+  const upper = name.toUpperCase();
+  if (DENY_PREFIXES.some((prefix) => upper.startsWith(prefix)))
+    return true;
+  if (DENY_SUFFIXES.some((suffix) => upper.endsWith(suffix)))
+    return true;
+  return DENY_CONTAINS.some((token) => upper.includes(token));
+}
+function isInterpreterInjectionEnvName(name) {
+  if (INTERPRETER_INJECTION.has(name))
+    return true;
+  return INTERPRETER_INJECTION_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+function isBashFunctionEnvName(name) {
+  return name.startsWith("BASH_FUNC_");
+}
+function isUnsafePathEntry(entry, home) {
+  if (entry === "" || !isAbsolute2(entry))
+    return true;
+  if (home && (entry === home || entry.startsWith(home + "/")))
+    return true;
+  if (entry === "/tmp" || entry.startsWith("/tmp/"))
+    return true;
+  if (entry === "/var/tmp" || entry.startsWith("/var/tmp/"))
+    return true;
+  try {
+    if ((statSync(entry).mode & 2) !== 0)
+      return true;
+  } catch {}
+  return false;
+}
+function sanitizeHookPath(pathValue, home) {
+  const baseline = PATH_BASELINE.slice();
+  if (process.platform === "darwin" && existsSync10("/opt/homebrew/bin"))
+    baseline.push("/opt/homebrew/bin");
+  const bunDir = dirname4(process.execPath);
+  const seen = new Set;
+  const out = [];
+  for (const dir of baseline) {
+    if (seen.has(dir))
+      continue;
+    seen.add(dir);
+    out.push(dir);
+  }
+  if (!seen.has(bunDir)) {
+    seen.add(bunDir);
+    out.push(bunDir);
+  }
+  for (const entry of pathValue.split(":")) {
+    if (seen.has(entry))
+      continue;
+    if (isUnsafePathEntry(entry, home))
+      continue;
+    seen.add(entry);
+    out.push(entry);
+  }
+  return out.join(":");
+}
+function buildHookEnv(source, extra) {
+  const out = {};
+  for (const name of ALLOWLIST) {
+    if (name === "PATH")
+      continue;
+    const value = source[name] ?? extra?.[name];
+    if (value !== undefined && value !== null)
+      out[name] = value;
+  }
+  const pathOverride = extra?.PATH;
+  if (pathOverride !== undefined && pathOverride !== null) {
+    out.PATH = pathOverride;
+  } else {
+    const parentPath = source.PATH;
+    if (parentPath !== undefined && parentPath !== null) {
+      out.PATH = sanitizeHookPath(parentPath, source.HOME ?? extra?.HOME);
+    }
+  }
+  for (const [from, to] of CONFIG_PROJECTIONS) {
+    const value = source[from] ?? extra?.[from];
+    if (value !== undefined && value !== null)
+      out[to] = value;
+  }
+  const merged = { ...source, ...extra ?? {} };
+  for (const [name, value] of Object.entries(merged)) {
+    if (out[name] !== undefined)
+      continue;
+    if (isDeniedEnvName(name))
+      continue;
+    if (isInterpreterInjectionEnvName(name))
+      continue;
+    if (isBashFunctionEnvName(name))
+      continue;
+    if (value !== undefined && value !== null)
+      out[name] = value;
+  }
+  return out;
+}
+var ALLOWLIST, INTERPRETER_INJECTION, INTERPRETER_INJECTION_PREFIXES, DENY_SUFFIXES, DENY_PREFIXES, DENY_CONTAINS, PATH_BASELINE, CONFIG_PROJECTIONS;
+var init_hook_env = __esm(() => {
+  ALLOWLIST = new Set(["PATH", "HOME", "LANG", "TZ", "SHELL", "TERM", "USER", "PWD"]);
+  INTERPRETER_INJECTION = new Set([
+    "BASH_ENV",
+    "ENV",
+    "BASHOPTS",
+    "SHELLOPTS",
+    "NODE_OPTIONS",
+    "NODE_PATH",
+    "PYTHONSTARTUP",
+    "PYTHONINSPECT",
+    "PYTHONPATH",
+    "PYTHONHOME",
+    "LD_PRELOAD",
+    "LD_LIBRARY_PATH",
+    "GCONV_PATH",
+    "LOCPATH",
+    "PERL5OPT",
+    "RUBYOPT",
+    "NODE_EXTRA_CA_CERTS",
+    "NODE_TLS_REJECT_UNAUTHORIZED",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    "CURL_CA_BUNDLE",
+    "GIT_SSL_CAINFO",
+    "AWS_CA_BUNDLE"
+  ]);
+  INTERPRETER_INJECTION_PREFIXES = ["GIT_CONFIG_"];
+  DENY_SUFFIXES = ["KEY", "TOKEN", "SECRET", "PASSWORD", "PASSWD", "CREDENTIAL", "CREDENTIALS", "URL", "URI"];
+  DENY_PREFIXES = [
+    "HASNA_",
+    "AWS_",
+    "AZURE_",
+    "GCP_",
+    "VAULT_",
+    "GOOGLE_",
+    "OPENAI_",
+    "ANTHROPIC_",
+    "POSTGRES_",
+    "MYSQL_",
+    "REDIS_",
+    "MONGO_",
+    "MEMENTOS_"
+  ];
+  DENY_CONTAINS = ["DATABASE_URL"];
+  PATH_BASELINE = ["/usr/bin", "/bin", "/usr/local/bin", "/sbin", "/usr/sbin"];
+  CONFIG_PROJECTIONS = [
+    ["HASNA_HOOKS_DATA_DIR", "HOOKS_DATA_DIR"],
+    ["HASNA_HOOKS_DB_PATH", "HOOKS_DB_PATH"],
+    ["HASNA_HOOKS_LOCK_PATH", "HOOKS_LOCK_PATH"],
+    ["HASNA_HOOKS_CONFIG_PATH", "HOOKS_CONFIG_PATH"]
+  ];
+});
+
 // src/lib/run.ts
 var exports_run = {};
 __export(exports_run, {
   executeVerifiedScript: () => executeVerifiedScript,
   HookTimeoutError: () => HookTimeoutError
 });
-import { randomBytes } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 import { rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
-import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, join as join9 } from "path";
+import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute3, join as join9 } from "path";
 function extensionOf(scriptPath) {
   const base = basename2(scriptPath);
   const dot = base.lastIndexOf(".");
@@ -5819,13 +6110,13 @@ function interpreterFor(name, scriptPath, content) {
     if (interp === "bash" || interp === "sh")
       return { command: ["/bin/bash"], tempExt: "sh" };
     if (interp === "node" || interp === "bun")
-      return { command: ["bun", "run"], tempExt: BUN_EXTENSIONS.has(ext) ? ext : "ts" };
+      return { command: [process.execPath, "run"], tempExt: BUN_EXTENSIONS.has(ext) ? ext : "ts" };
     throw new Error(`Refusing to run hook '${name}': shebang '${firstLine}' is not a recognized interpreter (supported: bash/sh, node/bun)`);
   }
   if (BASH_EXTENSIONS.has(ext))
     return { command: ["/bin/bash"], tempExt: "sh" };
   if (BUN_EXTENSIONS.has(ext))
-    return { command: ["bun", "run"], tempExt: ext };
+    return { command: [process.execPath, "run"], tempExt: ext };
   throw new Error(`Refusing to run hook '${name}': unsupported script extension '.${ext}' (supported: .sh .bash .ts .tsx .js .jsx .mjs .cjs .mts .cts, or a recognized shebang)`);
 }
 async function readPipeWithDeadline(stream, deadlineMs) {
@@ -5861,9 +6152,9 @@ async function readPipeWithDeadline(stream, deadlineMs) {
   return chunks.join("");
 }
 async function executeVerifiedScript(options) {
-  const scriptDir = dirname4(options.scriptPath);
+  const scriptDir = dirname5(options.scriptPath);
   const interpreter = interpreterFor(options.name, options.scriptPath, options.content);
-  const tempPath = join9(scriptDir, `.hooks-verified-${randomBytes(12).toString("hex")}.${interpreter.tempExt}`);
+  const tempPath = join9(scriptDir, `.hooks-verified-${randomBytes2(12).toString("hex")}.${interpreter.tempExt}`);
   let proc = null;
   let timedOut = false;
   const timeoutTimer = options.timeout ? setTimeout(() => {
@@ -5872,11 +6163,11 @@ async function executeVerifiedScript(options) {
   }, options.timeout) : null;
   try {
     writeFileSync6(tempPath, options.content, { flag: "wx", mode: 384 });
-    proc = Bun.spawn([...interpreter.command, isAbsolute2(tempPath) ? tempPath : `./${tempPath}`, ...options.args ?? []], {
+    proc = Bun.spawn([...interpreter.command, isAbsolute3(tempPath) ? tempPath : `./${tempPath}`, ...options.args ?? []], {
       stdin: new Response(options.stdin),
       stdout: "pipe",
       stderr: "pipe",
-      env: options.env ?? process.env,
+      env: buildHookEnv(process.env, options.env),
       detached: true
     });
     const exitCode = await proc.exited;
@@ -5934,6 +6225,7 @@ function killGroup(proc, options) {
 }
 var HookTimeoutError, BASH_EXTENSIONS, BUN_EXTENSIONS;
 var init_run = __esm(() => {
+  init_hook_env();
   HookTimeoutError = class HookTimeoutError extends Error {
     timeoutMs;
     constructor(timeoutMs) {
@@ -5953,12 +6245,12 @@ __export(exports_custom_install, {
   installCustomSource: () => installCustomSource,
   ensureCustomDir: () => ensureCustomDir
 });
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync4 } from "fs";
 import { join as join10 } from "path";
 import { tmpdir } from "os";
 function manifestAt(dir) {
   const path = join10(dir, "manifest.json");
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     return;
   try {
     return parseManifest(readFileSync7(path, "utf-8"));
@@ -6004,7 +6296,7 @@ function isCustomSource(value) {
     return true;
   if (value.startsWith("http://") || value.startsWith("https://"))
     return true;
-  return existsSync10(value);
+  return existsSync11(value);
 }
 async function installCustomSource(source) {
   if (isGitUrl(source)) {
@@ -6018,7 +6310,7 @@ async function installCustomSource(source) {
   if (source.startsWith("http://") || source.startsWith("https://")) {
     return installManifestUrl(source);
   }
-  if (!existsSync10(source)) {
+  if (!existsSync11(source)) {
     throw new Error(`No such local path: ${source}`);
   }
   if (source.endsWith("manifest.json")) {
@@ -6028,19 +6320,20 @@ async function installCustomSource(source) {
   return copyManifestDir(source, source, "local");
 }
 async function installManifestUrl(url) {
-  const res = await fetch(url, { redirect: "follow" });
+  const res = await fetch(url, { redirect: "error" });
   if (!res.ok) {
     throw new Error(`Failed to fetch manifest (${res.status}): ${url}`);
   }
   const manifest = parseManifest(await res.text());
   let script;
-  if (manifest.script.includes(`
-`)) {
+  const inline = manifest.script_kind === "inline" || manifest.script_kind === undefined && manifest.script.includes(`
+`);
+  if (inline) {
     script = { path: "script.ts", content: manifest.script };
   } else {
     const base = url.substring(0, url.lastIndexOf("/"));
     const scriptUrl = `${base}/${manifest.script}`;
-    const scriptRes = await fetch(scriptUrl, { redirect: "follow" });
+    const scriptRes = await fetch(scriptUrl, { redirect: "error" });
     if (!scriptRes.ok) {
       throw new Error(`Failed to fetch script (${scriptRes.status}): ${scriptUrl}`);
     }
@@ -6064,8 +6357,10 @@ var init_custom_install = __esm(() => {
 var exports_sync = {};
 __export(exports_sync, {
   syncHooks: () => syncHooks,
+  stageSyncArtifacts: () => stageSyncArtifacts,
   planSync: () => planSync,
-  fetchPinnedHook: () => fetchPinnedHook
+  fetchPinnedHook: () => fetchPinnedHook,
+  commitSyncArtifacts: () => commitSyncArtifacts
 });
 import { createHash as createHash2 } from "crypto";
 import { readFileSync as readFileSync8 } from "fs";
@@ -6089,7 +6384,7 @@ function collectBundledCatalog() {
   }
   return out;
 }
-async function fetchJson(base, path) {
+async function fetchJson(base, path, opts) {
   const headers = { accept: "application/json" };
   const apiKey = resolveApiKey();
   if (apiKey)
@@ -6105,7 +6400,11 @@ async function fetchJson(base, path) {
   if (!res.ok) {
     throw new Error(`GET ${path} failed with status ${res.status}`);
   }
-  return res.json();
+  const body = await res.json();
+  if (opts?.withHeader) {
+    body[opts.withHeader] = res.headers.get("x-hook-sha256");
+  }
+  return body;
 }
 async function fetchRemoteState(apiUrl) {
   const catalog = await fetchJson(apiUrl, "/api/v1/catalog");
@@ -6118,6 +6417,16 @@ async function fetchRemoteState(apiUrl) {
   }
   return { catalog: catalog.hooks, remoteLock };
 }
+function classifyRemotePin(pin, remoteVersion, remoteSha) {
+  const pinnedLocally = pin !== undefined && pin.version === remoteVersion && pin.sha256 === remoteSha;
+  if (pinnedLocally)
+    return "unchanged";
+  if (pin !== undefined && pin.pinned === true && pin.version !== remoteVersion)
+    return "unchanged";
+  if (pin !== undefined)
+    return "updated";
+  return "added";
+}
 function computeDiff(catalog, remoteLock) {
   const local = readLock();
   const diff = { added: [], updated: [], unchanged: [], skipped: [] };
@@ -6125,30 +6434,30 @@ function computeDiff(catalog, remoteLock) {
     if (!entry.name || !entry.version || !entry.sha256)
       continue;
     const pin = local.hooks[entry.name];
-    const remotePin = remoteLock ? remoteLock.hooks[entry.name] : entry;
-    if (remoteLock && !remotePin) {
-      diff.skipped.push(entry.name);
-      continue;
-    }
-    const pinnedLocally = pin && pin.version === entry.version && pin.sha256 === entry.sha256;
-    if (pinnedLocally) {
-      diff.unchanged.push(entry.name);
-    } else if (pin) {
-      diff.updated.push(entry.name);
+    if (remoteLock) {
+      const remotePin = remoteLock.hooks[entry.name];
+      if (!remotePin) {
+        diff.skipped.push(entry.name);
+        continue;
+      }
+      if (remotePin.version !== entry.version) {
+        throw new Error(`remote registry is ambiguous for '${entry.name}': lock pins ${remotePin.version} but catalog latest is ${entry.version}. ` + `Fix the registry (or its lock) before syncing \u2014 nothing was changed.`);
+      }
+      diff[classifyRemotePin(pin, remotePin.version, remotePin.sha256)].push(entry.name);
     } else {
-      diff.added.push(entry.name);
+      diff[classifyRemotePin(pin, entry.version, entry.sha256)].push(entry.name);
     }
   }
   return diff;
 }
-async function planSync() {
+async function planSync(options = {}) {
   const apiUrl = resolveApiUrl();
   if (apiUrl) {
     const { catalog, remoteLock } = await fetchRemoteState(apiUrl);
-    return { apiUrl, dryRun: false, diff: computeDiff(catalog, remoteLock) };
+    return { apiUrl, dryRun: options.dryRun ?? false, diff: computeDiff(catalog, remoteLock) };
   }
   const diff = computeDiff(collectBundledCatalog(), null);
-  return { apiUrl: null, dryRun: false, diff };
+  return { apiUrl: null, dryRun: options.dryRun ?? false, diff };
 }
 async function syncHooks(options = {}) {
   const apiUrl = resolveApiUrl();
@@ -6156,10 +6465,10 @@ async function syncHooks(options = {}) {
   if (options.dryRun)
     return { ...plan, dryRun: true };
   if (!apiUrl) {
-    const db2 = getDb();
+    const db = getDb();
     for (const entry of collectBundledCatalog()) {
       setPinnedHook(entry.name, { version: entry.version, sha256: entry.sha256, source: "bundled" });
-      upsertHookRecord(db2, {
+      upsertHookRecord(db, {
         name: entry.name,
         version: entry.version,
         sha256: entry.sha256,
@@ -6172,13 +6481,17 @@ async function syncHooks(options = {}) {
   }
   const { catalog, remoteLock } = await fetchRemoteState(apiUrl);
   const diff = computeDiff(catalog, remoteLock);
-  const toFetch = [...diff.added, ...diff.updated];
-  const artifacts = new Map;
-  for (const name of toFetch) {
+  const staged = await stageSyncArtifacts(apiUrl, [...diff.added, ...diff.updated], remoteLock);
+  await commitSyncArtifacts(staged, apiUrl, remoteLock);
+  return { apiUrl, dryRun: false, diff };
+}
+async function stageSyncArtifacts(apiUrl, names, remoteLock) {
+  const staged = [];
+  for (const name of names) {
     const entry = remoteLock.hooks[name];
     if (!entry)
       continue;
-    const artifact = await fetchJson(apiUrl, `/api/v1/hooks/${name}/${entry.version}`);
+    const artifact = await fetchJson(apiUrl, `/api/v1/hooks/${encodeURIComponent(name)}/${encodeURIComponent(entry.version)}`);
     if (!artifact.manifest || typeof artifact.script !== "string") {
       throw new Error(`artifact for '${name}@${entry.version}' is malformed`);
     }
@@ -6186,34 +6499,64 @@ async function syncHooks(options = {}) {
     if (actualSha !== entry.sha256) {
       throw new Error(`sha256 mismatch for '${name}@${entry.version}': lock says ${entry.sha256}, artifact has ${actualSha}`);
     }
-    artifacts.set(name, artifact);
-  }
-  const db = getDb();
-  for (const name of toFetch) {
-    const artifact = artifacts.get(name);
-    const entry = remoteLock.hooks[name];
-    if (!artifact || !entry)
-      continue;
     const manifest = parseManifest(JSON.stringify({ ...artifact.manifest, name: shortManifestName(artifact.manifest.name || name) }));
-    const scriptRel = artifact.manifest.script.includes(`
-`) ? "script.ts" : artifact.manifest.script;
-    writeCustomHook(name, manifest, artifact.script, scriptRel);
-    const scriptPath = resolveScriptPath(name);
-    const actual = await sha256File(scriptPath);
-    if (actual !== entry.sha256) {
-      throw new Error(`sha256 mismatch after write for '${name}@${entry.version}': lock says ${entry.sha256}, on disk ${actual}`);
+    if (manifest.version !== entry.version) {
+      throw new Error(`artifact for '${name}@${entry.version}' declares a different version ('${manifest.version}')`);
     }
-    setPinnedHook(name, { version: entry.version, sha256: entry.sha256, source: entry.source ?? "remote" });
-    upsertHookRecord(db, {
+    const scriptRel = scriptRelFor(manifest);
+    staged.push({
       name,
       version: entry.version,
       sha256: entry.sha256,
-      source_type: entry.source ?? "remote",
-      source_ref: apiUrl,
-      last_verified_at: new Date().toISOString()
+      source: entry.source ?? "remote",
+      manifest,
+      scriptContent: artifact.script,
+      scriptRel
     });
   }
-  return { apiUrl, dryRun: false, diff };
+  return staged;
+}
+async function commitSyncArtifacts(staged, apiUrl, remoteLock) {
+  const db = getDb();
+  for (const item of staged) {
+    const entry = remoteLock.hooks[item.name];
+    if (!entry)
+      continue;
+    writeCustomHook(item.name, item.manifest, item.scriptContent, item.scriptRel);
+    const scriptPath = resolveScriptPath(item.name);
+    const actual = await sha256File(scriptPath);
+    if (actual !== entry.sha256) {
+      throw new Error(`sha256 mismatch after write for '${item.name}@${entry.version}': lock says ${entry.sha256}, on disk ${actual}`);
+    }
+  }
+  const lock = readLock();
+  for (const item of staged) {
+    const entry = remoteLock.hooks[item.name];
+    if (!entry)
+      continue;
+    lock.hooks[item.name] = { version: entry.version, sha256: entry.sha256, source: entry.source ?? "remote" };
+  }
+  writeLock(lock);
+  db.exec("BEGIN");
+  try {
+    for (const item of staged) {
+      const entry = remoteLock.hooks[item.name];
+      if (!entry)
+        continue;
+      upsertHookRecord(db, {
+        name: item.name,
+        version: entry.version,
+        sha256: entry.sha256,
+        source_type: entry.source ?? "remote",
+        source_ref: apiUrl,
+        last_verified_at: new Date().toISOString()
+      });
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
 }
 async function fetchPinnedHook(name, version, apiUrl) {
   const remoteLock = await fetchJson(apiUrl, "/api/v1/lock");
@@ -6221,10 +6564,11 @@ async function fetchPinnedHook(name, version, apiUrl) {
   if (!entry) {
     throw new Error(`Hook '${name}' is not in the remote registry lock`);
   }
-  if (entry.version !== version) {
-    throw new Error(`Hook '${name}' version ${version} is not in the remote registry (available: ${entry.version})`);
+  const isLatest = entry.version === version;
+  if (!isLatest && !(entry.versions ?? []).includes(version)) {
+    throw new Error(`Hook '${name}' version ${version} is not in the remote registry (available: ${[entry.version, ...entry.versions ?? []].join(", ")})`);
   }
-  const artifact = await fetchJson(apiUrl, `/api/v1/hooks/${name}/${version}`);
+  const artifact = await fetchJson(apiUrl, `/api/v1/hooks/${encodeURIComponent(name)}/${encodeURIComponent(version)}`, { withHeader: "_headerSha" });
   if (!artifact.manifest || typeof artifact.script !== "string") {
     throw new Error(`artifact for '${name}@${version}' is malformed`);
   }
@@ -6236,24 +6580,31 @@ async function fetchPinnedHook(name, version, apiUrl) {
     throw new Error(`artifact for '${name}@${version}' declares a different version ('${artifact.manifest.version}')`);
   }
   const actualSha = sha256OfText(artifact.script);
-  if (actualSha !== entry.sha256) {
-    throw new Error(`sha256 mismatch for '${name}@${version}': lock says ${entry.sha256}, artifact has ${actualSha}`);
+  let expectedSha = entry.sha256;
+  if (!isLatest) {
+    const headerSha = artifact._headerSha;
+    if (!headerSha) {
+      throw new Error(`registry did not return a sha256 header for '${name}@${version}' (older pin); refusing to trust an unverified artifact`);
+    }
+    expectedSha = headerSha;
+  }
+  if (actualSha !== expectedSha) {
+    throw new Error(`sha256 mismatch for '${name}@${version}': expected ${expectedSha}, artifact has ${actualSha}`);
   }
   const manifest = parseManifest(JSON.stringify({ ...artifact.manifest, name: shortManifestName(artifact.manifest.name || name) }));
-  const scriptRel = artifact.manifest.script.includes(`
-`) ? "script.ts" : artifact.manifest.script;
+  const scriptRel = scriptRelFor(manifest);
   writeCustomHook(name, manifest, artifact.script, scriptRel);
   const scriptPath = resolveScriptPath(name);
   const actual = await sha256File(scriptPath);
-  if (actual !== entry.sha256) {
-    throw new Error(`sha256 mismatch after write for '${name}@${version}': lock says ${entry.sha256}, on disk ${actual}`);
+  if (actual !== expectedSha) {
+    throw new Error(`sha256 mismatch after write for '${name}@${version}': expected ${expectedSha}, on disk ${actual}`);
   }
   const db = getDb();
-  setPinnedHook(name, { version, sha256: entry.sha256, source: entry.source ?? "remote" });
+  setPinnedHook(name, { version, sha256: expectedSha, source: entry.source ?? "remote", pinned: true });
   upsertHookRecord(db, {
     name,
     version,
-    sha256: entry.sha256,
+    sha256: expectedSha,
     source_type: entry.source ?? "remote",
     source_ref: apiUrl,
     last_verified_at: new Date().toISOString()
@@ -6261,7 +6612,7 @@ async function fetchPinnedHook(name, version, apiUrl) {
   return {
     name,
     version,
-    sha256: entry.sha256,
+    sha256: expectedSha,
     source: entry.source ?? "remote",
     source_ref: apiUrl,
     artifact,
@@ -6286,7 +6637,7 @@ var init_pg_migrations = __esm(() => {
     timestamp    TEXT NOT NULL,
     session_id   TEXT NOT NULL,
     hook_name    TEXT NOT NULL,
-    event_type   TEXT NOT NULL CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit')),
+    event_type   TEXT NOT NULL CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit', 'SubagentStart')),
     tool_name    TEXT,
     tool_input   TEXT,
     result       TEXT CHECK (result IN ('continue', 'block', NULL)),
@@ -6319,7 +6670,10 @@ var init_pg_migrations = __esm(() => {
   )`,
     `ALTER TABLE hook_events DROP CONSTRAINT IF EXISTS hook_events_event_type_check`,
     `ALTER TABLE hook_events ADD CONSTRAINT hook_events_event_type_check
-    CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit'))`
+    CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit'))`,
+    `ALTER TABLE hook_events DROP CONSTRAINT IF EXISTS hook_events_event_type_check`,
+    `ALTER TABLE hook_events ADD CONSTRAINT hook_events_event_type_check
+    CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit', 'SubagentStart'))`
   ];
 });
 
@@ -6334,7 +6688,34 @@ function normalizeParams(params) {
   return flat.map((value) => value === undefined ? null : value);
 }
 function sslConfigFor(connectionString) {
-  return connectionString.includes("sslmode=require") || connectionString.includes("ssl=true") ? { rejectUnauthorized: false } : undefined;
+  const wantsSsl = wantsSslFor(connectionString);
+  if (!wantsSsl)
+    return;
+  const insecure = process.env.HASNA_HOOKS_PG_INSECURE_TLS === "1" || process.env.HOOKS_PG_INSECURE_TLS === "1";
+  if (insecure && false) {}
+  return insecure ? { rejectUnauthorized: false } : { rejectUnauthorized: true };
+}
+function wantsSslFor(connectionString) {
+  let raw;
+  try {
+    raw = new URL(connectionString).search.replace(/^\?/, "");
+  } catch {
+    raw = connectionString;
+  }
+  try {
+    raw = decodeURIComponent(raw);
+  } catch {}
+  const paramValue = (name) => {
+    const match = raw.match(new RegExp(`(?:^|[&\\s])${name}\\s*=\\s*([^&\\s]+)`, "i"));
+    return match ? match[1].toLowerCase() : undefined;
+  };
+  const sslmode = paramValue("sslmode");
+  if (sslmode !== undefined)
+    return sslmode !== "disable" && sslmode !== "allow";
+  const ssl = paramValue("ssl");
+  if (ssl !== undefined)
+    return ssl !== "false" && ssl !== "0" && ssl !== "no";
+  return false;
 }
 
 class PgAdapterAsync {
@@ -6496,9 +6877,15 @@ async function pushTable(db, remote, table) {
     result.rowsRead = rows.length;
     if (rows.length === 0)
       return result;
+    const projected = table === "hook_events" ? rows.map((row) => ({
+      ...row,
+      tool_input: typeof row.tool_input === "string" ? redactEventPayload(row.tool_input) : row.tool_input,
+      error: typeof row.error === "string" ? redactEventPayload(row.error) : row.error,
+      metadata: typeof row.metadata === "string" ? redactEventPayload(row.metadata) : row.metadata
+    })) : rows;
     const remoteColumns = await getRemoteColumns(remote, table);
-    const columns = filterRemoteColumns(remoteColumns, Object.keys(rows[0]));
-    result.rowsWritten = await upsertPg(remote, table, columns, rows, remoteColumns);
+    const columns = filterRemoteColumns(remoteColumns, Object.keys(projected[0]));
+    result.rowsWritten = await upsertPg(remote, table, columns, projected, remoteColumns);
   } catch (error) {
     result.errors.push(error instanceof Error ? error.message : String(error));
   }
@@ -6513,8 +6900,14 @@ async function pullTable(remote, db, table) {
     result.rowsRead = rows.length;
     if (rows.length === 0)
       return result;
-    const columns = filterLocalColumns(db, table, Object.keys(rows[0]));
-    result.rowsWritten = upsertSqlite(db, table, columns, rows);
+    const projected = table === "hook_events" ? rows.map((row) => ({
+      ...row,
+      tool_input: typeof row.tool_input === "string" ? redactEventPayload(row.tool_input) : row.tool_input,
+      error: typeof row.error === "string" ? redactEventPayload(row.error) : row.error,
+      metadata: typeof row.metadata === "string" ? redactEventPayload(row.metadata) : row.metadata
+    })) : rows;
+    const columns = filterLocalColumns(db, table, Object.keys(projected[0]));
+    result.rowsWritten = upsertSqlite(db, table, columns, projected);
   } catch (error) {
     result.errors.push(error instanceof Error ? error.message : String(error));
   }
@@ -6637,6 +7030,7 @@ var init_storage_sync = __esm(() => {
   init_db();
   init_pg_migrations();
   init_remote_storage();
+  init_redact();
   STORAGE_TABLES = [
     "hook_events",
     "schema_migrations",
@@ -6735,24 +7129,29 @@ async function buildCatalog() {
     const scriptPath = resolveHook(meta.name)?.scriptPath;
     if (!scriptPath)
       continue;
+    const sha = await sha256File(scriptPath);
     byName.set(meta.name, {
       name: meta.name,
       version: meta.version,
-      sha256: await sha256File(scriptPath),
+      sha256: sha,
       events: meta.events && meta.events.length > 0 ? meta.events : [meta.event],
       description: meta.description,
-      source: "bundled"
+      source: "bundled",
+      versions: [meta.version]
     });
   }
   for (const custom of listCustomHooks()) {
     const name = shortManifestName(custom.manifest.name);
+    const sha = await sha256File(custom.scriptPath);
+    const existing = byName.get(name);
     byName.set(name, {
       name,
       version: custom.manifest.version,
-      sha256: await sha256File(custom.scriptPath),
+      sha256: sha,
       events: custom.manifest.events,
       description: custom.manifest.description ?? "Custom hook",
-      source: byName.has(name) ? "custom-overrides-bundled" : "custom"
+      source: existing ? "custom-overrides-bundled" : "custom",
+      versions: existing ? [...new Set([...existing.versions, custom.manifest.version])] : [custom.manifest.version]
     });
   }
   return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
@@ -6770,6 +7169,7 @@ async function artifactFor(name, version) {
     description: resolved.description,
     events: resolved.events,
     script: custom ? custom.manifest.script : `src/hook.ts`,
+    script_kind: custom?.manifest.script_kind,
     args: custom?.manifest.args,
     timeout_ms: custom?.manifest.timeout_ms
   };
@@ -6799,11 +7199,32 @@ function handleServeRequest(req, apiKey) {
     return buildCatalog().then((catalog) => json({ hooks: catalog }));
   }
   if (url.pathname === "/api/v1/lock" && req.method === "GET") {
-    return Promise.resolve(json(readLock()));
+    return buildCatalog().then((catalog) => {
+      const lock = readLock();
+      const byVersion = {};
+      for (const entry of catalog)
+        byVersion[entry.name] = entry.versions;
+      const hooks = {};
+      for (const [name, pin] of Object.entries(lock.hooks)) {
+        hooks[name] = { ...pin, versions: byVersion[name] ?? [pin.version] };
+      }
+      return json({ hooks });
+    });
   }
-  const artifactMatch = /^\/api\/v1\/hooks\/([\w-]+)\/(\d+\.\d+\.\d+)$/.exec(url.pathname);
+  const artifactMatch = /^\/api\/v1\/hooks\/([\w-]+)\/([0-9A-Za-z.%+_-]+)$/.exec(url.pathname);
   if (artifactMatch && req.method === "GET") {
-    const [, name, version] = artifactMatch;
+    const [, rawName, rawVersion] = artifactMatch;
+    let name;
+    let version;
+    try {
+      name = decodeURIComponent(rawName);
+      version = decodeURIComponent(rawVersion);
+    } catch {
+      return Promise.resolve(json({ error: "invalid URL encoding" }, 400));
+    }
+    if (!SEMVER_PATTERN.test(version)) {
+      return Promise.resolve(json({ error: `invalid semver version '${version}'` }, 400));
+    }
     return artifactFor(name, version).then(async (artifact) => {
       if (!artifact)
         return json({ error: `Hook '${name}@${version}' not found locally` }, 404);
@@ -6834,7 +7255,7 @@ function handleServeRequest(req, apiKey) {
 function startServeServer(options) {
   const port = options.port ?? DEFAULT_SERVE_PORT;
   const host = options.host ?? SERVE_HOST;
-  const apiKey = resolveApiKey(options.apiKey);
+  const apiKey = resolveApiKey();
   const server = Bun.serve({
     hostname: host,
     port,
@@ -6852,6 +7273,7 @@ var init_serve = __esm(() => {
   init_store();
   init_resolve();
   init_config();
+  init_semver();
   if (false) {}
 });
 
@@ -6941,7 +7363,9 @@ var exports_server = {};
 __export(exports_server, {
   startStdioServer: () => startStdioServer,
   startSSEServer: () => startSSEServer,
+  sseAuthToken: () => sseAuthToken,
   createHooksServer: () => createHooksServer,
+  MCP_SSE_HOST: () => MCP_SSE_HOST,
   MCP_PORT: () => MCP_PORT
 });
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -6949,14 +7373,14 @@ import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z2 } from "zod";
 import { createServer } from "http";
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { join as join11, dirname as dirname5 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { join as join11, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath3 } 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 || !existsSync11(hookScript)) {
+  if (!resolved || !hookScript || !existsSync12(hookScript)) {
     throw new Error(`Hook '${name}' not found`);
   }
   const content = readFileSync9(hookScript);
@@ -6969,7 +7393,7 @@ async function runVerifiedHook(name, stdin, timeoutMs) {
   const started = Date.now();
   let ran;
   try {
-    ran = await executeVerifiedScript2({ name, scriptPath: hookScript, content, stdin, env: process.env, timeout: timeoutMs });
+    ran = await executeVerifiedScript2({ name, scriptPath: hookScript, content, stdin, timeout: timeoutMs });
   } catch (err) {
     try {
       const { recordHookRun: recordHookRun2, resolveEventType: resolveEventType2 } = await Promise.resolve().then(() => (init_db_writer(), exports_db_writer));
@@ -7075,6 +7499,9 @@ function compactEvent(row) {
     tool_input_preview: row.tool_input ? truncateText(row.tool_input, 180) : undefined
   };
 }
+function projectLogRows(rows) {
+  return rows.map((row) => projectEventRowForRead({ ...row }));
+}
 function createHooksServer() {
   const server = new McpServer({
     name: "@hasna/hooks",
@@ -7161,7 +7588,7 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     const issues = [];
     const healthy = [];
-    const settingsExist = existsSync11(settingsPath);
+    const settingsExist = existsSync12(settingsPath);
     if (!settingsExist) {
       issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
     }
@@ -7171,7 +7598,7 @@ function createHooksServer() {
       const meta = custom ? resolveHookMeta(name) : getHook(name);
       let hookHealthy = true;
       if (custom) {
-        if (!existsSync11(custom.scriptPath)) {
+        if (!existsSync12(custom.scriptPath)) {
           issues.push({ hook: name, issue: `Custom hook script missing: ${custom.scriptPath}`, severity: "error" });
           hookHealthy = false;
         }
@@ -7181,7 +7608,7 @@ function createHooksServer() {
           continue;
         }
         const hookDir = getHookPath(name);
-        if (!existsSync11(join11(hookDir, "src", "hook.ts"))) {
+        if (!existsSync12(join11(hookDir, "src", "hook.ts"))) {
           issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
           hookHealthy = false;
         }
@@ -7220,7 +7647,7 @@ function createHooksServer() {
       const hookPath = getHookPath(name);
       const readmePath = join11(hookPath, "README.md");
       let readme = "";
-      if (existsSync11(readmePath)) {
+      if (existsSync12(readmePath)) {
         readme = readFileSync9(readmePath, "utf-8");
       }
       if (verbose) {
@@ -7404,7 +7831,7 @@ function createHooksServer() {
     const ctx = {
       scope,
       settings_path: settingsPath,
-      settings_exists: existsSync11(settingsPath),
+      settings_exists: existsSync12(settingsPath),
       registered_hooks: hooks,
       hook_count: hooks.length,
       healthy,
@@ -7456,7 +7883,13 @@ function createHooksServer() {
       } catch (err) {
         const { HookTimeoutError: HookTimeoutError2 } = await Promise.resolve().then(() => (init_run(), exports_run));
         if (err instanceof HookTimeoutError2) {
-          return { name, decision: "approve", timedOut: true, timeout_ms: effectiveTimeout };
+          return {
+            name,
+            decision: "block",
+            timedOut: true,
+            timeout_ms: effectiveTimeout,
+            error: `hook timed out after ${effectiveTimeout}ms \u2014 preview blocked (never auto-approved)`
+          };
         }
         return { name, decision: "block", error: err instanceof Error ? err.message : String(err) };
       }
@@ -7482,15 +7915,25 @@ function createHooksServer() {
     hooks: z2.array(z2.string()).optional().describe("Hook names to install (omit for sensible defaults: gitguard, checkpoint, checktests, protectfiles)"),
     scope: z2.enum(["global", "project"]).default("global").describe("Install scope")
   }, async ({ agent_type, name, hooks, scope }) => {
+    if (agent_type !== "claude" && agent_type !== "gemini" && agent_type !== "custom") {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: `unsupported agent_type '${String(agent_type)}' (supported: claude, gemini, custom)` })
+        }],
+        isError: true
+      };
+    }
     const profile = createProfile({ agent_type, name });
+    const target = agent_type === "gemini" ? "gemini" : "claude";
     const toInstall = hooks && hooks.length > 0 ? hooks : ["gitguard", "checkpoint", "checktests", "protectfiles"];
-    const results = toInstall.map((h) => installHook(h, { scope, overwrite: false, profile: profile.agent_id }));
+    const results = toInstall.map((h) => installHook(h, { scope, overwrite: false, profile: profile.agent_id, target }));
     const installed = results.filter((r) => r.success).map((r) => r.hook);
     const failed = results.filter((r) => !r.success).map((r) => ({ hook: r.hook, error: r.error }));
     return {
       content: [{
         type: "text",
-        text: JSON.stringify({ profile, installed, failed, scope, run_with: `hooks run <name> --profile ${profile.agent_id}` })
+        text: JSON.stringify({ profile, installed, failed, scope, target, run_with: `hooks run <name> --profile ${profile.agent_id}` })
       }]
     };
   });
@@ -7534,7 +7977,7 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     let settings = {};
     try {
-      if (existsSync11(settingsPath))
+      if (existsSync12(settingsPath))
         settings = JSON.parse(readFileSync9(settingsPath, "utf-8"));
     } catch {}
     if (!settings.hooks)
@@ -7544,8 +7987,8 @@ function createHooksServer() {
       disabled.push(name);
     settings.hooks.__disabled = disabled;
     const { writeFileSync: writeFileSync7, mkdirSync: mkdirSync8 } = await import("fs");
-    const { dirname: dirname6 } = await import("path");
-    mkdirSync8(dirname6(settingsPath), { recursive: true });
+    const { dirname: dirname7 } = await import("path");
+    mkdirSync8(dirname7(settingsPath), { recursive: true });
     writeFileSync7(settingsPath, JSON.stringify(settings, null, 2) + `
 `);
     return { content: [{ type: "text", text: JSON.stringify({ hook: name, disabled: true, scope }) }] };
@@ -7557,7 +8000,7 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     let settings = {};
     try {
-      if (existsSync11(settingsPath))
+      if (existsSync12(settingsPath))
         settings = JSON.parse(readFileSync9(settingsPath, "utf-8"));
     } catch {}
     if (settings.hooks?.__disabled) {
@@ -7642,12 +8085,13 @@ function createHooksServer() {
     sql += " ORDER BY timestamp DESC LIMIT ?";
     params.push(maxRows);
     const rows = db.query(sql).all(...params);
+    const projected = projectLogRows(rows);
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
-          events: compact ? rows.map(compactEvent) : rows,
-          count: rows.length,
+          events: compact ? projected.map(compactEvent) : projected,
+          count: projected.length,
           compact,
           hint: compact ? "Use compact:false for full tool_input/output fields." : undefined
         })
@@ -7662,12 +8106,13 @@ function createHooksServer() {
     const db = getDb2();
     const maxRows = boundedLimit(n, 20, compact ? 100 : 500);
     const rows = db.query("SELECT * FROM hook_events ORDER BY timestamp DESC LIMIT ?").all(maxRows);
+    const projected = projectLogRows(rows);
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
-          events: compact ? rows.map(compactEvent) : rows,
-          count: rows.length,
+          events: compact ? projected.map(compactEvent) : projected,
+          count: projected.length,
           compact,
           hint: compact ? "Use compact:false for full tool_input/output fields." : undefined
         })
@@ -7692,12 +8137,13 @@ function createHooksServer() {
     }
     const ts = since.match(/^\d{4}/) ? since : parseDuration(since);
     const rows = db.query("SELECT * FROM hook_events WHERE error IS NOT NULL AND timestamp >= ? ORDER BY timestamp DESC LIMIT ?").all(ts, maxRows);
+    const projected = projectLogRows(rows);
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
-          events: compact ? rows.map(compactEvent) : rows,
-          count: rows.length,
+          events: compact ? projected.map(compactEvent) : projected,
+          count: projected.length,
           compact,
           hint: compact ? "Use compact:false for full tool_input/output fields." : undefined
         })
@@ -7825,11 +8271,48 @@ function createHooksServer() {
   });
   return server;
 }
-async function startSSEServer(port = MCP_PORT) {
+function isLoopbackHost(host) {
+  return host === "" || host === "127.0.0.1" || host === "::1" || host === "localhost";
+}
+function sseAuthToken(explicit) {
+  if (explicit && explicit.length > 0)
+    return explicit;
+  for (const name of MCP_SSE_AUTH_ENV) {
+    const value = process.env[name];
+    if (value && value.length > 0)
+      return value;
+  }
+  return;
+}
+async function startSSEServer(options = {}) {
+  const port = options.port ?? MCP_PORT;
+  const host = options.host ?? MCP_SSE_HOST;
+  const authToken = sseAuthToken(options.authToken);
+  const loopback = isLoopbackHost(host);
+  if (!loopback && !authToken) {
+    throw new Error(`Refusing to serve MCP SSE on non-loopback host '${host}' without an auth token. Set HASNA_HOOKS_MCP_TOKEN (or HOOKS_MCP_TOKEN) to authorize a non-loopback bind.`);
+  }
   const server = createHooksServer();
   const transports = new Map;
+  function authorized2(headers) {
+    if (!authToken)
+      return false;
+    const rawAuth = headers["authorization"];
+    const header = (Array.isArray(rawAuth) ? rawAuth[0] : rawAuth) ?? "";
+    if (header.startsWith("Bearer "))
+      return secureEqual(header.slice("Bearer ".length), authToken);
+    const rawKey = headers["x-api-key"];
+    return secureEqual((Array.isArray(rawKey) ? rawKey[0] : rawKey) ?? "", authToken);
+  }
   const httpServer = createServer(async (req, res) => {
     const url = new URL(req.url || "/", `http://localhost:${port}`);
+    if (url.pathname === "/sse" || url.pathname === "/messages") {
+      if (authToken && !authorized2(req.headers)) {
+        res.writeHead(401);
+        res.end("unauthorized: valid MCP token required");
+        return;
+      }
+    }
     if (url.pathname === "/sse") {
       const transport = new SSEServerTransport("/messages", res);
       transports.set(transport.sessionId, transport);
@@ -7852,9 +8335,9 @@ async function startSSEServer(port = MCP_PORT) {
       res.end(JSON.stringify({ name: "@hasna/hooks", version: pkg.version, transport: "sse", port }));
     }
   });
-  httpServer.listen(port, () => {
-    console.error(`@hasna/hooks MCP server running on http://localhost:${port}`);
-    console.error(`SSE endpoint: http://localhost:${port}/sse`);
+  httpServer.listen(port, host, () => {
+    console.error(`@hasna/hooks MCP server running on http://${host}:${port}`);
+    console.error(`SSE endpoint: http://${host}:${port}/sse`);
   });
 }
 async function startStdioServer() {
@@ -7868,7 +8351,7 @@ async function startStdioServer() {
     process.exit(1);
   }
 }
-var __dirname3, pkg, MCP_PORT = 39427, _hooksAgents;
+var __dirname3, pkg, MCP_PORT = 39427, _hooksAgents, MCP_SSE_HOST = "127.0.0.1", MCP_SSE_AUTH_ENV;
 var init_server = __esm(() => {
   init_registry();
   init_installer();
@@ -7876,19 +8359,21 @@ var init_server = __esm(() => {
   init_manifest();
   init_resolve();
   init_store();
+  init_redact();
   init_storage();
-  __dirname3 = dirname5(fileURLToPath3(import.meta.url));
+  __dirname3 = dirname6(fileURLToPath3(import.meta.url));
   pkg = { name: "@hasna/hooks", version: "0.0.0" };
   try {
     for (const rel of ["../../package.json", "../package.json", "../../../package.json"]) {
       const p = join11(__dirname3, rel);
-      if (existsSync11(p)) {
+      if (existsSync12(p)) {
         pkg = JSON.parse(readFileSync9(p, "utf-8"));
         break;
       }
     }
   } catch {}
   _hooksAgents = new Map;
+  MCP_SSE_AUTH_ENV = ["HASNA_HOOKS_MCP_TOKEN", "HOOKS_MCP_TOKEN"];
 });
 
 // src/mcp/http.ts
@@ -7950,7 +8435,7 @@ function startMcpHttpServer(options) {
 var DEFAULT_MCP_HTTP_PORT = 8847, MCP_HTTP_HOST = "127.0.0.1", MCP_SERVICE_NAME = "hooks";
 var init_http = () => {};
 
-// ../../node_modules/.bun/@hasna+events@0.1.15/node_modules/@hasna/events/dist/commander.js
+// ../events/dist/commander.js
 import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
 import { Buffer as Buffer2 } from "buffer";
 import { existsSync } from "fs";
@@ -9153,8 +9638,8 @@ var {
 
 // src/cli/index.tsx
 import chalk2 from "chalk";
-import { existsSync as existsSync12, readFileSync as readFileSync10, rmSync as rmSync5 } from "fs";
-import { join as join12, dirname as dirname6 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync10, rmSync as rmSync5 } from "fs";
+import { join as join12, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/cli/components/App.tsx
@@ -10329,13 +10814,15 @@ function App({ initialHooks, overwrite = false }) {
 // src/cli/index.tsx
 init_registry();
 init_installer();
+init_redact();
 init_profiles();
 init_manifest();
 init_resolve();
 init_store();
+init_semver();
 import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
-var __dirname4 = dirname6(fileURLToPath4(import.meta.url));
-var pkgPath = existsSync12(join12(__dirname4, "..", "package.json")) ? join12(__dirname4, "..", "package.json") : join12(__dirname4, "..", "..", "package.json");
+var __dirname4 = dirname7(fileURLToPath4(import.meta.url));
+var pkgPath = existsSync13(join12(__dirname4, "..", "package.json")) ? join12(__dirname4, "..", "package.json") : join12(__dirname4, "..", "..", "package.json");
 var pkg2 = JSON.parse(readFileSync10(pkgPath, "utf-8"));
 var program2 = new Command;
 function resolveScope(options) {
@@ -10364,6 +10851,9 @@ function truncateText2(value, max = 96) {
     return text;
   return `${text.slice(0, Math.max(0, max - 3))}...`;
 }
+function projectLogRows2(rows) {
+  return rows.map((row) => projectEventRowForRead({ ...row }));
+}
 function readToken(tokenFile) {
   if (tokenFile) {
     try {
@@ -10500,7 +10990,7 @@ program2.command("run").argument("<hook>", "Hook to run").option("--profile <id>
     process.exit(1);
   }
   const hookScript = resolveScriptPath2(hook);
-  if (!hookScript || !existsSync12(hookScript)) {
+  if (!hookScript || !existsSync13(hookScript)) {
     console.error(JSON.stringify({ error: `Hook script not found: ${hookScript ?? hook}` }));
     process.exit(1);
   }
@@ -10625,6 +11115,7 @@ program2.command("install").alias("add").argument("[hooks...]", "Hooks to instal
         console.log(chalk2.red(`Unknown category: ${options.category}`));
         console.log(chalk2.dim(`Available: ${CATEGORIES.join(", ")}`));
       }
+      process.exitCode = 1;
       return;
     }
     toInstall = getHooksByCategory(category).map((h) => h.name);
@@ -10657,7 +11148,7 @@ program2.command("install").alias("add").argument("[hooks...]", "Hooks to instal
     const version = arg.slice(at + 1);
     if (!HOOK_NAME_RE2.test(name))
       return null;
-    if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version))
+    if (!SEMVER_PATTERN.test(version))
       return null;
     return { name, version };
   }
@@ -10791,7 +11282,7 @@ Dry run \u2014 would install (${scope}, ${target}):
       target,
       applied: results.some((r) => r.applied)
     }));
-    if (results.length > 0 && results.every((r) => !r.success)) {
+    if (results.some((r) => !r.success)) {
       process.exitCode = 1;
     }
     return;
@@ -10829,6 +11320,11 @@ Installing hooks (${scope}, ${target})...
     process.exitCode = 1;
     return;
   }
+  if (successCount < results.length) {
+    console.log(chalk2.red(`
+\u2717 ${results.length - successCount} of ${results.length} hook(s) failed to install.`));
+    process.exitCode = 1;
+  }
   console.log(chalk2.dim(`
 Registered in ${settingsFile}`));
 });
@@ -11024,6 +11520,7 @@ program2.command("info").argument("<hook>", "Hook name").option("-j, --json", "O
     } else {
       console.log(chalk2.red(`Hook '${hook}' not found${hint}`));
     }
+    process.exitCode = 1;
     return;
   }
   const globalInstalled = getRegisteredHooks("global").includes(meta.name);
@@ -11065,17 +11562,24 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
   const settingsPath = getSettingsPath(scope);
   const issues = [];
   const healthy = [];
-  const settingsExist = existsSync12(settingsPath);
+  const settingsExist = existsSync13(settingsPath);
   if (!settingsExist) {
     issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
   }
   const registered = getRegisteredHooks(scope);
+  let wiringCount = 0;
+  if (settingsExist) {
+    try {
+      const settings = JSON.parse(readFileSync10(settingsPath, "utf-8"));
+      wiringCount = countSettingsWiring(settings);
+    } catch {}
+  }
   for (const name of registered) {
     const custom = readCustomManifest(name);
     const meta = custom ? resolveHookMeta(name) : getHook(name);
     let hookHealthy = true;
     if (custom) {
-      if (!existsSync12(custom.scriptPath)) {
+      if (!existsSync13(custom.scriptPath)) {
         issues.push({ hook: name, issue: `Custom hook script missing: ${custom.scriptPath}`, severity: "error" });
         hookHealthy = false;
       }
@@ -11087,7 +11591,7 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
       }
       const hookDir = getHookPath(name);
       const hookScript = join12(hookDir, "src", "hook.ts");
-      if (!existsSync12(hookScript)) {
+      if (!existsSync13(hookScript)) {
         issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
         hookHealthy = false;
       }
@@ -11107,7 +11611,7 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
     }
   }
   if (options.json) {
-    console.log(JSON.stringify({ healthy: issues.length === 0, healthy_hooks: healthy, issues, registered, scope }));
+    console.log(JSON.stringify({ healthy: issues.length === 0, healthy_hooks: healthy, issues, registered, wiring_count: wiringCount, scope }));
     return;
   }
   console.log(chalk2.bold(`
@@ -11116,6 +11620,9 @@ Hook Health Check (${scope})
   if (registered.length === 0) {
     console.log(chalk2.dim("  No hooks registered."));
     console.log(chalk2.dim("  Run: hooks install gitguard"));
+    console.log(chalk2.dim(`  (checked 0 registered \`hooks run\` entries of ${wiringCount} settings wiring entries; direct-path wiring outside the registered surface is not covered by this check)`));
+    if (issues.length > 0)
+      process.exitCode = 1;
     return;
   }
   if (healthy.length > 0) {
@@ -11124,6 +11631,9 @@ Hook Health Check (${scope})
       console.log(chalk2.green(`    ${name}`));
     }
   }
+  if (registered.length > 0) {
+    console.log(chalk2.dim(`  (checked ${registered.length} registered \`hooks run\` entries of ${wiringCount} settings wiring entries; direct-path wiring outside the registered surface is not covered by this check)`));
+  }
   if (issues.length > 0) {
     console.log();
     for (const issue of issues) {
@@ -11131,9 +11641,11 @@ Hook Health Check (${scope})
       console.log(`  ${icon} ${chalk2.cyan(issue.hook)}: ${issue.issue}`);
     }
   }
-  if (issues.length === 0) {
+  if (issues.length === 0 && registered.length > 0) {
     console.log(chalk2.green(`
-  All hooks healthy!`));
+  All ${healthy.length} registered hook(s) healthy`));
+  } else if (issues.some((i) => i.severity === "error")) {
+    process.exitCode = 1;
   }
   console.log();
 });
@@ -11166,7 +11678,7 @@ program2.command("update").argument("[hooks...]", "Hooks to update (defaults to
     const version = arg.slice(at + 1);
     if (!HOOK_NAME_RE2.test(name))
       return null;
-    if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version))
+    if (!SEMVER_PATTERN.test(version))
       return null;
     return { name, version };
   }
@@ -11249,12 +11761,13 @@ program2.command("docs").argument("[hook]", "Hook name (shows general docs if om
       } else {
         console.log(chalk2.red(`Hook '${hook}' not found`));
       }
+      process.exitCode = 1;
       return;
     }
     const hookPath = getHookPath(hook);
     const readmePath = join12(hookPath, "README.md");
     let readme = "";
-    if (existsSync12(readmePath)) {
+    if (existsSync13(readmePath)) {
       readme = readFileSync10(readmePath, "utf-8");
     }
     if (options.json) {
@@ -11503,18 +12016,19 @@ logCmd.command("list").description("List hook events").option("--hook <name>", "
   sql += " ORDER BY timestamp DESC LIMIT ?";
   params.push(String(limit));
   const rows = db.query(sql).all(...params);
+  const projected = projectLogRows2(rows);
   if (options.json) {
-    console.log(JSON.stringify(rows, null, 2));
+    console.log(JSON.stringify(projected, null, 2));
     return;
   }
-  if (rows.length === 0) {
+  if (projected.length === 0) {
     console.log(chalk2.dim("No events found."));
     return;
   }
   console.log(chalk2.bold(`
-  Hook Events (${rows.length})
+  Hook Events (${projected.length})
 `));
-  for (const row of rows) {
+  for (const row of projected) {
     const ts = row.timestamp.slice(0, 19).replace("T", " ");
     const err = row.error ? chalk2.red(` ERR: ${truncateText2(row.error, 60)}`) : "";
     const tool = row.tool_name ? chalk2.dim(` [${row.tool_name}]`) : "";
@@ -11529,18 +12043,19 @@ logCmd.command("search <text>").description("Search hook events by tool_input or
   const limit = parseInt(options.limit) || 50;
   const q = `%${text}%`;
   const rows = db.query("SELECT * FROM hook_events WHERE tool_input LIKE ? OR error LIKE ? ORDER BY timestamp DESC LIMIT ?").all(q, q, limit);
+  const projected = projectLogRows2(rows);
   if (options.json) {
-    console.log(JSON.stringify(rows, null, 2));
+    console.log(JSON.stringify(projected, null, 2));
     return;
   }
-  if (rows.length === 0) {
+  if (projected.length === 0) {
     console.log(chalk2.dim(`No events matching "${text}".`));
     return;
   }
   console.log(chalk2.bold(`
-  Search results for "${text}" (${rows.length})
+  Search results for "${text}" (${projected.length})
 `));
-  for (const row of rows) {
+  for (const row of projected) {
     const ts = row.timestamp.slice(0, 19).replace("T", " ");
     const snippet = truncateText2(row.tool_input || row.error || "", 80);
     console.log(`  ${chalk2.dim(ts)}  ${chalk2.cyan(row.hook_name.padEnd(14))}  ${chalk2.dim(snippet)}`);
@@ -11553,18 +12068,19 @@ logCmd.command("tail").description("Show most recent hook events").option("-n <n
   const db = getDb2();
   const limit = parseInt(options.n) || 20;
   const rows = db.query("SELECT * FROM hook_events ORDER BY timestamp DESC LIMIT ?").all(limit);
+  const projected = projectLogRows2(rows);
   if (options.json) {
-    console.log(JSON.stringify(rows, null, 2));
+    console.log(JSON.stringify(projected, null, 2));
     return;
   }
-  if (rows.length === 0) {
+  if (projected.length === 0) {
     console.log(chalk2.dim("No events yet."));
     return;
   }
   console.log(chalk2.bold(`
-  Last ${rows.length} events
+  Last ${projected.length} events
 `));
-  for (const row of rows) {
+  for (const row of projected) {
     const ts = row.timestamp.slice(0, 19).replace("T", " ");
     const err = row.error ? chalk2.red(` \u2717 ${truncateText2(row.error, 60)}`) : "";
     const tool = row.tool_name ? chalk2.dim(` [${row.tool_name}]`) : "";
@@ -11597,18 +12113,19 @@ logCmd.command("errors").description("Show hook events that contain errors").opt
   }
   const since = new Date(Date.now() - parseDuration(options.since)).toISOString();
   const rows = db.query("SELECT * FROM hook_events WHERE error IS NOT NULL AND timestamp >= ? ORDER BY timestamp DESC LIMIT ?").all(since, limit);
+  const projected = projectLogRows2(rows);
   if (options.json) {
-    console.log(JSON.stringify(rows, null, 2));
+    console.log(JSON.stringify(projected, null, 2));
     return;
   }
-  if (rows.length === 0) {
+  if (projected.length === 0) {
     console.log(chalk2.dim(`No errors in the last ${options.since}.`));
     return;
   }
   console.log(chalk2.bold(`
-  Errors (last ${options.since}, ${rows.length} found)
+  Errors (last ${options.since}, ${projected.length} found)
 `));
-  for (const row of rows) {
+  for (const row of projected) {
     const ts = row.timestamp.slice(0, 19).replace("T", " ");
     console.log(`  ${chalk2.dim(ts)}  ${chalk2.cyan(row.hook_name.padEnd(14))}  ${chalk2.red(truncateText2(row.error, 100))}`);
   }
@@ -11730,18 +12247,17 @@ program2.command("trust").argument("<hook>", "Hook to trust").option("-j, --json
   console.log(chalk2.green(`\u2713 Trusted '${resolved.name}' v${resolved.version} (${resolved.source})`));
   console.log(chalk2.dim(`  sha256 ${result.actual}`));
 });
-program2.command("serve").option("-p, --port <port>", "Port (default 39428)").option("--host <host>", "Host to bind (default 127.0.0.1)").option("--api-key <key>", "API key for publish (defaults to HASNA_HOOKS_API_KEY / HOOKS_API_KEY)").description("Serve the local hook registry over HTTP (catalog, artifacts, lock)").action(async (options) => {
+program2.command("serve").option("-p, --port <port>", "Port (default 39428)").option("--host <host>", "Host to bind (default 127.0.0.1)").description("Serve the local hook registry over HTTP (catalog, artifacts, lock). The publish API key resolves from HASNA_HOOKS_API_KEY / HOOKS_API_KEY only \u2014 there is deliberately no --api-key flag (P1-8).").action(async (options) => {
   const { startServeServer: startServeServer2 } = await Promise.resolve().then(() => (init_serve(), exports_serve));
   startServeServer2({
     port: options.port ? parseInt(options.port, 10) : undefined,
-    host: options.host,
-    apiKey: options.apiKey
+    host: options.host
   });
 });
 program2.command("sync").option("--dry-run", "Print the plan without changing anything", false).option("-j, --json", "Output as JSON", false).description("Sync local hooks with the remote registry (or bundled registry when no API URL is configured)").action(async (options) => {
   const { syncHooks: syncHooks2, planSync: planSync2 } = await Promise.resolve().then(() => (init_sync(), exports_sync));
   try {
-    const plan = options.dryRun ? await planSync2() : await syncHooks2();
+    const plan = options.dryRun ? await syncHooks2({ dryRun: true }) : await syncHooks2();
     const diff = plan.diff;
     if (options.json) {
       console.log(JSON.stringify({ dry_run: plan.dryRun, api_url: plan.apiUrl ?? null, diff }));
@@ -11837,7 +12353,7 @@ program2.command("mcp").option("-s, --stdio", "Use stdio transport (one process
     await startStdioServer2();
   } else if (options.sse) {
     const { startSSEServer: startSSEServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
-    await startSSEServer2(options.port ? parseInt(options.port) : 39427);
+    await startSSEServer2({ port: options.port ? parseInt(options.port) : 39427 });
   } else {
     const { createHooksServer: createHooksServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
     const { resolveMcpHttpPort: resolveMcpHttpPort2, startMcpHttpServer: startMcpHttpServer2 } = await Promise.resolve().then(() => (init_http(), exports_http));