@hasna/hooks 0.4.1 → 0.6.0

package/bin/index.js

@@ -47,7 +47,7 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// node_modules/commander/lib/error.js
+// ../../node_modules/.bun/commander@12.1.0/node_modules/commander/lib/error.js
 var require_error = __commonJS((exports) => {
   class CommanderError extends Error {
     constructor(exitCode, code, message) {
@@ -71,7 +71,7 @@ var require_error = __commonJS((exports) => {
   exports.InvalidArgumentError = InvalidArgumentError;
 });
 
-// node_modules/commander/lib/argument.js
+// ../../node_modules/.bun/commander@12.1.0/node_modules/commander/lib/argument.js
 var require_argument = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -150,7 +150,7 @@ var require_argument = __commonJS((exports) => {
   exports.humanReadableArgName = humanReadableArgName;
 });
 
-// node_modules/commander/lib/help.js
+// ../../node_modules/.bun/commander@12.1.0/node_modules/commander/lib/help.js
 var require_help = __commonJS((exports) => {
   var { humanReadableArgName } = require_argument();
 
@@ -399,7 +399,7 @@ var require_help = __commonJS((exports) => {
   exports.Help = Help;
 });
 
-// node_modules/commander/lib/option.js
+// ../../node_modules/.bun/commander@12.1.0/node_modules/commander/lib/option.js
 var require_option = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -550,7 +550,7 @@ var require_option = __commonJS((exports) => {
   exports.DualOptions = DualOptions;
 });
 
-// node_modules/commander/lib/suggestSimilar.js
+// ../../node_modules/.bun/commander@12.1.0/node_modules/commander/lib/suggestSimilar.js
 var require_suggestSimilar = __commonJS((exports) => {
   var maxDistance = 3;
   function editDistance(a, b) {
@@ -623,7 +623,7 @@ var require_suggestSimilar = __commonJS((exports) => {
   exports.suggestSimilar = suggestSimilar;
 });
 
-// node_modules/commander/lib/command.js
+// ../../node_modules/.bun/commander@12.1.0/node_modules/commander/lib/command.js
 var require_command = __commonJS((exports) => {
   var EventEmitter = __require("events").EventEmitter;
   var childProcess = __require("child_process");
@@ -1866,7 +1866,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.Command = Command;
 });
 
-// node_modules/commander/index.js
+// ../../node_modules/.bun/commander@12.1.0/node_modules/commander/index.js
 var require_commander = __commonJS((exports) => {
   var { Argument } = require_argument();
   var { Command } = require_command();
@@ -2045,6 +2045,16 @@ var init_registry = __esm(() => {
       matcher: "Bash",
       tags: ["codewith", "bash", "secrets", "gitleaks", "risky-ops"]
     },
+    {
+      name: "scanoutput",
+      displayName: "Scan Output",
+      description: "Scans tool output for credential shapes and warns. Detection only \u2014 the output is already persisted when this runs; it cannot redact or prevent",
+      version: "0.1.0",
+      category: "Security",
+      event: "PostToolUse",
+      matcher: "Bash",
+      tags: ["security", "credentials", "secrets", "detection", "audit"]
+    },
     {
       name: "phonenotify",
       displayName: "Phone Notify",
@@ -2399,7 +2409,7 @@ var init_registry = __esm(() => {
   ];
 });
 
-// node_modules/cli-spinners/spinners.json
+// ../../node_modules/.bun/cli-spinners@2.9.2/node_modules/cli-spinners/spinners.json
 var require_spinners = __commonJS((exports, module) => {
   module.exports = {
     dots: {
@@ -4025,7 +4035,7 @@ var require_spinners = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/cli-spinners/index.js
+// ../../node_modules/.bun/cli-spinners@2.9.2/node_modules/cli-spinners/index.js
 var require_cli_spinners = __commonJS((exports, module) => {
   var spinners = Object.assign({}, require_spinners());
   var spinnersList = Object.keys(spinners);
@@ -4039,10 +4049,320 @@ var require_cli_spinners = __commonJS((exports, module) => {
   module.exports = spinners;
 });
 
-// src/lib/installer.ts
+// src/config.ts
+var exports_config = {};
+__export(exports_config, {
+  writeConfig: () => writeConfig,
+  resolveApiUrl: () => resolveApiUrl,
+  resolveApiKey: () => resolveApiKey,
+  readConfig: () => readConfig,
+  getLockPath: () => getLockPath,
+  getHooksDataDir: () => getHooksDataDir,
+  getCustomHooksDir: () => getCustomHooksDir,
+  getConfigPath: () => getConfigPath
+});
 import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join as join2, dirname } from "path";
+import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
+function getHooksDataDir() {
+  const explicit = process.env.HASNA_HOOKS_DATA_DIR ?? process.env.HOOKS_DATA_DIR;
+  if (explicit)
+    return explicit;
+  return join2(homedir2(), ".hasna", "hooks");
+}
+function getCustomHooksDir() {
+  return join2(getHooksDataDir(), "hooks");
+}
+function getLockPath() {
+  const explicit = process.env.HASNA_HOOKS_LOCK_PATH ?? process.env.HOOKS_LOCK_PATH;
+  if (explicit)
+    return explicit;
+  return join2(getHooksDataDir(), "hooks.lock");
+}
+function getConfigPath() {
+  const explicit = process.env.HASNA_HOOKS_CONFIG_PATH ?? process.env.HOOKS_CONFIG_PATH;
+  if (explicit)
+    return explicit;
+  return join2(getHooksDataDir(), "config.json");
+}
+function readConfig() {
+  try {
+    const path = getConfigPath();
+    if (!existsSync2(path))
+      return {};
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  const path = getConfigPath();
+  mkdirSync(join2(path, ".."), { recursive: true });
+  writeFileSync(path, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+  return path;
+}
+function resolveApiUrl() {
+  const envUrl = process.env.HASNA_HOOKS_API_URL ?? process.env.HOOKS_API_URL ?? process.env.HASNA_HOOKS_REGISTRY_URL ?? process.env.HOOKS_REGISTRY_URL;
+  if (envUrl)
+    return envUrl.replace(/\/+$/, "");
+  const cfg = readConfig();
+  return cfg.api_url ? cfg.api_url.replace(/\/+$/, "") : undefined;
+}
+function resolveApiKey(flagKey) {
+  if (flagKey && flagKey.length > 0)
+    return flagKey;
+  return process.env.HASNA_HOOKS_API_KEY ?? process.env.HOOKS_API_KEY;
+}
+var init_config = () => {};
+
+// src/lib/manifest.ts
+var exports_manifest = {};
+__export(exports_manifest, {
+  writeCustomHook: () => writeCustomHook,
+  shortManifestName: () => shortManifestName,
+  resolveScript: () => resolveScript,
+  readCustomManifest: () => readCustomManifest,
+  parseManifest: () => parseManifest,
+  normalizeManifestName: () => normalizeManifestName,
+  manifestSchema: () => manifestSchema,
+  listCustomHooks: () => listCustomHooks,
+  customHookDir: () => customHookDir,
+  assertContained: () => assertContained,
+  ScriptContainmentError: () => ScriptContainmentError,
+  HOOK_NAME_RE: () => HOOK_NAME_RE
+});
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, realpathSync, writeFileSync as writeFileSync2 } from "fs";
+import { basename, dirname, isAbsolute, join as join3, normalize, resolve, sep } from "path";
+import { z } from "zod";
+function parseManifest(json) {
+  const parsed = JSON.parse(json);
+  return manifestSchema.parse(parsed);
+}
+function normalizeManifestName(name) {
+  return name.startsWith("hook-") ? name : `hook-${name}`;
+}
+function shortManifestName(name) {
+  return name.startsWith("hook-") ? name.slice("hook-".length) : name;
+}
+function isWithin(child, parent) {
+  return child === parent || child.startsWith(parent + sep);
+}
+function assertContainedLexical(target, root, raw) {
+  const lexical = resolve(target);
+  const rootLexical = resolve(root);
+  if (!isWithin(lexical, rootLexical)) {
+    throw new ScriptContainmentError(target, root, raw);
+  }
+  return lexical;
+}
+function realpathNearest(path) {
+  const tail = [];
+  let cur = path;
+  while (!existsSync3(cur)) {
+    const parent = dirname(cur);
+    if (parent === cur)
+      break;
+    tail.unshift(basename(cur));
+    cur = parent;
+  }
+  return join3(realpathSync(cur), ...tail);
+}
+function assertContainedReal(root, target, raw) {
+  const rootReal = realpathSync(root);
+  const targetReal = realpathNearest(target);
+  if (!isWithin(targetReal, rootReal)) {
+    throw new ScriptContainmentError(target, root, raw);
+  }
+}
+function assertContained(target, root, raw) {
+  const lexical = assertContainedLexical(target, root, raw);
+  assertContainedReal(root, lexical, raw);
+  return lexical;
+}
+function resolveScript(manifest, manifestDir) {
+  if (manifest.script.includes(`
+`)) {
+    const ext = manifest.script.trim().startsWith("#!") ? ".sh" : ".ts";
+    return { path: `script${ext}`, content: manifest.script };
+  }
+  const rel = normalize(manifest.script);
+  if (isAbsolute(rel)) {
+    throw new Error(`manifest script must be relative or inline, got absolute path '${manifest.script}'`);
+  }
+  const resolved = assertContained(join3(manifestDir, rel), manifestDir, manifest.script);
+  if (!existsSync3(resolved)) {
+    throw new Error(`manifest script file not found: ${resolved}`);
+  }
+  return { path: rel, content: readFileSync2(resolved, "utf-8") };
+}
+function customHookDir(name) {
+  return join3(getCustomHooksDir(), shortManifestName(name));
+}
+function readCustomManifest(name) {
+  const dir = customHookDir(name);
+  const manifestPath = join3(dir, "manifest.json");
+  if (!existsSync3(manifestPath))
+    return;
+  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(`
+`) };
+  } catch (err) {
+    if (err instanceof ScriptContainmentError)
+      throw err;
+    return;
+  }
+}
+function listCustomHooks() {
+  const dir = getCustomHooksDir();
+  if (!existsSync3(dir))
+    return [];
+  const results = [];
+  for (const entry of readdirSafe(dir)) {
+    const parsed = readCustomManifest(entry);
+    if (parsed)
+      results.push(parsed);
+  }
+  return results.sort((a, b) => a.manifest.name.localeCompare(b.manifest.name));
+}
+function writeCustomHook(name, manifest, scriptContent, scriptRelPath) {
+  const dir = customHookDir(name);
+  if (isAbsolute(scriptRelPath)) {
+    throw new ScriptContainmentError(scriptRelPath, dir);
+  }
+  const scriptPath = scriptRelPath.includes("/") ? join3(dir, scriptRelPath) : join3(dir, scriptRelPath);
+  assertContainedLexical(scriptPath, dir, scriptRelPath);
+  mkdirSync2(dir, { recursive: true });
+  assertContainedReal(dir, scriptPath, scriptRelPath);
+  const scriptDir = dirname(scriptPath);
+  if (scriptDir !== dir)
+    mkdirSync2(scriptDir, { recursive: true });
+  writeFileSync2(scriptPath, scriptContent, "utf-8");
+  writeFileSync2(join3(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + `
+`, "utf-8");
+  return { dir, scriptPath };
+}
+function readdirSafe(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+var HOOK_NAME_RE, manifestSchema, ScriptContainmentError;
+var init_manifest = __esm(() => {
+  init_config();
+  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)"),
+    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"),
+    args: z.array(z.string()).optional(),
+    timeout_ms: z.number().int().positive().optional()
+  });
+  ScriptContainmentError = class ScriptContainmentError extends Error {
+    constructor(path, hookDir, raw) {
+      super(raw && raw !== path ? `manifest script escapes the hook directory: '${path}' (from '${raw}') resolves outside '${hookDir}'` : `manifest script escapes the hook directory: '${path}' resolves outside '${hookDir}'`);
+      this.name = "ScriptContainmentError";
+    }
+  };
+});
+
+// src/lib/resolve.ts
+var exports_resolve = {};
+__export(exports_resolve, {
+  resolveScriptPath: () => resolveScriptPath,
+  resolveHookMeta: () => resolveHookMeta,
+  resolveHookDir: () => resolveHookDir,
+  resolveHook: () => resolveHook
+});
+import { join as join4 } from "path";
+import { existsSync as existsSync4 } from "fs";
+function resolveHookDir(name) {
+  const custom = readCustomManifest(name);
+  if (custom)
+    return customHookDir(name);
+  const meta = getHook(shortManifestName(name));
+  if (!meta)
+    return;
+  const short = shortManifestName(name);
+  const bundledBase = join4(__dirname, "..", "..", "hooks");
+  const direct = join4(bundledBase, short);
+  if (existsSync4(direct))
+    return direct;
+  const prefixed = join4(bundledBase, `hook-${short}`);
+  return existsSync4(prefixed) ? prefixed : undefined;
+}
+function resolveScriptPath(name) {
+  const custom = readCustomManifest(name);
+  if (custom)
+    return custom.scriptPath;
+  const dir = resolveHookDir(name);
+  if (!dir)
+    return;
+  const script = join4(dir, "src", "hook.ts");
+  return existsSync4(script) ? script : undefined;
+}
+function resolveHookMeta(name) {
+  const custom = readCustomManifest(name);
+  if (custom) {
+    const { manifest } = custom;
+    return {
+      name: shortManifestName(manifest.name),
+      displayName: manifest.description ? manifest.name : manifest.name,
+      description: manifest.description ?? "Custom hook",
+      version: manifest.version,
+      category: "Workflow Automation",
+      event: manifest.events[0] ?? "PostToolUse",
+      events: manifest.events,
+      matcher: "",
+      tags: ["custom"]
+    };
+  }
+  return getHook(shortManifestName(name));
+}
+function resolveHook(name) {
+  const custom = readCustomManifest(name);
+  if (custom) {
+    const meta2 = resolveHookMeta(name);
+    return {
+      name: shortManifestName(custom.manifest.name),
+      source: "custom",
+      version: custom.manifest.version,
+      events: custom.manifest.events,
+      description: custom.manifest.description ?? "Custom hook",
+      scriptPath: custom.scriptPath,
+      meta: meta2
+    };
+  }
+  const meta = getHook(shortManifestName(name));
+  const scriptPath = resolveScriptPath(name);
+  if (!meta || !scriptPath)
+    return;
+  return {
+    name: shortManifestName(name),
+    source: "bundled",
+    version: meta.version,
+    events: meta.events && meta.events.length > 0 ? meta.events : [meta.event],
+    description: meta.description,
+    scriptPath,
+    meta
+  };
+}
+var __dirname = "/home/hasna/.hasna/repos/worktrees/apps/1ec6ba31-cdbc-42ea-8b1e-705e4198abbf/apps/hooks/src/lib";
+var init_resolve = __esm(() => {
+  init_registry();
+  init_manifest();
+});
+
+// src/lib/installer.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
+import { homedir as homedir3 } from "os";
 import { fileURLToPath } from "url";
 function normalizeHookName(name) {
   return name.startsWith("hook-") ? name : `hook-${name}`;
@@ -4063,33 +4383,43 @@ function getTargetSettingsDir(target) {
     return ".gemini";
   return ".claude";
 }
+function getGlobalSettingsPathOverride(target) {
+  if (target === "claude")
+    return process.env.HASNA_HOOKS_CLAUDE_SETTINGS_PATH;
+  if (target === "gemini")
+    return process.env.HASNA_HOOKS_GEMINI_SETTINGS_PATH;
+  return;
+}
 function getSettingsPath(scope = "global", target = "claude", codewithConfigPath) {
   if (target === "codewith" && codewithConfigPath)
     return codewithConfigPath;
   if (target === "codewith" && process.env.HASNA_HOOKS_CODEWITH_CONFIG_PATH) {
     return process.env.HASNA_HOOKS_CODEWITH_CONFIG_PATH;
   }
+  const globalOverride = scope === "global" ? getGlobalSettingsPathOverride(target) : undefined;
+  if (globalOverride)
+    return globalOverride;
   const dir = getTargetSettingsDir(target);
   if (scope === "project") {
-    return target === "codewith" ? join2(process.cwd(), dir, "config.toml") : join2(process.cwd(), dir, "settings.json");
+    return target === "codewith" ? join5(process.cwd(), dir, "config.toml") : join5(process.cwd(), dir, "settings.json");
   }
-  return target === "codewith" ? join2(homedir2(), dir, "config.toml") : join2(homedir2(), dir, "settings.json");
+  return target === "codewith" ? join5(homedir3(), dir, "config.toml") : join5(homedir3(), dir, "settings.json");
 }
 function getHookPath(name) {
   const shortName = shortHookName(name);
-  const direct = join2(HOOKS_DIR, shortName);
-  if (existsSync2(direct))
-    return direct;
-  return join2(HOOKS_DIR, normalizeHookName(shortName));
+  const resolved = resolveHookDir(shortName);
+  if (resolved)
+    return resolved;
+  return join5(HOOKS_DIR, normalizeHookName(shortName));
 }
 function hookExists(name) {
-  return existsSync2(getHookPath(name));
+  return existsSync5(getHookPath(name));
 }
 function readSettings(scope = "global", target = "claude") {
   const path = getSettingsPath(scope, target);
   try {
-    if (existsSync2(path)) {
-      return JSON.parse(readFileSync(path, "utf-8"));
+    if (existsSync5(path)) {
+      return JSON.parse(readFileSync3(path, "utf-8"));
     }
   } catch (error) {
     console.warn(`[hooks] Failed to read settings at ${path}: ${error instanceof Error ? error.message : String(error)}`);
@@ -4098,11 +4428,11 @@ function readSettings(scope = "global", target = "claude") {
 }
 function writeSettings(settings, scope = "global", target = "claude") {
   const path = getSettingsPath(scope, target);
-  const dir = dirname(path);
-  if (!existsSync2(dir)) {
-    mkdirSync(dir, { recursive: true });
+  const dir = dirname2(path);
+  if (!existsSync5(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
-  writeFileSync(path, JSON.stringify(settings, null, 2) + `
+  writeFileSync3(path, JSON.stringify(settings, null, 2) + `
 `);
 }
 function getTargetEventName(internalEvent, target) {
@@ -4160,7 +4490,7 @@ function codewithStatusMessage(name) {
 }
 function buildCodewithTomlFragment(name, profile) {
   const shortName = shortHookName(name);
-  const meta = getHook(shortName);
+  const meta = resolveHookMeta(shortName);
   if (!meta)
     throw new Error(`Hook '${shortName}' not found`);
   const command = profile ? `hooks run ${shortName} --profile ${profile}` : `hooks run ${shortName}`;
@@ -4188,25 +4518,25 @@ function buildCodewithTomlFragment(name, profile) {
 function readCodewithConfig(scope, configPath) {
   const path = getSettingsPath(scope, "codewith", configPath);
   try {
-    return existsSync2(path) ? readFileSync(path, "utf-8") : "";
+    return existsSync5(path) ? readFileSync3(path, "utf-8") : "";
   } catch {
     return "";
   }
 }
 function appendCodewithFragment(fragment, scope, configPath) {
   const path = getSettingsPath(scope, "codewith", configPath);
-  const dir = dirname(path);
-  if (!existsSync2(dir))
-    mkdirSync(dir, { recursive: true });
-  const existing = existsSync2(path) ? readFileSync(path, "utf-8") : "";
-  const sep = existing.trim() ? `
+  const dir = dirname2(path);
+  if (!existsSync5(dir))
+    mkdirSync3(dir, { recursive: true });
+  const existing = existsSync5(path) ? readFileSync3(path, "utf-8") : "";
+  const sep2 = existing.trim() ? `
 
 ` : "";
-  writeFileSync(path, `${existing.replace(/\s*$/, "")}${sep}${fragment}`);
+  writeFileSync3(path, `${existing.replace(/\s*$/, "")}${sep2}${fragment}`);
   return path;
 }
 function detectConflict(name, scope, target) {
-  const meta = getHook(name);
+  const meta = resolveHookMeta(name);
   if (!meta || !meta.matcher)
     return;
   const events = new Set(getHookEvents(meta));
@@ -4302,7 +4632,7 @@ function installHook(name, options = {}) {
   const { scope = "global", overwrite = false, target = "claude", profile, codewithMode = "fragment", codewithConfigPath } = options;
   if (target === "all") {
     const shortName = shortHookName(name);
-    const meta = getHook(shortName);
+    const meta = resolveHookMeta(shortName);
     if (meta) {
       const unsupportedTargets = ["claude", "codewith"].filter((agentTarget) => getHookEvents(meta).some((event) => !isEventSupported(event, agentTarget)));
       if (unsupportedTargets.length > 0) {
@@ -4335,7 +4665,7 @@ function installHook(name, options = {}) {
   return installForTarget(name, scope, overwrite, target, profile, codewithMode, codewithConfigPath);
 }
 function registerHook(name, scope = "global", target = "claude", profile) {
-  const meta = getHook(name);
+  const meta = resolveHookMeta(name);
   if (!meta)
     return;
   const eventKeys = getHookEvents(meta).map((event) => {
@@ -4378,7 +4708,7 @@ function removeHookFromAllEvents(settings, name) {
   }
 }
 function unregisterHook(name, scope = "global", target = "claude") {
-  const meta = getHook(name);
+  const meta = resolveHookMeta(name);
   if (!meta)
     return;
   const settings = readSettings(scope, target);
@@ -4445,8 +4775,9 @@ function removeHookForTarget(name, scope, target) {
 var __dirname2, HOOKS_DIR, EVENT_MAP, getInstalledHooks;
 var init_installer = __esm(() => {
   init_registry();
-  __dirname2 = dirname(fileURLToPath(import.meta.url));
-  HOOKS_DIR = existsSync2(join2(__dirname2, "..", "..", "hooks", "hook-gitguard")) ? join2(__dirname2, "..", "..", "hooks") : join2(__dirname2, "..", "hooks");
+  init_resolve();
+  __dirname2 = dirname2(fileURLToPath(import.meta.url));
+  HOOKS_DIR = existsSync5(join5(__dirname2, "..", "..", "hooks", "hook-gitguard")) ? join5(__dirname2, "..", "..", "hooks") : join5(__dirname2, "..", "hooks");
   EVENT_MAP = {
     claude: {
       PreToolUse: "PreToolUse",
@@ -4483,25 +4814,25 @@ var init_installer = __esm(() => {
 });
 
 // src/lib/profiles.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, readdirSync, rmSync, cpSync } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, readdirSync as readdirSync2, rmSync, cpSync } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir4 } from "os";
 function resolveProfilesDir() {
-  const newDir = join3(homedir3(), ".hasna", "hooks", "profiles");
-  const oldDir = join3(homedir3(), ".hooks", "profiles");
-  if (!existsSync3(newDir) && existsSync3(oldDir)) {
-    mkdirSync2(join3(homedir3(), ".hasna", "hooks"), { recursive: true });
+  const newDir = join6(homedir4(), ".hasna", "hooks", "profiles");
+  const oldDir = join6(homedir4(), ".hooks", "profiles");
+  if (!existsSync6(newDir) && existsSync6(oldDir)) {
+    mkdirSync4(join6(homedir4(), ".hasna", "hooks"), { recursive: true });
     cpSync(oldDir, newDir, { recursive: true });
   }
   return newDir;
 }
 function ensureProfilesDir() {
-  if (!existsSync3(PROFILES_DIR)) {
-    mkdirSync2(PROFILES_DIR, { recursive: true });
+  if (!existsSync6(PROFILES_DIR)) {
+    mkdirSync4(PROFILES_DIR, { recursive: true });
   }
 }
 function profilePath(id) {
-  return join3(PROFILES_DIR, `${id}.json`);
+  return join6(PROFILES_DIR, `${id}.json`);
 }
 function shortUuid() {
   return crypto.randomUUID().slice(0, 8);
@@ -4520,29 +4851,29 @@ function createProfile(input) {
   if (input.name) {
     profile.name = input.name;
   }
-  writeFileSync2(profilePath(id), JSON.stringify(profile, null, 2) + `
+  writeFileSync4(profilePath(id), JSON.stringify(profile, null, 2) + `
 `);
   return profile;
 }
 function getProfile(id) {
   const path = profilePath(id);
   try {
-    if (!existsSync3(path))
+    if (!existsSync6(path))
       return null;
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync4(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function listProfiles() {
-  if (!existsSync3(PROFILES_DIR))
+  if (!existsSync6(PROFILES_DIR))
     return [];
   try {
-    const files = readdirSync(PROFILES_DIR).filter((f) => f.endsWith(".json"));
+    const files = readdirSync2(PROFILES_DIR).filter((f) => f.endsWith(".json"));
     const profiles = [];
     for (const file of files) {
       try {
-        const content = readFileSync2(join3(PROFILES_DIR, file), "utf-8");
+        const content = readFileSync4(join6(PROFILES_DIR, file), "utf-8");
         profiles.push(JSON.parse(content));
       } catch {}
     }
@@ -4556,7 +4887,7 @@ function touchProfile(id) {
   if (!profile)
     return;
   profile.last_seen_at = new Date().toISOString();
-  writeFileSync2(profilePath(id), JSON.stringify(profile, null, 2) + `
+  writeFileSync4(profilePath(id), JSON.stringify(profile, null, 2) + `
 `);
 }
 function exportProfiles() {
@@ -4572,11 +4903,11 @@ function importProfiles(profiles) {
       continue;
     }
     const path = profilePath(profile.agent_id);
-    if (existsSync3(path)) {
+    if (existsSync6(path)) {
       skipped++;
       continue;
     }
-    writeFileSync2(path, JSON.stringify(profile, null, 2) + `
+    writeFileSync4(path, JSON.stringify(profile, null, 2) + `
 `);
     imported++;
   }
@@ -4683,6 +5014,32 @@ var init_003_user_prompt_submit_event = __esm(() => {
   init_schema();
 });
 
+// src/db/migrations/004_hooks_table.ts
+function up4(db) {
+  db.exec(CREATE_HOOKS_TABLE);
+  for (const idx of CREATE_HOOKS_INDEXES) {
+    db.exec(idx);
+  }
+}
+var CREATE_HOOKS_TABLE = `
+  CREATE TABLE IF NOT EXISTS hooks (
+    id               TEXT PRIMARY KEY,
+    name             TEXT NOT NULL,
+    version          TEXT NOT NULL,
+    sha256           TEXT NOT NULL,
+    source_type      TEXT NOT NULL,
+    source_ref       TEXT,
+    installed_at     TEXT NOT NULL,
+    enabled          INTEGER NOT NULL DEFAULT 1,
+    last_verified_at TEXT
+  )
+`, CREATE_HOOKS_INDEXES;
+var init_004_hooks_table = __esm(() => {
+  CREATE_HOOKS_INDEXES = [
+    `CREATE INDEX IF NOT EXISTS idx_hooks_name ON hooks (name)`
+  ];
+});
+
 // src/db/migrations/index.ts
 function ensureMigrationsTable(db) {
   db.exec(`
@@ -4714,17 +5071,19 @@ var init_migrations = __esm(() => {
   init_001_initial();
   init_002_session_events();
   init_003_user_prompt_submit_event();
+  init_004_hooks_table();
   MIGRATIONS = [
     { version: "001_initial", up },
     { version: "002_session_events", up: up2 },
-    { version: "003_user_prompt_submit_event", up: up3 }
+    { version: "003_user_prompt_submit_event", up: up3 },
+    { version: "004_hooks_table", up: up4 }
   ];
 });
 
 // src/db/legacy-import.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir5 } from "os";
 function ensureMetaTable(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS _meta (
@@ -4747,7 +5106,7 @@ function nanoid() {
 function importJsonlFile(db, filePath) {
   let count = 0;
   try {
-    const lines = readFileSync3(filePath, "utf-8").split(`
+    const lines = readFileSync5(filePath, "utf-8").split(`
 `).filter(Boolean);
     for (const line of lines) {
       try {
@@ -4773,7 +5132,7 @@ function importJsonlFile(db, filePath) {
 function importErrorsLog(db, filePath) {
   let count = 0;
   try {
-    const lines = readFileSync3(filePath, "utf-8").split(`
+    const lines = readFileSync5(filePath, "utf-8").split(`
 `).filter(Boolean);
     const linePattern = /^\[(.+?)\]\s+(?:\[session:(\S+)\]\s+)?(.+?)\s+\u2014\s+(.+)$/;
     for (const line of lines) {
@@ -4798,25 +5157,25 @@ function importErrorsLog(db, filePath) {
   } catch {}
   return count;
 }
-function runLegacyImport(db) {
+function runLegacyImport(db, homeDir = homedir5()) {
   try {
     if (isAlreadyDone(db))
       return;
     let total = 0;
-    const claudeProjectsDir = join4(homedir4(), ".claude", "projects");
-    if (existsSync4(claudeProjectsDir)) {
+    const claudeProjectsDir = join7(homeDir, ".claude", "projects");
+    if (existsSync7(claudeProjectsDir)) {
       try {
-        const projectDirs = readdirSync2(claudeProjectsDir);
+        const projectDirs = readdirSync3(claudeProjectsDir);
         for (const dir of projectDirs) {
-          const projectDir = join4(claudeProjectsDir, dir);
+          const projectDir = join7(claudeProjectsDir, dir);
           try {
-            const files = readdirSync2(projectDir);
+            const files = readdirSync3(projectDir);
             for (const file of files) {
               if (file.match(/^session-log-\d{4}-\d{2}-\d{2}\.jsonl$/)) {
-                total += importJsonlFile(db, join4(projectDir, file));
+                total += importJsonlFile(db, join7(projectDir, file));
               }
               if (file === "errors.log") {
-                total += importErrorsLog(db, join4(projectDir, file));
+                total += importErrorsLog(db, join7(projectDir, file));
               }
             }
           } catch {}
@@ -4859,17 +5218,17 @@ __export(exports_db, {
   closeDb: () => closeDb
 });
 import { Database } from "bun:sqlite";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, cpSync as cpSync2 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, cpSync as cpSync2 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir6 } from "os";
 function resolveDataDir() {
   const explicit = process.env.HASNA_HOOKS_DATA_DIR ?? process.env.HOOKS_DATA_DIR;
   if (explicit)
     return explicit;
-  const newDir = join5(homedir5(), ".hasna", "hooks");
-  const oldDir = join5(homedir5(), ".hooks");
-  if (!existsSync5(newDir) && existsSync5(oldDir)) {
-    mkdirSync3(join5(homedir5(), ".hasna"), { recursive: true });
+  const newDir = join8(homedir6(), ".hasna", "hooks");
+  const oldDir = join8(homedir6(), ".hooks");
+  if (!existsSync8(newDir) && existsSync8(oldDir)) {
+    mkdirSync5(join8(homedir6(), ".hasna"), { recursive: true });
     cpSync2(oldDir, newDir, { recursive: true });
   }
   return newDir;
@@ -4879,19 +5238,19 @@ function getDbPath() {
   if (explicitDb)
     return explicitDb;
   const dataDir = resolveDataDir();
-  return join5(dataDir, "hooks.db");
+  return join8(dataDir, "hooks.db");
 }
 function ensureDir(dbPath) {
   const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
-  if (dir && !existsSync5(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  if (dir && !existsSync8(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
 }
 function getDb() {
   if (instance)
     return instance;
   const dbPath = getDbPath();
-  const isNew = dbPath === ":memory:" || !existsSync5(dbPath);
+  const isNew = dbPath === ":memory:" || !existsSync8(dbPath);
   ensureDir(dbPath);
   instance = new Database(dbPath);
   instance.exec("PRAGMA journal_mode=WAL");
@@ -4930,6 +5289,313 @@ var init_db = __esm(() => {
   init_legacy_import();
 });
 
+// src/lib/store.ts
+var exports_store = {};
+__export(exports_store, {
+  writeLock: () => writeLock,
+  verifyScriptHash: () => verifyScriptHash,
+  upsertHookRecord: () => upsertHookRecord,
+  sha256Of: () => sha256Of,
+  sha256File: () => sha256File,
+  setPinnedHook: () => setPinnedHook,
+  retrustHook: () => retrustHook,
+  removePinnedHook: () => removePinnedHook,
+  removeHookRecord: () => removeHookRecord,
+  readLock: () => readLock,
+  listHookRecords: () => listHookRecords,
+  getPinnedHook: () => getPinnedHook,
+  getHookRecord: () => getHookRecord,
+  checkScriptHash: () => checkScriptHash
+});
+import { createHash } from "crypto";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+function sha256Of(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+async function sha256File(path) {
+  const buf = await readFile2(path);
+  return sha256Of(buf);
+}
+function getHookRecord(db, name) {
+  return db.query("SELECT * FROM hooks WHERE name = ?").get(name);
+}
+function listHookRecords(db) {
+  return db.query("SELECT * FROM hooks ORDER BY name").all();
+}
+function upsertHookRecord(db, record) {
+  const existing = getHookRecord(db, record.name);
+  const id = existing?.id ?? record.name;
+  const installedAt = existing?.installed_at ?? new Date().toISOString();
+  const enabled = record.enabled ?? existing?.enabled ?? 1;
+  db.run(`INSERT INTO hooks (id, name, version, sha256, source_type, source_ref, installed_at, enabled, last_verified_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       version = excluded.version,
+       sha256 = excluded.sha256,
+       source_type = excluded.source_type,
+       source_ref = excluded.source_ref,
+       enabled = excluded.enabled,
+       last_verified_at = excluded.last_verified_at`, [
+    id,
+    record.name,
+    record.version,
+    record.sha256,
+    record.source_type,
+    record.source_ref ?? existing?.source_ref ?? null,
+    installedAt,
+    enabled,
+    record.last_verified_at ?? null
+  ]);
+}
+function removeHookRecord(db, name) {
+  const res = db.run("DELETE FROM hooks WHERE name = ?", [name]);
+  return res.changes > 0;
+}
+function readLock() {
+  try {
+    const path = getLockPath();
+    if (!existsSync9(path))
+      return { hooks: {} };
+    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
+    return { hooks: parsed.hooks ?? {} };
+  } catch {
+    return { hooks: {} };
+  }
+}
+function writeLock(lock) {
+  const path = getLockPath();
+  mkdirSync6(path.substring(0, path.lastIndexOf("/")) || ".", { recursive: true });
+  const sorted = {};
+  for (const name of Object.keys(lock.hooks).sort()) {
+    sorted[name] = lock.hooks[name];
+  }
+  writeFileSync5(path, JSON.stringify({ hooks: sorted }, null, 2) + `
+`, "utf-8");
+  return path;
+}
+function setPinnedHook(name, entry) {
+  const lock = readLock();
+  lock.hooks[name] = entry;
+  return writeLock(lock);
+}
+function getPinnedHook(name) {
+  return readLock().hooks[name];
+}
+function removePinnedHook(name) {
+  const lock = readLock();
+  if (!(name in lock.hooks))
+    return false;
+  delete lock.hooks[name];
+  writeLock(lock);
+  return true;
+}
+function checkScriptHash(name, actual) {
+  const db = getDb();
+  const record = getHookRecord(db, name);
+  const pin = getPinnedHook(name);
+  const expected = record?.sha256 ?? pin?.sha256 ?? null;
+  if (expected !== null && expected !== actual) {
+    return { ok: false, pinned: true, expected, actual, name };
+  }
+  if (expected === null) {
+    const now3 = new Date().toISOString();
+    const version = pin?.version ?? record?.version ?? "0.0.0";
+    const source = pin?.source ?? record?.source_type ?? "local";
+    upsertHookRecord(db, {
+      name,
+      version,
+      sha256: actual,
+      source_type: source,
+      last_verified_at: now3
+    });
+    setPinnedHook(name, { version, sha256: actual, source });
+    return { ok: true, pinned: false, expected: null, actual, name };
+  }
+  const now2 = new Date().toISOString();
+  upsertHookRecord(db, {
+    name,
+    version: record?.version ?? pin?.version ?? "0.0.0",
+    sha256: expected,
+    source_type: record?.source_type ?? pin?.source ?? "local",
+    last_verified_at: now2
+  });
+  return { ok: true, pinned: true, expected, actual, name };
+}
+async function verifyScriptHash(name, scriptPath) {
+  return checkScriptHash(name, await sha256File(scriptPath));
+}
+function retrustHook(name, scriptPath, version, source) {
+  const actual = sha256Of(readFileSync6(scriptPath));
+  const db = getDb();
+  upsertHookRecord(db, {
+    name,
+    version,
+    sha256: actual,
+    source_type: source,
+    last_verified_at: new Date().toISOString()
+  });
+  setPinnedHook(name, { version, sha256: actual, source });
+  return { ok: true, pinned: true, expected: actual, actual, name };
+}
+var init_store = __esm(() => {
+  init_db();
+  init_config();
+});
+
+// src/lib/run.ts
+var exports_run = {};
+__export(exports_run, {
+  executeVerifiedScript: () => executeVerifiedScript
+});
+import { randomBytes } from "crypto";
+import { rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join9 } from "path";
+function extensionOf(scriptPath) {
+  const base = basename2(scriptPath);
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(dot + 1) : "ts";
+}
+async function executeVerifiedScript(options) {
+  const scriptDir = dirname3(options.scriptPath);
+  const tempPath = join9(scriptDir, `.hooks-verified-${randomBytes(12).toString("hex")}.${extensionOf(options.scriptPath)}`);
+  try {
+    writeFileSync6(tempPath, options.content, { flag: "wx", mode: 384 });
+    const proc = Bun.spawn(["bun", "run", isAbsolute2(tempPath) ? tempPath : `./${tempPath}`, ...options.args ?? []], {
+      stdin: new Response(options.stdin),
+      stdout: "pipe",
+      stderr: "pipe",
+      env: options.env ?? process.env,
+      ...options.timeout ? { timeout: options.timeout } : {}
+    });
+    const [stdoutText, stderrText, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    return { stdout: stdoutText, stderr: stderrText, exitCode };
+  } finally {
+    try {
+      rmSync2(tempPath, { force: true });
+    } catch {}
+  }
+}
+var init_run = () => {};
+
+// src/lib/custom-install.ts
+var exports_custom_install = {};
+__export(exports_custom_install, {
+  isCustomSource: () => isCustomSource,
+  installCustomSource: () => installCustomSource,
+  ensureCustomDir: () => ensureCustomDir
+});
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync3 } from "fs";
+import { join as join10 } from "path";
+import { tmpdir } from "os";
+function manifestAt(dir) {
+  const path = join10(dir, "manifest.json");
+  if (!existsSync10(path))
+    return;
+  try {
+    return parseManifest(readFileSync7(path, "utf-8"));
+  } catch {
+    return;
+  }
+}
+function copyManifestDir(srcDir, source, kind) {
+  const manifest = manifestAt(srcDir);
+  if (!manifest) {
+    throw new Error(`No valid manifest.json found at ${srcDir}`);
+  }
+  return writeFromManifest(manifest, srcDir, source, kind);
+}
+function writeFromManifest(manifest, srcDir, source, kind) {
+  const script = resolveScript(manifest, srcDir);
+  const name = shortManifestName(manifest.name);
+  const { dir, scriptPath } = writeCustomHook(name, manifest, script.content, script.path);
+  return { name, version: manifest.version, kind, source, dir, scriptPath };
+}
+async function cloneToTemp(gitUrl) {
+  const tmp = mkdtempSync(join10(tmpdir(), "hooks-install-"));
+  const proc = Bun.spawn(["git", "clone", "--depth", "1", "--quiet", gitUrl, join10(tmp, "repo")], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  if (exitCode !== 0) {
+    rmSync3(tmp, { recursive: true, force: true });
+    throw new Error(`git clone failed (${exitCode}): ${stderr.trim()}`);
+  }
+  return join10(tmp, "repo");
+}
+function isGitUrl(value) {
+  return value.startsWith("git@") || value.startsWith("ssh://") || value.startsWith("file://") || value.endsWith(".git");
+}
+function isCustomSource(value) {
+  if (isGitUrl(value))
+    return true;
+  if (value.startsWith("http://") || value.startsWith("https://"))
+    return true;
+  return existsSync10(value);
+}
+async function installCustomSource(source) {
+  if (isGitUrl(source)) {
+    const repoDir = await cloneToTemp(source);
+    try {
+      return copyManifestDir(repoDir, source, "git");
+    } finally {
+      rmSync3(repoDir, { recursive: true, force: true });
+    }
+  }
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    return installManifestUrl(source);
+  }
+  if (!existsSync10(source)) {
+    throw new Error(`No such local path: ${source}`);
+  }
+  if (source.endsWith("manifest.json")) {
+    const manifest = parseManifest(readFileSync7(source, "utf-8"));
+    return writeFromManifest(manifest, source.substring(0, source.lastIndexOf("/")), source, "local");
+  }
+  return copyManifestDir(source, source, "local");
+}
+async function installManifestUrl(url) {
+  const res = await fetch(url, { redirect: "follow" });
+  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(`
+`)) {
+    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" });
+    if (!scriptRes.ok) {
+      throw new Error(`Failed to fetch script (${scriptRes.status}): ${scriptUrl}`);
+    }
+    script = { path: manifest.script, content: await scriptRes.text() };
+  }
+  const name = shortManifestName(manifest.name);
+  const { dir, scriptPath } = writeCustomHook(name, manifest, script.content, script.path);
+  return { name, version: manifest.version, kind: "url", source: url, dir, scriptPath };
+}
+function ensureCustomDir() {
+  const dir = getCustomHooksDir();
+  mkdirSync7(dir, { recursive: true });
+  return dir;
+}
+var init_custom_install = __esm(() => {
+  init_config();
+  init_manifest();
+});
+
 // src/db/pg-migrations.ts
 var PG_MIGRATIONS;
 var init_pg_migrations = __esm(() => {
@@ -5014,11 +5680,30 @@ function readEnv(name) {
   const value = process.env[name]?.trim();
   return value || undefined;
 }
-function normalizeStorageMode(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (normalized === "local" || normalized === "hybrid" || normalized === "remote")
-    return normalized;
-  return;
+function assertNoRetiredModeEnv() {
+  for (const name of RETIRED_STORAGE_MODE_ENV) {
+    const value = readEnv(name);
+    if (!value)
+      continue;
+    const replacement = RETIRED_MODE_REPLACEMENT[value.trim().toLowerCase()];
+    const mapping = replacement ? `${value} maps to ${replacement}` : `use one of ${STORAGE_BACKENDS.join(", ")}`;
+    throw new Error(`${name} is a retired deployment-mode variable and is no longer read. ` + `Hooks storage is a data-backend switch, not a deployment mode: ` + `set ${HOOKS_STORAGE_BACKEND_ENV} to ${STORAGE_BACKENDS.join(" or ")} instead (${mapping}), ` + `then unset ${name}.`);
+  }
+}
+function normalizeStorageBackend(value, envName) {
+  if (value === undefined)
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "")
+    return;
+  const backend = BACKEND_ALIASES[normalized];
+  if (backend)
+    return backend;
+  const replacement = RETIRED_MODE_REPLACEMENT[normalized];
+  if (replacement) {
+    throw new Error(`${envName}=${value} names a retired deployment mode. ` + `local/hybrid/remote/self_hosted/cloud were removed: hooks storage now selects a data ` + `backend only. Set ${envName}=${replacement} instead.`);
+  }
+  throw new Error(`${envName}=${value} is not a known hooks storage backend. ` + `Set ${HOOKS_STORAGE_BACKEND_ENV} to one of ${STORAGE_BACKENDS.join(", ")}.`);
 }
 function getStorageDatabaseEnvName() {
   for (const name of STORAGE_DATABASE_ENV) {
@@ -5035,11 +5720,12 @@ function getStorageDatabaseUrl() {
   const env = getStorageDatabaseEnv();
   return env ? readEnv(env.name) ?? null : null;
 }
-function getStorageMode() {
-  const mode = normalizeStorageMode(readEnv(HOOKS_STORAGE_MODE_ENV)) ?? normalizeStorageMode(readEnv(HOOKS_STORAGE_MODE_FALLBACK_ENV));
-  if (mode)
-    return mode;
-  return getStorageDatabaseUrl() ? "hybrid" : "local";
+function getStorageBackend() {
+  assertNoRetiredModeEnv();
+  const backend = normalizeStorageBackend(readEnv(HOOKS_STORAGE_BACKEND_ENV), HOOKS_STORAGE_BACKEND_ENV) ?? normalizeStorageBackend(readEnv(HOOKS_STORAGE_BACKEND_FALLBACK_ENV), HOOKS_STORAGE_BACKEND_FALLBACK_ENV);
+  if (backend)
+    return backend;
+  return getStorageDatabaseUrl() ? "postgresql" : "sqlite";
 }
 async function getStoragePg() {
   const url = getStorageDatabaseUrl();
@@ -5097,7 +5783,7 @@ function getStorageStatus() {
   const activeEnv = getStorageDatabaseEnv();
   return {
     configured: Boolean(activeEnv),
-    mode: getStorageMode(),
+    backend: getStorageBackend(),
     env: STORAGE_DATABASE_ENV,
     activeEnv: activeEnv?.name ?? null,
     service: "hooks",
@@ -5265,7 +5951,7 @@ function coerceForSqlite(value) {
     return JSON.stringify(value);
   return String(value);
 }
-var STORAGE_TABLES, HOOKS_STORAGE_TABLES, HOOKS_STORAGE_ENV = "HASNA_HOOKS_DATABASE_URL", HOOKS_STORAGE_FALLBACK_ENV = "HOOKS_DATABASE_URL", HOOKS_STORAGE_MODE_ENV = "HASNA_HOOKS_STORAGE_MODE", HOOKS_STORAGE_MODE_FALLBACK_ENV = "HOOKS_STORAGE_MODE", STORAGE_DATABASE_ENV, STORAGE_MODE_ENV, PRIMARY_KEYS;
+var STORAGE_TABLES, HOOKS_STORAGE_TABLES, STORAGE_BACKENDS, HOOKS_STORAGE_ENV = "HASNA_HOOKS_DATABASE_URL", HOOKS_STORAGE_FALLBACK_ENV = "HOOKS_DATABASE_URL", HOOKS_STORAGE_BACKEND_ENV = "HASNA_HOOKS_STORAGE_BACKEND", HOOKS_STORAGE_BACKEND_FALLBACK_ENV = "HOOKS_STORAGE_BACKEND", STORAGE_DATABASE_ENV, STORAGE_BACKEND_ENV, RETIRED_STORAGE_MODE_ENV, PRIMARY_KEYS, RETIRED_MODE_REPLACEMENT, BACKEND_ALIASES;
 var init_storage_sync = __esm(() => {
   init_db();
   init_pg_migrations();
@@ -5277,14 +5963,32 @@ var init_storage_sync = __esm(() => {
     "feedback"
   ];
   HOOKS_STORAGE_TABLES = STORAGE_TABLES;
+  STORAGE_BACKENDS = ["sqlite", "postgresql"];
   STORAGE_DATABASE_ENV = [HOOKS_STORAGE_ENV, HOOKS_STORAGE_FALLBACK_ENV];
-  STORAGE_MODE_ENV = [HOOKS_STORAGE_MODE_ENV, HOOKS_STORAGE_MODE_FALLBACK_ENV];
+  STORAGE_BACKEND_ENV = [HOOKS_STORAGE_BACKEND_ENV, HOOKS_STORAGE_BACKEND_FALLBACK_ENV];
+  RETIRED_STORAGE_MODE_ENV = ["HASNA_HOOKS_STORAGE_MODE", "HOOKS_STORAGE_MODE"];
   PRIMARY_KEYS = {
     hook_events: ["id"],
     schema_migrations: ["version"],
     _meta: ["key"],
     feedback: ["id"]
   };
+  RETIRED_MODE_REPLACEMENT = {
+    local: "sqlite",
+    hybrid: "postgresql",
+    remote: "postgresql",
+    self_hosted: "postgresql",
+    "self-hosted": "postgresql",
+    selfhosted: "postgresql",
+    cloud: "postgresql"
+  };
+  BACKEND_ALIASES = {
+    sqlite: "sqlite",
+    sqlite3: "sqlite",
+    postgresql: "postgresql",
+    postgres: "postgresql",
+    pg: "postgresql"
+  };
 });
 
 // src/storage.ts
@@ -5299,20 +6003,22 @@ __export(exports_storage, {
   getSyncMetaAll: () => getSyncMetaAll,
   getStorageStatus: () => getStorageStatus,
   getStoragePg: () => getStoragePg,
-  getStorageMode: () => getStorageMode,
   getStorageDatabaseUrl: () => getStorageDatabaseUrl,
   getStorageDatabaseEnvName: () => getStorageDatabaseEnvName,
   getStorageDatabaseEnv: () => getStorageDatabaseEnv,
+  getStorageBackend: () => getStorageBackend,
   STORAGE_TABLES: () => STORAGE_TABLES,
-  STORAGE_MODE_ENV: () => STORAGE_MODE_ENV,
   STORAGE_DATABASE_ENV: () => STORAGE_DATABASE_ENV,
+  STORAGE_BACKEND_ENV: () => STORAGE_BACKEND_ENV,
+  STORAGE_BACKENDS: () => STORAGE_BACKENDS,
+  RETIRED_STORAGE_MODE_ENV: () => RETIRED_STORAGE_MODE_ENV,
   PgAdapterAsync: () => PgAdapterAsync,
   PG_MIGRATIONS: () => PG_MIGRATIONS,
   HOOKS_STORAGE_TABLES: () => HOOKS_STORAGE_TABLES,
-  HOOKS_STORAGE_MODE_FALLBACK_ENV: () => HOOKS_STORAGE_MODE_FALLBACK_ENV,
-  HOOKS_STORAGE_MODE_ENV: () => HOOKS_STORAGE_MODE_ENV,
   HOOKS_STORAGE_FALLBACK_ENV: () => HOOKS_STORAGE_FALLBACK_ENV,
-  HOOKS_STORAGE_ENV: () => HOOKS_STORAGE_ENV
+  HOOKS_STORAGE_ENV: () => HOOKS_STORAGE_ENV,
+  HOOKS_STORAGE_BACKEND_FALLBACK_ENV: () => HOOKS_STORAGE_BACKEND_FALLBACK_ENV,
+  HOOKS_STORAGE_BACKEND_ENV: () => HOOKS_STORAGE_BACKEND_ENV
 });
 var init_storage = __esm(() => {
   init_storage_sync();
@@ -5320,56 +6026,433 @@ var init_storage = __esm(() => {
   init_pg_migrations();
 });
 
-// src/mcp/server.ts
-var exports_server = {};
-__export(exports_server, {
-  startStdioServer: () => startStdioServer,
-  startSSEServer: () => startSSEServer,
-  createHooksServer: () => createHooksServer,
-  MCP_PORT: () => MCP_PORT
+// src/serve.ts
+var exports_serve = {};
+__export(exports_serve, {
+  startServeServer: () => startServeServer,
+  handleServeRequest: () => handleServeRequest,
+  SERVE_SERVICE_NAME: () => SERVE_SERVICE_NAME,
+  SERVE_HOST: () => SERVE_HOST,
+  DEFAULT_SERVE_PORT: () => DEFAULT_SERVE_PORT
 });
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { createServer } from "http";
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function formatInstallResults(results, extra) {
-  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({ installed, failed, total: results.length, success: installed.length, ...extra })
-    }]
+async function buildCatalog() {
+  const byName = new Map;
+  for (const meta of HOOKS) {
+    const scriptPath = resolveHook(meta.name)?.scriptPath;
+    if (!scriptPath)
+      continue;
+    byName.set(meta.name, {
+      name: meta.name,
+      version: meta.version,
+      sha256: await sha256File(scriptPath),
+      events: meta.events && meta.events.length > 0 ? meta.events : [meta.event],
+      description: meta.description,
+      source: "bundled"
+    });
+  }
+  for (const custom of listCustomHooks()) {
+    const name = shortManifestName(custom.manifest.name);
+    byName.set(name, {
+      name,
+      version: custom.manifest.version,
+      sha256: await sha256File(custom.scriptPath),
+      events: custom.manifest.events,
+      description: custom.manifest.description ?? "Custom hook",
+      source: byName.has(name) ? "custom-overrides-bundled" : "custom"
+    });
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+async function artifactFor(name, version) {
+  const resolved = resolveHook(name);
+  if (!resolved)
+    return null;
+  if (version !== resolved.version)
+    return null;
+  const custom = listCustomHooks().find((c) => shortManifestName(c.manifest.name) === name);
+  const manifest = {
+    name,
+    version: resolved.version,
+    description: resolved.description,
+    events: resolved.events,
+    script: custom ? custom.manifest.script : `src/hook.ts`,
+    args: custom?.manifest.args,
+    timeout_ms: custom?.manifest.timeout_ms
   };
+  const script = await Bun.file(resolved.scriptPath).text();
+  return { manifest, script };
 }
-function truncateText(value, max = 160) {
-  const text = String(value ?? "").replace(/\s+/g, " ").trim();
-  if (text.length <= max)
-    return text;
-  return `${text.slice(0, Math.max(0, max - 3))}...`;
+function authorized(req, apiKey) {
+  if (!apiKey)
+    return false;
+  const header = req.headers.get("authorization") ?? "";
+  if (header.startsWith("Bearer "))
+    return header.slice("Bearer ".length) === apiKey;
+  return req.headers.get("x-api-key") === apiKey;
 }
-function boundedLimit(value, fallback, max) {
-  if (!Number.isFinite(value) || !value || value <= 0)
-    return fallback;
-  return Math.min(Math.floor(value), max);
+function json(body, status = 200, headers = {}) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json", ...headers }
+  });
 }
-function compactHook(hook) {
-  return {
-    name: hook.name,
-    event: hook.event,
-    matcher: hook.matcher,
-    category: hook.category
-  };
+function handleServeRequest(req, apiKey) {
+  const url = new URL(req.url);
+  if (url.pathname === "/health" && req.method === "GET") {
+    return Promise.resolve(json({ status: "ok", name: SERVE_SERVICE_NAME }));
+  }
+  if (url.pathname === "/api/v1/catalog" && req.method === "GET") {
+    return buildCatalog().then((catalog) => json({ hooks: catalog }));
+  }
+  if (url.pathname === "/api/v1/lock" && req.method === "GET") {
+    return Promise.resolve(json(readLock()));
+  }
+  const artifactMatch = /^\/api\/v1\/hooks\/([\w-]+)\/(\d+\.\d+\.\d+)$/.exec(url.pathname);
+  if (artifactMatch && req.method === "GET") {
+    const [, name, version] = artifactMatch;
+    return artifactFor(name, version).then(async (artifact) => {
+      if (!artifact)
+        return json({ error: `Hook '${name}@${version}' not found locally` }, 404);
+      const resolved = resolveHook(name);
+      const sha = resolved ? await sha256File(resolved.scriptPath) : artifact.manifest.name;
+      return json(artifact, 200, { "x-hook-sha256": sha });
+    });
+  }
+  if (url.pathname === "/api/v1/hooks" && req.method === "PUT") {
+    if (!authorized(req, apiKey)) {
+      return Promise.resolve(json({ error: "unauthorized: valid API key required to publish" }, 401));
+    }
+    return req.json().then((body) => {
+      const name = body.name ?? "";
+      const version = body.version ?? "";
+      const resolved = resolveHook(name);
+      if (!resolved)
+        return json({ error: `Hook '${name}' not found in local store` }, 404);
+      if (version && version !== resolved.version) {
+        return json({ error: `Version mismatch: local '${name}' is ${resolved.version}, requested ${version}` }, 409);
+      }
+      const check = retrustHook(name, resolved.scriptPath, resolved.version, "serve");
+      return json({ ok: true, hook: { name, version: resolved.version, sha256: check.actual } });
+    }, () => json({ error: "invalid JSON body" }, 400));
+  }
+  return Promise.resolve(json({ error: "Not Found" }, 404));
+}
+function startServeServer(options) {
+  const port = options.port ?? DEFAULT_SERVE_PORT;
+  const host = options.host ?? SERVE_HOST;
+  const apiKey = resolveApiKey(options.apiKey);
+  const server = Bun.serve({
+    hostname: host,
+    port,
+    async fetch(req) {
+      return handleServeRequest(req, apiKey);
+    }
+  });
+  console.error(`hooks registry listening on http://${host}:${port} (publish requires an API key)`);
+  return server;
 }
-function compactHookResult(hooks, limit, detail) {
-  const visible = hooks.slice(0, limit).map(compactHook);
-  const omitted = Math.max(0, hooks.length - visible.length);
-  return {
-    hooks: visible,
+var DEFAULT_SERVE_PORT = 39428, SERVE_HOST = "127.0.0.1", SERVE_SERVICE_NAME = "hooks-registry";
+var init_serve = __esm(() => {
+  init_registry();
+  init_manifest();
+  init_store();
+  init_resolve();
+  init_config();
+  if (false) {}
+});
+
+// src/lib/sync.ts
+var exports_sync = {};
+__export(exports_sync, {
+  syncHooks: () => syncHooks,
+  planSync: () => planSync
+});
+import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync8 } from "fs";
+function sha256OfText(text) {
+  return createHash2("sha256").update(text).digest("hex");
+}
+function sha256OfPath(path) {
+  return createHash2("sha256").update(readFileSync8(path)).digest("hex");
+}
+function collectBundledCatalog() {
+  const out = [];
+  for (const meta of HOOKS) {
+    const scriptPath = resolveScriptPath(meta.name);
+    if (!scriptPath)
+      continue;
+    out.push({
+      name: meta.name,
+      version: meta.version,
+      sha256: sha256OfPath(scriptPath)
+    });
+  }
+  return out;
+}
+async function fetchJson(base, path) {
+  const res = await fetch(`${base}${path}`, {
+    headers: { accept: "application/json" },
+    signal: AbortSignal.timeout(15000)
+  });
+  if (!res.ok) {
+    throw new Error(`GET ${path} failed with status ${res.status}`);
+  }
+  return res.json();
+}
+async function fetchRemoteState(apiUrl) {
+  const catalog = await fetchJson(apiUrl, "/api/v1/catalog");
+  const remoteLock = await fetchJson(apiUrl, "/api/v1/lock");
+  if (!catalog.hooks || !Array.isArray(catalog.hooks)) {
+    throw new Error("remote catalog is malformed: missing hooks array");
+  }
+  if (!remoteLock.hooks || typeof remoteLock.hooks !== "object") {
+    throw new Error("remote lock is malformed: missing hooks map");
+  }
+  return { catalog: catalog.hooks, remoteLock };
+}
+function computeDiff(catalog, remoteLock) {
+  const local = readLock();
+  const diff = { added: [], updated: [], unchanged: [], skipped: [] };
+  for (const entry of catalog) {
+    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);
+    } else {
+      diff.added.push(entry.name);
+    }
+  }
+  return diff;
+}
+async function planSync() {
+  const apiUrl = resolveApiUrl();
+  if (apiUrl) {
+    const { catalog, remoteLock } = await fetchRemoteState(apiUrl);
+    return { apiUrl, dryRun: false, diff: computeDiff(catalog, remoteLock) };
+  }
+  const diff = computeDiff(collectBundledCatalog(), null);
+  return { apiUrl: null, dryRun: false, diff };
+}
+async function syncHooks(options = {}) {
+  const apiUrl = resolveApiUrl();
+  const plan = await planSync();
+  if (options.dryRun)
+    return { ...plan, dryRun: true };
+  if (!apiUrl) {
+    const db2 = getDb();
+    for (const entry of collectBundledCatalog()) {
+      setPinnedHook(entry.name, { version: entry.version, sha256: entry.sha256, source: "bundled" });
+      upsertHookRecord(db2, {
+        name: entry.name,
+        version: entry.version,
+        sha256: entry.sha256,
+        source_type: "bundled",
+        source_ref: "apps/hooks/hooks",
+        last_verified_at: new Date().toISOString()
+      });
+    }
+    return plan;
+  }
+  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 entry = remoteLock.hooks[name];
+    if (!entry)
+      continue;
+    const artifact = await fetchJson(apiUrl, `/api/v1/hooks/${name}/${entry.version}`);
+    if (!artifact.manifest || typeof artifact.script !== "string") {
+      throw new Error(`artifact for '${name}@${entry.version}' is malformed`);
+    }
+    const actualSha = sha256OfText(artifact.script);
+    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);
+    setPinnedHook(name, { version: entry.version, sha256: actual, source: entry.source ?? "remote" });
+    upsertHookRecord(db, {
+      name,
+      version: entry.version,
+      sha256: actual,
+      source_type: entry.source ?? "remote",
+      source_ref: apiUrl,
+      last_verified_at: new Date().toISOString()
+    });
+  }
+  return { apiUrl, dryRun: false, diff };
+}
+var init_sync = __esm(() => {
+  init_registry();
+  init_config();
+  init_db();
+  init_store();
+  init_manifest();
+  init_resolve();
+});
+
+// src/cf/provision.ts
+var exports_provision = {};
+__export(exports_provision, {
+  provisionCloudflareResources: () => provisionCloudflareResources
+});
+async function cfFetch(fetchFn, token, path, init) {
+  const res = await fetchFn(`${CF_API}${path}`, {
+    ...init,
+    headers: {
+      authorization: `Bearer ${token}`,
+      "content-type": "application/json",
+      ...init?.headers ?? {}
+    }
+  });
+  const data = await res.json().catch(() => null);
+  return { ok: res.ok, status: res.status, data };
+}
+async function provisionCloudflareResources(options) {
+  const { token, accountId, databaseName, bucketName, dryRun, fetchFn = fetch } = options;
+  const result = {
+    d1DatabaseId: null,
+    d1Created: false,
+    d1Exists: false,
+    r2BucketExists: false,
+    r2Created: false,
+    commands: []
+  };
+  if (dryRun) {
+    result.commands = [
+      `POST ${CF_API}/accounts/${accountId}/d1/database {"name": "${databaseName}"} (if missing)`,
+      `PUT ${CF_API}/accounts/${accountId}/r2/buckets/${bucketName} (if missing)`,
+      `wrangler d1 migrations apply ${databaseName} --remote`,
+      `wrangler deploy --config wrangler.toml`
+    ];
+    return result;
+  }
+  const d1List = await cfFetch(fetchFn, token, `/accounts/${accountId}/d1/database?name=${encodeURIComponent(databaseName)}`);
+  if (!d1List.ok) {
+    throw new Error(`failed to list D1 databases (${d1List.status})`);
+  }
+  const d1Rows = d1List.data?.result ?? [];
+  if (d1Rows.length > 0) {
+    result.d1Exists = true;
+    result.d1DatabaseId = d1Rows[0].id;
+  } else {
+    const created = await cfFetch(fetchFn, token, `/accounts/${accountId}/d1/database`, {
+      method: "POST",
+      body: JSON.stringify({ name: databaseName })
+    });
+    if (!created.ok) {
+      throw new Error(`failed to create D1 database '${databaseName}' (${created.status})`);
+    }
+    result.d1Created = true;
+    result.d1DatabaseId = created.data?.result?.id ?? null;
+  }
+  const r2List = await cfFetch(fetchFn, token, `/accounts/${accountId}/r2/buckets`);
+  if (!r2List.ok) {
+    throw new Error(`failed to list R2 buckets (${r2List.status})`);
+  }
+  const bucketNames = (r2List.data?.result?.buckets ?? []).map((b) => b.name);
+  if (bucketNames.includes(bucketName)) {
+    result.r2BucketExists = true;
+  } else {
+    const created = await cfFetch(fetchFn, token, `/accounts/${accountId}/r2/buckets/${bucketName}`, {
+      method: "PUT",
+      body: JSON.stringify({ name: bucketName })
+    });
+    if (!created.ok) {
+      throw new Error(`failed to create R2 bucket '${bucketName}' (${created.status})`);
+    }
+    result.r2Created = true;
+  }
+  result.commands = [
+    `wrangler d1 migrations apply ${databaseName} --remote`,
+    `wrangler secret put HOOKS_API_KEY`,
+    `wrangler deploy --config wrangler.toml`
+  ];
+  return result;
+}
+var CF_API = "https://api.cloudflare.com/client/v4";
+
+// src/mcp/server.ts
+var exports_server = {};
+__export(exports_server, {
+  startStdioServer: () => startStdioServer,
+  startSSEServer: () => startSSEServer,
+  createHooksServer: () => createHooksServer,
+  MCP_PORT: () => MCP_PORT
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+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 dirname4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+async function runVerifiedHook(name, scriptPath, stdin, timeoutMs) {
+  const content = readFileSync9(scriptPath);
+  const check = checkScriptHash(name, sha256Of(content));
+  if (!check.ok) {
+    throw new Error(`Hook '${name}' script changed since it was trusted (sha256 ${check.expected} != ${check.actual}). Run 'hooks trust ${name}' to trust the new content.`);
+  }
+  const { executeVerifiedScript: executeVerifiedScript2 } = await Promise.resolve().then(() => (init_run(), exports_run));
+  return executeVerifiedScript2({ name, scriptPath, content, stdin, env: process.env, timeout: timeoutMs });
+}
+function formatInstallResults(results, extra) {
+  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({ installed, failed, total: results.length, success: installed.length, ...extra })
+    }]
+  };
+}
+function truncateText(value, max = 160) {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (text.length <= max)
+    return text;
+  return `${text.slice(0, Math.max(0, max - 3))}...`;
+}
+function boundedLimit(value, fallback, max) {
+  if (!Number.isFinite(value) || !value || value <= 0)
+    return fallback;
+  return Math.min(Math.floor(value), max);
+}
+function compactHook(hook) {
+  return {
+    name: hook.name,
+    event: hook.event,
+    matcher: hook.matcher,
+    category: hook.category
+  };
+}
+function compactHookResult(hooks, limit, detail) {
+  const visible = hooks.slice(0, limit).map(compactHook);
+  const omitted = Math.max(0, hooks.length - visible.length);
+  return {
+    hooks: visible,
     count: visible.length,
     total: hooks.length,
     omitted,
@@ -5394,9 +6477,9 @@ function createHooksServer() {
   });
   const defineTool = (name, description, schema, handler) => server.tool(name, description, schema, handler);
   defineTool("hooks_list", "List available hooks. Compact by default; pass compact:false for full HookMeta objects.", {
-    category: z.string().optional().describe("Filter by category name (e.g. 'Git Safety', 'Code Quality', 'Security')"),
-    compact: z.boolean().default(true).describe("Return compact summaries by default. Set false for full fields."),
-    limit: z.number().default(25).describe("Max compact rows to return")
+    category: z2.string().optional().describe("Filter by category name (e.g. 'Git Safety', 'Code Quality', 'Security')"),
+    compact: z2.boolean().default(true).describe("Return compact summaries by default. Set false for full fields."),
+    limit: z2.number().default(25).describe("Max compact rows to return")
   }, async ({ category, compact, limit }) => {
     const maxRows = boundedLimit(limit, 25, 100);
     if (category) {
@@ -5414,15 +6497,15 @@ function createHooksServer() {
     return { content: [{ type: "text", text: JSON.stringify(compact ? compactHookResult(HOOKS, maxRows, "hooks_info") : result) }] };
   });
   defineTool("hooks_search", "Search hooks. Compact by default; pass compact:false for full HookMeta objects.", {
-    query: z.string().describe("Search query"),
-    compact: z.boolean().default(true).describe("Return compact summaries by default. Set false for full fields."),
-    limit: z.number().default(10).describe("Max compact rows to return")
+    query: z2.string().describe("Search query"),
+    compact: z2.boolean().default(true).describe("Return compact summaries by default. Set false for full fields."),
+    limit: z2.number().default(10).describe("Max compact rows to return")
   }, async ({ query, compact, limit }) => {
     const results = searchHooks(query);
     const out = compact ? compactHookResult(results, boundedLimit(limit, 10, 100), "hooks_info") : results;
     return { content: [{ type: "text", text: JSON.stringify(out) }] };
   });
-  defineTool("hooks_info", "Get detailed information about a specific hook including install status", { name: z.string().describe("Hook name (e.g. 'gitguard', 'checkpoint')") }, async ({ name }) => {
+  defineTool("hooks_info", "Get detailed information about a specific hook including install status", { name: z2.string().describe("Hook name (e.g. 'gitguard', 'checkpoint')") }, async ({ name }) => {
     const meta = getHook(name);
     if (!meta) {
       return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
@@ -5432,18 +6515,18 @@ function createHooksServer() {
     return { content: [{ type: "text", text: JSON.stringify({ ...meta, global: globalInstalled, project: projectInstalled }) }] };
   });
   defineTool("hooks_install", "Install one or more hooks by registering them in agent settings", {
-    hooks: z.array(z.string()).describe("Hook names to install"),
-    scope: z.enum(["global", "project"]).default("global").describe("Install scope"),
-    overwrite: z.boolean().default(false).describe("Overwrite if already installed"),
-    profile: z.string().optional().describe("Agent profile ID to scope hooks to")
+    hooks: z2.array(z2.string()).describe("Hook names to install"),
+    scope: z2.enum(["global", "project"]).default("global").describe("Install scope"),
+    overwrite: z2.boolean().default(false).describe("Overwrite if already installed"),
+    profile: z2.string().optional().describe("Agent profile ID to scope hooks to")
   }, async ({ hooks, scope, overwrite, profile }) => {
     const results = hooks.map((name) => installHook(name, { scope, overwrite, profile }));
     return formatInstallResults(results, { scope, profile });
   });
   defineTool("hooks_install_category", "Install all hooks in a category", {
-    category: z.string().describe("Category name"),
-    scope: z.enum(["global", "project"]).default("global").describe("Install scope"),
-    overwrite: z.boolean().default(false).describe("Overwrite if already installed")
+    category: z2.string().describe("Category name"),
+    scope: z2.enum(["global", "project"]).default("global").describe("Install scope"),
+    overwrite: z2.boolean().default(false).describe("Overwrite if already installed")
   }, async ({ category, scope, overwrite }) => {
     const cat = CATEGORIES.find((c) => c.toLowerCase() === category.toLowerCase());
     if (!cat) {
@@ -5454,45 +6537,53 @@ function createHooksServer() {
     return formatInstallResults(results, { category: cat, scope });
   });
   defineTool("hooks_install_all", "Install all available hooks", {
-    scope: z.enum(["global", "project"]).default("global").describe("Install scope"),
-    overwrite: z.boolean().default(false).describe("Overwrite if already installed")
+    scope: z2.enum(["global", "project"]).default("global").describe("Install scope"),
+    overwrite: z2.boolean().default(false).describe("Overwrite if already installed")
   }, async ({ scope, overwrite }) => {
     const results = HOOKS.map((h) => installHook(h.name, { scope, overwrite }));
     return formatInstallResults(results, { scope });
   });
   defineTool("hooks_remove", "Remove (unregister) a hook from agent settings", {
-    name: z.string().describe("Hook name to remove"),
-    scope: z.enum(["global", "project"]).default("global").describe("Scope to remove from")
+    name: z2.string().describe("Hook name to remove"),
+    scope: z2.enum(["global", "project"]).default("global").describe("Scope to remove from")
   }, async ({ name, scope }) => {
     const removed = removeHook(name, scope);
     return { content: [{ type: "text", text: JSON.stringify({ hook: name, removed, scope }) }] };
   });
   defineTool("hooks_doctor", "Check health of installed hooks \u2014 verifies hook source exists, settings are correct", {
-    scope: z.enum(["global", "project"]).default("global").describe("Scope to check")
+    scope: z2.enum(["global", "project"]).default("global").describe("Scope to check")
   }, async ({ scope }) => {
     const settingsPath = getSettingsPath(scope);
     const issues = [];
     const healthy = [];
-    const settingsExist = existsSync6(settingsPath);
+    const settingsExist = existsSync11(settingsPath);
     if (!settingsExist) {
       issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
     }
     const registered = getRegisteredHooks(scope);
     for (const name of registered) {
-      const meta = getHook(name);
+      const custom = readCustomManifest(name);
+      const meta = custom ? resolveHookMeta(name) : getHook(name);
       let hookHealthy = true;
-      if (!hookExists(name)) {
-        issues.push({ hook: name, issue: "Hook not found in @hasna/hooks package", severity: "error" });
-        continue;
-      }
-      const hookDir = getHookPath(name);
-      if (!existsSync6(join6(hookDir, "src", "hook.ts"))) {
-        issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
-        hookHealthy = false;
+      if (custom) {
+        if (!existsSync11(custom.scriptPath)) {
+          issues.push({ hook: name, issue: `Custom hook script missing: ${custom.scriptPath}`, severity: "error" });
+          hookHealthy = false;
+        }
+      } else {
+        if (!hookExists(name)) {
+          issues.push({ hook: name, issue: "Hook not found in @hasna/hooks package", severity: "error" });
+          continue;
+        }
+        const hookDir = getHookPath(name);
+        if (!existsSync11(join11(hookDir, "src", "hook.ts"))) {
+          issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
+          hookHealthy = false;
+        }
       }
       if (meta && settingsExist) {
         try {
-          const settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+          const settings = JSON.parse(readFileSync9(settingsPath, "utf-8"));
           const eventHooks = settings.hooks?.[meta.event] || [];
           const found = eventHooks.some((entry) => entry.hooks?.some((h) => {
             const match = h.command?.match(/^hooks run ([\w-]+)/);
@@ -5517,8 +6608,8 @@ function createHooksServer() {
     return { content: [{ type: "text", text: JSON.stringify(result) }] };
   });
   defineTool("hooks_docs", "Get documentation. Hook README content is summarized by default; pass verbose:true for the full README.", {
-    name: z.string().optional().describe("Hook name for specific docs, omit for general docs"),
-    verbose: z.boolean().default(false).describe("Return full hook README when true")
+    name: z2.string().optional().describe("Hook name for specific docs, omit for general docs"),
+    verbose: z2.boolean().default(false).describe("Return full hook README when true")
   }, async ({ name, verbose }) => {
     if (name) {
       const meta = getHook(name);
@@ -5526,10 +6617,10 @@ function createHooksServer() {
         return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
       }
       const hookPath = getHookPath(name);
-      const readmePath = join6(hookPath, "README.md");
+      const readmePath = join11(hookPath, "README.md");
       let readme = "";
-      if (existsSync6(readmePath)) {
-        readme = readFileSync4(readmePath, "utf-8");
+      if (existsSync11(readmePath)) {
+        readme = readFileSync9(readmePath, "utf-8");
       }
       if (verbose) {
         return { content: [{ type: "text", text: JSON.stringify({ ...meta, readme }) }] };
@@ -5577,9 +6668,9 @@ function createHooksServer() {
     };
   });
   defineTool("hooks_registered", "Get currently registered hooks for a scope. Compact by default.", {
-    scope: z.enum(["global", "project"]).default("global").describe("Scope to check"),
-    compact: z.boolean().default(true).describe("Return compact summaries by default. Set false for descriptions."),
-    limit: z.number().default(25).describe("Max compact rows to return")
+    scope: z2.enum(["global", "project"]).default("global").describe("Scope to check"),
+    compact: z2.boolean().default(true).describe("Return compact summaries by default. Set false for descriptions."),
+    limit: z2.number().default(25).describe("Max compact rows to return")
   }, async ({ scope, compact, limit }) => {
     const registered = getRegisteredHooks(scope);
     const result = registered.map((name) => {
@@ -5609,18 +6700,18 @@ function createHooksServer() {
     };
   });
   defineTool("hooks_run", "Execute a hook programmatically with the given input and return its output", {
-    name: z.string().describe("Hook name (e.g. 'gitguard', 'checkpoint')"),
-    input: z.record(z.string(), z.unknown()).default(() => ({})).describe("Hook input as JSON object (HookInput)"),
-    profile: z.string().optional().describe("Agent profile ID to inject into hook input"),
-    timeout_ms: z.number().default(1e4).describe("Timeout in milliseconds (default: 10000)")
+    name: z2.string().describe("Hook name (e.g. 'gitguard', 'checkpoint')"),
+    input: z2.record(z2.string(), z2.unknown()).default(() => ({})).describe("Hook input as JSON object (HookInput)"),
+    profile: z2.string().optional().describe("Agent profile ID to inject into hook input"),
+    timeout_ms: z2.number().default(1e4).describe("Timeout in milliseconds (default: 10000)")
   }, async ({ name, input, profile, timeout_ms }) => {
     const meta = getHook(name);
     if (!meta) {
       return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
     }
     const hookDir = getHookPath(name);
-    const hookScript = join6(hookDir, "src", "hook.ts");
-    if (!existsSync6(hookScript)) {
+    const hookScript = join11(hookDir, "src", "hook.ts");
+    if (!existsSync11(hookScript)) {
       return { content: [{ type: "text", text: JSON.stringify({ error: `Hook script not found: ${hookScript}` }) }] };
     }
     let hookInput = { ...input };
@@ -5635,29 +6726,28 @@ function createHooksServer() {
         };
       }
     }
-    const proc = Bun.spawn(["bun", "run", hookScript], {
-      stdin: new Response(JSON.stringify(hookInput)),
-      stdout: "pipe",
-      stderr: "pipe",
-      env: process.env
-    });
-    const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(null), timeout_ms));
-    const result = await Promise.race([
-      Promise.all([
-        new Response(proc.stdout).text(),
-        new Response(proc.stderr).text(),
-        proc.exited
-      ]).then(([stdout, stderr, exitCode]) => ({ stdout, stderr, exitCode, timedOut: false })),
-      timeoutPromise.then(() => {
-        proc.kill();
-        return { stdout: "", stderr: "", exitCode: -1, timedOut: true };
-      })
-    ]);
+    let ran = null;
+    try {
+      ran = await Promise.race([
+        runVerifiedHook(name, hookScript, JSON.stringify(hookInput), timeout_ms),
+        new Promise((resolve2) => setTimeout(() => resolve2(null), timeout_ms))
+      ]);
+    } catch (err) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ hook: name, error: err instanceof Error ? err.message : String(err), trust_failed: true })
+        }]
+      };
+    }
+    const timedOut = ran === null;
+    const stdoutText = ran?.stdout ?? "";
+    const stderrText = ran?.stderr ?? "";
     let output = {};
     try {
-      output = JSON.parse(result.stdout);
+      output = JSON.parse(stdoutText);
     } catch {
-      output = result.stdout ? { raw: result.stdout } : {};
+      output = stdoutText ? { raw: stdoutText } : {};
     }
     return {
       content: [{
@@ -5665,16 +6755,16 @@ function createHooksServer() {
         text: JSON.stringify({
           hook: name,
           output,
-          stderr: result.stderr || undefined,
-          exitCode: result.exitCode,
-          ...result.timedOut ? { timedOut: true, timeout_ms } : {}
+          stderr: stderrText || undefined,
+          exitCode: ran?.exitCode ?? -1,
+          ...timedOut ? { timedOut: true, timeout_ms } : {}
         })
       }]
     };
   });
   defineTool("hooks_update", "Re-register installed hooks to pick up new package version (reinstalls with overwrite)", {
-    hooks: z.array(z.string()).optional().describe("Hook names to update (omit to update all installed hooks)"),
-    scope: z.enum(["global", "project"]).default("global").describe("Scope to update")
+    hooks: z2.array(z2.string()).optional().describe("Hook names to update (omit to update all installed hooks)"),
+    scope: z2.enum(["global", "project"]).default("global").describe("Scope to update")
   }, async ({ hooks, scope }) => {
     const installed = getRegisteredHooks(scope);
     const toUpdate = hooks && hooks.length > 0 ? hooks : installed;
@@ -5692,9 +6782,9 @@ function createHooksServer() {
     return { content: [{ type: "text", text: JSON.stringify({ updated, failed, total: results.length }) }] };
   });
   defineTool("hooks_context", "Get compact agent context in one call: installed hooks, active profile summary, settings path, and doctor status.", {
-    scope: z.enum(["global", "project"]).default("global").describe("Scope to inspect"),
-    profile: z.string().optional().describe("Agent profile ID to include in context"),
-    verbose: z.boolean().default(false).describe("Include full profile preferences/details when true")
+    scope: z2.enum(["global", "project"]).default("global").describe("Scope to inspect"),
+    profile: z2.string().optional().describe("Agent profile ID to include in context"),
+    verbose: z2.boolean().default(false).describe("Include full profile preferences/details when true")
   }, async ({ scope, profile, verbose }) => {
     const settingsPath = getSettingsPath(scope);
     const registered = getRegisteredHooks(scope);
@@ -5712,7 +6802,7 @@ function createHooksServer() {
     const ctx = {
       scope,
       settings_path: settingsPath,
-      settings_exists: existsSync6(settingsPath),
+      settings_exists: existsSync11(settingsPath),
       registered_hooks: hooks,
       hook_count: hooks.length,
       healthy,
@@ -5728,10 +6818,10 @@ function createHooksServer() {
     return { content: [{ type: "text", text: JSON.stringify(ctx) }] };
   });
   defineTool("hooks_preview", "Simulate which installed PreToolUse hooks would fire for a given tool call and what decision each returns. Use this to understand your hook environment before taking an action.", {
-    tool_name: z.string().describe("Tool name to simulate (e.g. 'Bash', 'Write', 'Edit')"),
-    tool_input: z.record(z.string(), z.unknown()).default(() => ({})).describe("Tool input to pass to matching hooks"),
-    scope: z.enum(["global", "project"]).default("global").describe("Scope to check"),
-    timeout_ms: z.number().default(5000).describe("Per-hook timeout in milliseconds")
+    tool_name: z2.string().describe("Tool name to simulate (e.g. 'Bash', 'Write', 'Edit')"),
+    tool_input: z2.record(z2.string(), z2.unknown()).default(() => ({})).describe("Tool input to pass to matching hooks"),
+    scope: z2.enum(["global", "project"]).default("global").describe("Scope to check"),
+    timeout_ms: z2.number().default(5000).describe("Per-hook timeout in milliseconds")
   }, async ({ tool_name, tool_input, scope, timeout_ms }) => {
     const registered = getRegisteredHooks(scope);
     const matchingHooks = registered.filter((name) => {
@@ -5752,28 +6842,23 @@ function createHooksServer() {
     const input = { tool_name, tool_input };
     const results = await Promise.all(matchingHooks.map(async (name) => {
       const hookDir = getHookPath(name);
-      const hookScript = join6(hookDir, "src", "hook.ts");
-      if (!existsSync6(hookScript))
+      const hookScript = join11(hookDir, "src", "hook.ts");
+      if (!existsSync11(hookScript))
         return { name, decision: "approve", error: "script not found" };
-      const proc = Bun.spawn(["bun", "run", hookScript], {
-        stdin: new Response(JSON.stringify(input)),
-        stdout: "pipe",
-        stderr: "pipe",
-        env: process.env
-      });
-      const timeout = new Promise((r) => setTimeout(() => r(null), timeout_ms));
-      const res = await Promise.race([
-        Promise.all([new Response(proc.stdout).text(), proc.exited]).then(([stdout]) => ({ stdout, timedOut: false })),
-        timeout.then(() => {
-          proc.kill();
-          return { stdout: "", timedOut: true };
-        })
-      ]);
-      if (res.timedOut)
+      let ran = null;
+      try {
+        ran = await Promise.race([
+          runVerifiedHook(name, hookScript, JSON.stringify(input), timeout_ms),
+          new Promise((r) => setTimeout(() => r(null), timeout_ms))
+        ]);
+      } catch (err) {
+        return { name, decision: "block", error: err instanceof Error ? err.message : String(err) };
+      }
+      if (ran === null)
         return { name, decision: "approve", timedOut: true };
       let output = {};
       try {
-        output = JSON.parse(res.stdout);
+        output = JSON.parse(ran.stdout);
       } catch {}
       return { name, decision: output.decision ?? "approve", reason: output.reason, raw: output };
     }));
@@ -5793,10 +6878,10 @@ function createHooksServer() {
     };
   });
   defineTool("hooks_setup", "Single-shot agent onboarding: create an agent profile + install recommended hooks in one call. Ideal for agents setting up hooks at session start.", {
-    agent_type: z.enum(["claude", "gemini", "custom"]).default("claude").describe("Type of AI agent"),
-    name: z.string().optional().describe("Optional display name for the agent"),
-    hooks: z.array(z.string()).optional().describe("Hook names to install (omit for sensible defaults: gitguard, checkpoint, checktests, protectfiles)"),
-    scope: z.enum(["global", "project"]).default("global").describe("Install scope")
+    agent_type: z2.enum(["claude", "gemini", "custom"]).default("claude").describe("Type of AI agent"),
+    name: z2.string().optional().describe("Optional display name for the agent"),
+    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 }) => {
     const profile = createProfile({ agent_type, name });
     const toInstall = hooks && hooks.length > 0 ? hooks : ["gitguard", "checkpoint", "checktests", "protectfiles"];
@@ -5811,52 +6896,49 @@ function createHooksServer() {
     };
   });
   defineTool("hooks_batch_run", "Run multiple hooks in parallel in a single call. Returns all results at once \u2014 more efficient than N separate hooks_run calls.", {
-    hooks: z.array(z.object({
-      name: z.string().describe("Hook name"),
-      input: z.record(z.string(), z.unknown()).default(() => ({})).describe("Hook input JSON")
+    hooks: z2.array(z2.object({
+      name: z2.string().describe("Hook name"),
+      input: z2.record(z2.string(), z2.unknown()).default(() => ({})).describe("Hook input JSON")
     })).describe("List of hooks to run with their inputs"),
-    timeout_ms: z.number().default(1e4).describe("Per-hook timeout in milliseconds")
+    timeout_ms: z2.number().default(1e4).describe("Per-hook timeout in milliseconds")
   }, async ({ hooks, timeout_ms }) => {
     const results = await Promise.all(hooks.map(async ({ name, input }) => {
       const meta = getHook(name);
       if (!meta)
         return { name, error: `Hook '${name}' not found` };
-      const hookScript = join6(getHookPath(name), "src", "hook.ts");
-      if (!existsSync6(hookScript))
+      const hookScript = join11(getHookPath(name), "src", "hook.ts");
+      if (!existsSync11(hookScript))
         return { name, error: "script not found" };
-      const proc = Bun.spawn(["bun", "run", hookScript], {
-        stdin: new Response(JSON.stringify(input)),
-        stdout: "pipe",
-        stderr: "pipe",
-        env: process.env
-      });
-      const timeout = new Promise((r) => setTimeout(() => r(null), timeout_ms));
-      const res = await Promise.race([
-        Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]).then(([stdout, stderr, exitCode]) => ({ stdout, stderr, exitCode, timedOut: false })),
-        timeout.then(() => {
-          proc.kill();
-          return { stdout: "", stderr: "", exitCode: -1, timedOut: true };
-        })
-      ]);
+      let ran = null;
+      try {
+        ran = await Promise.race([
+          runVerifiedHook(name, hookScript, JSON.stringify(input), timeout_ms),
+          new Promise((r) => setTimeout(() => r(null), timeout_ms))
+        ]);
+      } catch (err) {
+        return { name, error: err instanceof Error ? err.message : String(err) };
+      }
+      const stdoutText = ran?.stdout ?? "";
+      const timedOut = ran === null;
       let output = {};
       try {
-        output = JSON.parse(res.stdout);
+        output = JSON.parse(stdoutText);
       } catch {
-        output = res.stdout ? { raw: res.stdout } : {};
+        output = stdoutText ? { raw: stdoutText } : {};
       }
-      return { name, output, exitCode: res.exitCode, ...res.timedOut ? { timedOut: true } : {} };
+      return { name, output, exitCode: ran?.exitCode ?? -1, ...timedOut ? { timedOut: true } : {} };
     }));
     return { content: [{ type: "text", text: JSON.stringify({ results, count: results.length }) }] };
   });
   defineTool("hooks_disable", "Temporarily disable a registered hook without removing it. Stores disabled list in settings under hooks.__disabled.", {
-    name: z.string().describe("Hook name to disable"),
-    scope: z.enum(["global", "project"]).default("global").describe("Scope")
+    name: z2.string().describe("Hook name to disable"),
+    scope: z2.enum(["global", "project"]).default("global").describe("Scope")
   }, async ({ name, scope }) => {
     const settingsPath = getSettingsPath(scope);
     let settings = {};
     try {
-      if (existsSync6(settingsPath))
-        settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+      if (existsSync11(settingsPath))
+        settings = JSON.parse(readFileSync9(settingsPath, "utf-8"));
     } catch {}
     if (!settings.hooks)
       settings.hooks = {};
@@ -5864,43 +6946,43 @@ function createHooksServer() {
     if (!disabled.includes(name))
       disabled.push(name);
     settings.hooks.__disabled = disabled;
-    const { writeFileSync: writeFileSync3, mkdirSync: mkdirSync4 } = await import("fs");
-    const { dirname: dirname3 } = await import("path");
-    mkdirSync4(dirname3(settingsPath), { recursive: true });
-    writeFileSync3(settingsPath, JSON.stringify(settings, null, 2) + `
+    const { writeFileSync: writeFileSync7, mkdirSync: mkdirSync8 } = await import("fs");
+    const { dirname: dirname5 } = await import("path");
+    mkdirSync8(dirname5(settingsPath), { recursive: true });
+    writeFileSync7(settingsPath, JSON.stringify(settings, null, 2) + `
 `);
     return { content: [{ type: "text", text: JSON.stringify({ hook: name, disabled: true, scope }) }] };
   });
   defineTool("hooks_enable", "Re-enable a previously disabled hook.", {
-    name: z.string().describe("Hook name to enable"),
-    scope: z.enum(["global", "project"]).default("global").describe("Scope")
+    name: z2.string().describe("Hook name to enable"),
+    scope: z2.enum(["global", "project"]).default("global").describe("Scope")
   }, async ({ name, scope }) => {
     const settingsPath = getSettingsPath(scope);
     let settings = {};
     try {
-      if (existsSync6(settingsPath))
-        settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+      if (existsSync11(settingsPath))
+        settings = JSON.parse(readFileSync9(settingsPath, "utf-8"));
     } catch {}
     if (settings.hooks?.__disabled) {
       settings.hooks.__disabled = settings.hooks.__disabled.filter((n) => n !== name);
       if (settings.hooks.__disabled.length === 0)
         delete settings.hooks.__disabled;
-      const { writeFileSync: writeFileSync3 } = await import("fs");
-      writeFileSync3(settingsPath, JSON.stringify(settings, null, 2) + `
+      const { writeFileSync: writeFileSync7 } = await import("fs");
+      writeFileSync7(settingsPath, JSON.stringify(settings, null, 2) + `
 `);
     }
     return { content: [{ type: "text", text: JSON.stringify({ hook: name, disabled: false, scope }) }] };
   });
   defineTool("hooks_init", "Register a new agent profile \u2014 returns a unique agent_id for use with hook installation and execution", {
-    agent_type: z.enum(["claude", "gemini", "custom"]).default("claude").describe("Type of AI agent"),
-    name: z.string().optional().describe("Optional display name for the agent")
+    agent_type: z2.enum(["claude", "gemini", "custom"]).default("claude").describe("Type of AI agent"),
+    name: z2.string().optional().describe("Optional display name for the agent")
   }, async ({ agent_type, name }) => {
     const profile = createProfile({ agent_type, name });
     return { content: [{ type: "text", text: JSON.stringify(profile) }] };
   });
   defineTool("hooks_profiles", "List registered agent profiles. Compact by default.", {
-    compact: z.boolean().default(true).describe("Return compact summaries by default. Set false for full profiles."),
-    limit: z.number().default(25).describe("Max compact rows to return")
+    compact: z2.boolean().default(true).describe("Return compact summaries by default. Set false for full profiles."),
+    limit: z2.number().default(25).describe("Max compact rows to return")
   }, async ({ compact, limit }) => {
     const profiles = listProfiles();
     if (!compact)
@@ -5926,11 +7008,11 @@ function createHooksServer() {
     };
   });
   defineTool("hooks_log_list", "List hook events from SQLite. Compact summaries by default; set compact:false for full event rows.", {
-    hook_name: z.string().optional().describe("Filter by hook name (e.g. 'sessionlog', 'costwatch')"),
-    session_id: z.string().optional().describe("Filter by session ID prefix"),
-    limit: z.number().optional().describe("Max number of events to return. Defaults to 20 compact rows or 50 full rows."),
-    since: z.string().optional().describe("ISO timestamp or duration string (e.g. '1h', '30m', '7d') to filter from"),
-    compact: z.boolean().default(true).describe("Return compact event summaries by default. Set false for full rows.")
+    hook_name: z2.string().optional().describe("Filter by hook name (e.g. 'sessionlog', 'costwatch')"),
+    session_id: z2.string().optional().describe("Filter by session ID prefix"),
+    limit: z2.number().optional().describe("Max number of events to return. Defaults to 20 compact rows or 50 full rows."),
+    since: z2.string().optional().describe("ISO timestamp or duration string (e.g. '1h', '30m', '7d') to filter from"),
+    compact: z2.boolean().default(true).describe("Return compact event summaries by default. Set false for full rows.")
   }, async ({ hook_name, session_id, limit, since, compact }) => {
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
     const db = getDb2();
@@ -5976,8 +7058,8 @@ function createHooksServer() {
     };
   });
   defineTool("hooks_log_tail", "Show recent hook events from SQLite. Compact summaries by default.", {
-    n: z.number().default(20).describe("Number of most recent events to return"),
-    compact: z.boolean().default(true).describe("Return compact event summaries by default. Set false for full rows.")
+    n: z2.number().default(20).describe("Number of most recent events to return"),
+    compact: z2.boolean().default(true).describe("Return compact event summaries by default. Set false for full rows.")
   }, async ({ n, compact }) => {
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
     const db = getDb2();
@@ -5996,9 +7078,9 @@ function createHooksServer() {
     };
   });
   defineTool("hooks_log_errors", "Show hook events that contain errors. Compact summaries by default.", {
-    since: z.string().default("24h").describe("Duration string (e.g. '1h', '30m', '7d') or ISO timestamp"),
-    limit: z.number().optional().describe("Max number of error events to return. Defaults to 20 compact rows or 50 full rows."),
-    compact: z.boolean().default(true).describe("Return compact event summaries by default. Set false for full rows.")
+    since: z2.string().default("24h").describe("Duration string (e.g. '1h', '30m', '7d') or ISO timestamp"),
+    limit: z2.number().optional().describe("Max number of error events to return. Defaults to 20 compact rows or 50 full rows."),
+    compact: z2.boolean().default(true).describe("Return compact event summaries by default. Set false for full rows.")
   }, async ({ since, limit, compact }) => {
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
     const db = getDb2();
@@ -6026,7 +7108,7 @@ function createHooksServer() {
     };
   });
   defineTool("hooks_log_summary", "Summarize hook execution: counts per hook, error rates, and recent activity.", {
-    since: z.string().default("24h").describe("Duration string (e.g. '1h', '24h', '7d') or ISO timestamp")
+    since: z2.string().default("24h").describe("Duration string (e.g. '1h', '24h', '7d') or ISO timestamp")
   }, async ({ since }) => {
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
     const db = getDb2();
@@ -6060,13 +7142,13 @@ function createHooksServer() {
     };
   });
   defineTool("storage_status", "Show hooks storage sync configuration and local sync history.", {}, async () => ({ content: [{ type: "text", text: JSON.stringify(getStorageStatus()) }] }));
-  defineTool("storage_push", "Push local hook data to storage PostgreSQL.", { tables: z.array(z.string()).optional() }, async (params) => ({ content: [{ type: "text", text: JSON.stringify(await storagePush(params.tables ? { tables: params.tables } : undefined)) }] }));
-  defineTool("storage_pull", "Pull hook data from storage PostgreSQL to local SQLite.", { tables: z.array(z.string()).optional() }, async (params) => ({ content: [{ type: "text", text: JSON.stringify(await storagePull(params.tables ? { tables: params.tables } : undefined)) }] }));
-  defineTool("storage_sync", "Bidirectional hooks storage sync: pull then push.", { tables: z.array(z.string()).optional() }, async (params) => ({ content: [{ type: "text", text: JSON.stringify(await storageSync(params.tables ? { tables: params.tables } : undefined)) }] }));
+  defineTool("storage_push", "Push local hook data to storage PostgreSQL.", { tables: z2.array(z2.string()).optional() }, async (params) => ({ content: [{ type: "text", text: JSON.stringify(await storagePush(params.tables ? { tables: params.tables } : undefined)) }] }));
+  defineTool("storage_pull", "Pull hook data from storage PostgreSQL to local SQLite.", { tables: z2.array(z2.string()).optional() }, async (params) => ({ content: [{ type: "text", text: JSON.stringify(await storagePull(params.tables ? { tables: params.tables } : undefined)) }] }));
+  defineTool("storage_sync", "Bidirectional hooks storage sync: pull then push.", { tables: z2.array(z2.string()).optional() }, async (params) => ({ content: [{ type: "text", text: JSON.stringify(await storageSync(params.tables ? { tables: params.tables } : undefined)) }] }));
   defineTool("send_feedback", "Send feedback about this service", {
-    message: z.string(),
-    email: z.string().optional(),
-    category: z.enum(["bug", "feature", "general"]).optional()
+    message: z2.string(),
+    email: z2.string().optional(),
+    category: z2.enum(["bug", "feature", "general"]).optional()
   }, async (params) => {
     try {
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
@@ -6083,8 +7165,8 @@ function createHooksServer() {
     }
   });
   defineTool("register_agent", "Register an agent session. Returns agent_id. Auto-triggers a heartbeat.", {
-    name: z.string(),
-    session_id: z.string().optional()
+    name: z2.string(),
+    session_id: z2.string().optional()
   }, async (params) => {
     const existing = [..._hooksAgents.values()].find((a) => a.name === params.name);
     if (existing) {
@@ -6099,7 +7181,7 @@ function createHooksServer() {
     return { content: [{ type: "text", text: JSON.stringify(ag) }] };
   });
   defineTool("heartbeat", "Update last_seen_at to signal agent is active.", {
-    agent_id: z.string()
+    agent_id: z2.string()
   }, async (params) => {
     const ag = _hooksAgents.get(params.agent_id);
     if (!ag)
@@ -6108,8 +7190,8 @@ function createHooksServer() {
     return { content: [{ type: "text", text: JSON.stringify({ agent_id: ag.id, last_seen_at: ag.last_seen_at }) }] };
   });
   defineTool("set_focus", "Set active project context for this agent session.", {
-    agent_id: z.string(),
-    project_id: z.string().optional()
+    agent_id: z2.string(),
+    project_id: z2.string().optional()
   }, async (params) => {
     const ag = _hooksAgents.get(params.agent_id);
     if (!ag)
@@ -6118,8 +7200,8 @@ function createHooksServer() {
     return { content: [{ type: "text", text: JSON.stringify({ agent_id: ag.id, project_id: ag.project_id ?? null }) }] };
   });
   defineTool("list_agents", "List registered agents. Compact by default.", {
-    compact: z.boolean().default(true).describe("Return compact agent summaries by default. Set false for full records."),
-    limit: z.number().default(25).describe("Max compact rows to return")
+    compact: z2.boolean().default(true).describe("Return compact agent summaries by default. Set false for full records."),
+    limit: z2.number().default(25).describe("Max compact rows to return")
   }, async ({ compact, limit }) => {
     const agents = [..._hooksAgents.values()];
     if (!compact)
@@ -6194,14 +7276,17 @@ var init_server = __esm(() => {
   init_registry();
   init_installer();
   init_profiles();
+  init_manifest();
+  init_resolve();
+  init_store();
   init_storage();
-  __dirname3 = dirname2(fileURLToPath2(import.meta.url));
+  __dirname3 = dirname4(fileURLToPath2(import.meta.url));
   pkg = { name: "@hasna/hooks", version: "0.0.0" };
   try {
     for (const rel of ["../../package.json", "../package.json", "../../../package.json"]) {
-      const p = join6(__dirname3, rel);
-      if (existsSync6(p)) {
-        pkg = JSON.parse(readFileSync4(p, "utf-8"));
+      const p = join11(__dirname3, rel);
+      if (existsSync11(p)) {
+        pkg = JSON.parse(readFileSync9(p, "utf-8"));
         break;
       }
     }
@@ -6268,8 +7353,9 @@ 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/@hasna/events/dist/commander.js
+// ../../node_modules/.bun/@hasna+events@0.1.15/node_modules/@hasna/events/dist/commander.js
 import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { Buffer as Buffer2 } from "buffer";
 import { existsSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
@@ -6374,6 +7460,9 @@ function channelMatchesEvent(channel, event) {
 }
 var HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR";
 var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
+var LOCAL_JSON_EVENT_CURSOR_PREFIX = "local-json-v1:";
+var DEFAULT_EVENT_PAGE_LIMIT = 100;
+var MAX_EVENT_PAGE_LIMIT = 1000;
 function getEventsDataDir(override) {
   return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join(homedir(), ".hasna", "events");
 }
@@ -6387,11 +7476,13 @@ function getActiveEventsDirEnv() {
 
 class JsonEventsStore {
   dataDir;
+  runtime;
   channelsPath;
   eventsPath;
   deliveriesPath;
   constructor(dataDir = getEventsDataDir()) {
     this.dataDir = dataDir;
+    this.runtime = localJsonRuntime(dataDir);
     this.channelsPath = join(dataDir, "channels.json");
     this.eventsPath = join(dataDir, "events.json");
     this.deliveriesPath = join(dataDir, "deliveries.json");
@@ -6439,13 +7530,58 @@ class JsonEventsStore {
     await this.writeJson(this.eventsPath, events);
     return event;
   }
-  async listEvents() {
+  async appendEventOnce(event, options = {}) {
     await this.init();
-    return this.readJson(this.eventsPath, []);
+    const events = await this.readJson(this.eventsPath, []);
+    const dedupe = options.dedupe !== false;
+    if (dedupe) {
+      const existing = findEventByIdentity(events, { id: event.id, dedupeKey: event.dedupeKey });
+      if (existing) {
+        return {
+          event: existing,
+          stored: false,
+          deduped: true,
+          identity: { id: existing.id, dedupeKey: existing.dedupeKey }
+        };
+      }
+    }
+    events.push(event);
+    await this.writeJson(this.eventsPath, events);
+    return {
+      event,
+      stored: true,
+      deduped: false,
+      identity: { id: event.id, dedupeKey: event.dedupeKey }
+    };
+  }
+  async listEvents(options = {}) {
+    await this.init();
+    const events = await this.readJson(this.eventsPath, []);
+    return queryEvents(events, options);
+  }
+  async listEventsPage(options = {}) {
+    await this.init();
+    const events = await this.readJson(this.eventsPath, []);
+    const queried = queryEvents(events, {
+      eventId: options.eventId,
+      source: options.source,
+      type: options.type
+    });
+    const offset = decodeLocalJsonEventCursor(options.cursor, options);
+    const limit = normalizeEventPageLimit(options.limit);
+    const pageEvents = queried.slice(offset, offset + limit);
+    const nextOffset = offset + pageEvents.length;
+    const hasMore = nextOffset < queried.length;
+    return {
+      events: pageEvents,
+      cursor: options.cursor,
+      nextCursor: hasMore ? encodeLocalJsonEventCursor(nextOffset, options) : undefined,
+      hasMore
+    };
   }
   async findEventByIdentity(identity) {
     const events = await this.listEvents();
-    return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
+    return findEventByIdentity(events, identity);
   }
   async appendDelivery(result) {
     await this.init();
@@ -6496,6 +7632,83 @@ class JsonEventsStore {
     });
   }
 }
+function localJsonRuntime(dataDir = getEventsDataDir()) {
+  return {
+    mode: "local-files",
+    name: "json-events-store",
+    remote: false,
+    localFiles: true,
+    localSqlite: false,
+    postgres: false,
+    s3: false,
+    aws: false,
+    durable: true,
+    idempotency: "best-effort-local",
+    replayCursors: true,
+    description: `Local JSON files in ${dataDir}; no SQLite, Postgres, S3, or AWS runtime is configured by this store.`
+  };
+}
+function encodeLocalJsonEventCursor(offset, options = {}) {
+  if (!Number.isInteger(offset) || offset < 0)
+    throw new Error(`Invalid event cursor offset: ${offset}`);
+  const payload = {
+    offset,
+    eventId: options.eventId,
+    source: options.source,
+    type: options.type
+  };
+  return `${LOCAL_JSON_EVENT_CURSOR_PREFIX}${Buffer2.from(JSON.stringify(payload), "utf-8").toString("base64url")}`;
+}
+function decodeLocalJsonEventCursor(cursor, options = {}) {
+  if (!cursor)
+    return 0;
+  if (!cursor.startsWith(LOCAL_JSON_EVENT_CURSOR_PREFIX))
+    throw new Error(`Invalid local JSON event cursor: ${cursor}`);
+  const rawPayload = cursor.slice(LOCAL_JSON_EVENT_CURSOR_PREFIX.length);
+  let payload;
+  try {
+    payload = JSON.parse(Buffer2.from(rawPayload, "base64url").toString("utf-8"));
+  } catch {
+    throw new Error(`Invalid local JSON event cursor: ${cursor}`);
+  }
+  const offset = payload.offset;
+  if (!Number.isInteger(offset) || offset < 0)
+    throw new Error(`Invalid local JSON event cursor: ${cursor}`);
+  assertCursorFilter("eventId", payload.eventId, options.eventId);
+  assertCursorFilter("source", payload.source, options.source);
+  assertCursorFilter("type", payload.type, options.type);
+  return offset;
+}
+function normalizeEventPageLimit(limit) {
+  if (limit === undefined)
+    return DEFAULT_EVENT_PAGE_LIMIT;
+  if (!Number.isInteger(limit) || limit < 1)
+    throw new Error(`Event page limit must be a positive integer, got ${limit}`);
+  return Math.min(limit, MAX_EVENT_PAGE_LIMIT);
+}
+function queryEvents(events, options) {
+  let rows = events;
+  if (options.eventId)
+    rows = rows.filter((event) => event.id === options.eventId);
+  if (options.source)
+    rows = rows.filter((event) => event.source === options.source);
+  if (options.type)
+    rows = rows.filter((event) => event.type === options.type);
+  if (options.cursor) {
+    const offset = decodeLocalJsonEventCursor(options.cursor, options);
+    rows = rows.slice(offset);
+  }
+  if (options.limit !== undefined)
+    rows = rows.slice(0, normalizeEventPageLimit(options.limit));
+  return rows;
+}
+function assertCursorFilter(name, cursorValue, optionValue) {
+  if (cursorValue !== optionValue)
+    throw new Error(`Local JSON event cursor ${name} filter mismatch`);
+}
+function findEventByIdentity(events, identity) {
+  return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
+}
 async function getEventsStatus(dataDir) {
   const store = new JsonEventsStore(dataDir);
   await store.init();
@@ -6512,6 +7725,7 @@ async function getEventsStatus(dataDir) {
     service: "events",
     schemaVersion: "1.0",
     dataDir: store.dataDir,
+    storage: store.runtime,
     env: {
       primary: HASNA_EVENTS_DIR_ENV,
       fallback: HASNA_EVENTS_HOME_ENV,
@@ -6556,21 +7770,27 @@ function now() {
 function truncate(value, max = 4096) {
   return value.length > max ? `${value.slice(0, max)}...` : value;
 }
-function buildWebhookRequest(event, channel) {
+function buildWebhookRequest(event, channel, options = {}) {
   if (!channel.webhook)
     throw new Error(`Channel ${channel.id} has no webhook config`);
+  for (const name of Object.keys(channel.webhook.headers ?? {})) {
+    if (/^x-hasna-/i.test(name)) {
+      throw new Error(`Webhook header ${name} is reserved for signed delivery metadata`);
+    }
+  }
   const body = JSON.stringify(event);
-  const timestamp = event.time;
+  const timestamp = options.timestamp ?? new Date().toISOString();
   const headers = {
     "Content-Type": "application/json",
     "User-Agent": "@hasna/events",
     "X-Hasna-Event-Id": event.id,
     "X-Hasna-Event-Type": event.type,
-    "X-Hasna-Timestamp": timestamp,
-    ...channel.webhook.headers
+    ...channel.webhook.headers,
+    "X-Hasna-Timestamp": timestamp
   };
-  if (channel.webhook.secret) {
-    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp, body);
+  const secret = options.secret ?? channel.webhook.secret;
+  if (secret) {
+    headers["X-Hasna-Signature"] = signPayload(secret, timestamp, body);
   }
   return { body, headers };
 }
@@ -6578,7 +7798,21 @@ async function dispatchWebhook(event, channel, options = {}) {
   if (!channel.webhook)
     throw new Error(`Channel ${channel.id} has no webhook config`);
   const startedAt = now();
-  const { body, headers } = buildWebhookRequest(event, channel);
+  let secret = channel.webhook.secret;
+  if (channel.webhook.secretRef) {
+    if (!options.secretResolver) {
+      return failedAttempt(startedAt, "Webhook secret reference has no runtime resolver");
+    }
+    try {
+      secret = await options.secretResolver(channel.webhook.secretRef);
+    } catch {
+      return failedAttempt(startedAt, "Webhook secret reference could not be resolved");
+    }
+    if (!secret)
+      return failedAttempt(startedAt, "Webhook secret reference could not be resolved");
+  }
+  const timestamp = (options.now?.() ?? new Date).toISOString();
+  const { body, headers } = buildWebhookRequest(event, channel, { secret, timestamp });
   const controller = new AbortController;
   const timeout = setTimeout(() => controller.abort(), channel.webhook.timeoutMs ?? 15000);
   try {
@@ -6610,6 +7844,15 @@ async function dispatchWebhook(event, channel, options = {}) {
     clearTimeout(timeout);
   }
 }
+function failedAttempt(startedAt, error) {
+  return {
+    attempt: 1,
+    status: "failed",
+    startedAt,
+    completedAt: now(),
+    error
+  };
+}
 async function dispatchCommand(event, channel) {
   if (!channel.command)
     throw new Error(`Channel ${channel.id} has no command config`);
@@ -6698,6 +7941,90 @@ function createDeliveryResult(event, channel, attempts) {
     completedAt: attempts.at(-1)?.completedAt ?? now()
   };
 }
+
+class EventValidationError extends Error {
+  eventType;
+  issues;
+  constructor(eventType, issues) {
+    const detail = issues.map((issue) => `${issue.path || "<root>"}: ${issue.message}`).join("; ");
+    super(`Event validation failed for type "${eventType}": ${detail}`);
+    this.name = "EventValidationError";
+    this.eventType = eventType;
+    this.issues = issues;
+  }
+}
+
+class EventTypeCatalog {
+  definitions = new Map;
+  register(definition) {
+    this.definitions.set(definition.type, definition);
+    return this;
+  }
+  unregister(type) {
+    return this.definitions.delete(type);
+  }
+  has(type) {
+    return this.definitions.has(type);
+  }
+  get(type) {
+    return this.definitions.get(type);
+  }
+  list() {
+    return [...this.definitions.values()];
+  }
+  validateEvent(event) {
+    const definition = this.definitions.get(event.type);
+    if (!definition)
+      return { ok: true };
+    return definition.validate(event.data, event);
+  }
+  assertEventValid(event) {
+    const result = this.validateEvent(event);
+    if (!result.ok) {
+      throw new EventValidationError(event.type, result.issues);
+    }
+  }
+}
+var defaultEventTypeCatalog = new EventTypeCatalog;
+var APP_EVENT_V1_MAX_DATA_BYTES = 32 * 1024;
+function redactPaths(event, paths, replacement = "[REDACTED]") {
+  if (paths.length === 0)
+    return event;
+  const copy = structuredClone(event);
+  for (const path of paths) {
+    setPath(copy, path, replacement);
+  }
+  return copy;
+}
+function redactSensitiveKeys(event, replacement = "[REDACTED]") {
+  return redactValue(event, replacement);
+}
+function shouldRedactKey(key) {
+  return /secret|token|password|api[_-]?key|authorization/i.test(key);
+}
+function redactValue(value, replacement) {
+  if (Array.isArray(value))
+    return value.map((item) => redactValue(item, replacement));
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key,
+    shouldRedactKey(key) ? replacement : redactValue(item, replacement)
+  ]));
+}
+function setPath(input, path, replacement) {
+  const parts = path.split(".");
+  let cursor = input;
+  for (const part of parts.slice(0, -1)) {
+    const next = cursor[part];
+    if (!next || typeof next !== "object")
+      return;
+    cursor = next;
+  }
+  const last = parts.at(-1);
+  if (last && last in cursor)
+    cursor[last] = replacement;
+}
 function createEvent(input) {
   return {
     id: input.id ?? randomUUID2(),
@@ -6718,10 +8045,18 @@ class EventsClient {
   store;
   redactors;
   transportOptions;
+  catalog;
+  validateCatalogTypes;
   constructor(options = {}) {
     this.store = options.store ?? new JsonEventsStore(options.dataDir);
     this.redactors = options.redactors ?? [];
-    this.transportOptions = { fetchImpl: options.fetchImpl };
+    this.transportOptions = {
+      fetchImpl: options.fetchImpl,
+      secretResolver: options.secretResolver,
+      now: options.now
+    };
+    this.catalog = options.catalog ?? defaultEventTypeCatalog;
+    this.validateCatalogTypes = options.validateCatalogTypes ?? false;
   }
   async addChannel(input) {
     const timestamp = new Date().toISOString();
@@ -6739,18 +8074,40 @@ class EventsClient {
   }
   async emit(input, options = {}) {
     const event = options.redactSensitiveData === false ? createEvent(input) : redactSensitiveKeys(createEvent(input));
-    if (options.dedupe !== false) {
-      const existing = await this.store.findEventByIdentity({ id: input.id, dedupeKey: event.dedupeKey });
-      if (existing) {
-        return { event: existing, deliveries: [], deduped: true };
-      }
-    }
-    await this.store.appendEvent(event);
-    const deliveries = options.deliver === false ? [] : await this.deliver(event);
-    return { event, deliveries, deduped: false };
-  }
-  async listEvents() {
-    return this.store.listEvents();
+    if (options.validate ?? this.validateCatalogTypes) {
+      this.catalog.assertEventValid(event);
+    }
+    const append = await this.appendEvent(event, { dedupe: options.dedupe !== false });
+    if (append.deduped) {
+      return { event: append.event, deliveries: [], deduped: true };
+    }
+    const deliveries = options.deliver === false ? [] : await this.deliver(append.event);
+    return { event: append.event, deliveries, deduped: false };
+  }
+  async listEvents(options = {}) {
+    if (Object.keys(options).length === 0)
+      return this.store.listEvents();
+    return queryClientEvents(await this.store.listEvents(), options);
+  }
+  async listEventsPage(options = {}) {
+    if (this.store.listEventsPage)
+      return this.store.listEventsPage(options);
+    const events = queryClientEvents(await this.store.listEvents(), {
+      eventId: options.eventId,
+      source: options.source,
+      type: options.type
+    });
+    const offset = decodeLocalJsonEventCursor(options.cursor, options);
+    const limit = normalizeEventPageLimit(options.limit);
+    const pageEvents = events.slice(offset, offset + limit);
+    const nextOffset = offset + pageEvents.length;
+    const hasMore = nextOffset < events.length;
+    return {
+      events: pageEvents,
+      cursor: options.cursor,
+      nextCursor: hasMore ? encodeLocalJsonEventCursor(nextOffset, options) : undefined,
+      hasMore
+    };
   }
   async listDeliveries() {
     return this.store.listDeliveries();
@@ -6818,22 +8175,37 @@ class EventsClient {
     return result;
   }
   async replay(options = {}) {
-    const events = (await this.store.listEvents()).filter((event) => {
-      if (options.eventId && event.id !== options.eventId)
-        return false;
-      if (options.source && event.source !== options.source)
-        return false;
-      if (options.type && event.type !== options.type)
-        return false;
-      return true;
-    });
+    const page = options.cursor || options.limit !== undefined ? await this.listEventsPage(options) : { events: await this.listEvents(options), hasMore: false };
     if (options.dryRun)
-      return { events, deliveries: [] };
+      return { events: page.events, deliveries: [], cursor: page.cursor, nextCursor: page.nextCursor, hasMore: page.hasMore };
     const deliveries = [];
-    for (const event of events) {
+    for (const event of page.events) {
       deliveries.push(...await this.deliver(event));
     }
-    return { events, deliveries };
+    return { events: page.events, deliveries, cursor: page.cursor, nextCursor: page.nextCursor, hasMore: page.hasMore };
+  }
+  async appendEvent(event, options) {
+    if (this.store.appendEventOnce) {
+      return this.store.appendEventOnce(event, { dedupe: options.dedupe });
+    }
+    if (options.dedupe) {
+      const existing = await this.store.findEventByIdentity({ id: event.id, dedupeKey: event.dedupeKey });
+      if (existing) {
+        return {
+          event: existing,
+          stored: false,
+          deduped: true,
+          identity: { id: existing.id, dedupeKey: existing.dedupeKey }
+        };
+      }
+    }
+    const stored = await this.store.appendEvent(event);
+    return {
+      event: stored,
+      stored: true,
+      deduped: false,
+      identity: { id: stored.id, dedupeKey: stored.dedupeKey }
+    };
   }
   async applyRedaction(event, channel) {
     let next = redactPaths(event, channel.redact?.paths ?? [], channel.redact?.replacement ?? "[REDACTED]");
@@ -6860,15 +8232,6 @@ class EventsClient {
     return createDeliveryResult(event, channel, attempts);
   }
 }
-function redactPaths(event, paths, replacement = "[REDACTED]") {
-  if (paths.length === 0)
-    return event;
-  const copy = structuredClone(event);
-  for (const path of paths) {
-    setPath(copy, path, replacement);
-  }
-  return copy;
-}
 function sanitizeChannelForOutput(channel) {
   const copy = structuredClone(channel);
   if (copy.webhook?.secret)
@@ -6881,34 +8244,19 @@ function sanitizeChannelForOutput(channel) {
 function sanitizeChannelsForOutput(channels) {
   return channels.map(sanitizeChannelForOutput);
 }
-function redactSensitiveKeys(event, replacement = "[REDACTED]") {
-  return redactValue(event, replacement);
-}
-function shouldRedactKey(key) {
-  return /secret|token|password|api[_-]?key|authorization/i.test(key);
-}
-function redactValue(value, replacement) {
-  if (Array.isArray(value))
-    return value.map((item) => redactValue(item, replacement));
-  if (!value || typeof value !== "object")
-    return value;
-  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-    key,
-    shouldRedactKey(key) ? replacement : redactValue(item, replacement)
-  ]));
-}
-function setPath(input, path, replacement) {
-  const parts = path.split(".");
-  let cursor = input;
-  for (const part of parts.slice(0, -1)) {
-    const next = cursor[part];
-    if (!next || typeof next !== "object")
-      return;
-    cursor = next;
-  }
-  const last = parts.at(-1);
-  if (last && last in cursor)
-    cursor[last] = replacement;
+function queryClientEvents(events, options) {
+  let rows = events;
+  if (options.eventId)
+    rows = rows.filter((event) => event.id === options.eventId);
+  if (options.source)
+    rows = rows.filter((event) => event.source === options.source);
+  if (options.type)
+    rows = rows.filter((event) => event.type === options.type);
+  if (options.cursor)
+    rows = rows.slice(decodeLocalJsonEventCursor(options.cursor, options));
+  if (options.limit !== undefined)
+    rows = rows.slice(0, normalizeEventPageLimit(options.limit));
+  return rows;
 }
 function normalizeTime(value) {
   if (!value)
@@ -6992,6 +8340,7 @@ function parseMatcherExpression(value, label) {
     negated: false
   };
 }
+var DEFAULT_EVENT_LIST_LIMIT = 100;
 function parseJsonObject(value, fallback) {
   if (!value)
     return fallback;
@@ -7024,6 +8373,14 @@ function print(value, json, text) {
   else
     console.log(text);
 }
+function fail(error, json) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (json)
+    console.log(JSON.stringify({ error: message }, null, 2));
+  else
+    console.error(message);
+  process.exitCode = 1;
+}
 function hasJsonOption(options) {
   return Boolean(options?.json || options?.opts?.().json || options?.optsWithGlobals?.().json || options?.parent?.opts?.().json || options?.parent?.optsWithGlobals?.().json);
 }
@@ -7078,26 +8435,36 @@ function registerChannelCommands(program, options) {
     print({ removed }, wantsJson(actionOptions, command), removed ? `Removed ${id}` : `Channel not found: ${id}`);
   });
   channels.command("test").description("Send a test event to one channel").argument("<id>", "Channel identifier").option("--source <source>", "Event source override").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--honor-filters", "Skip delivery when the sample event does not match channel filters", false).option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
-    const result = await createClient(options).testChannel(id, {
-      source: actionOptions.source ?? options.source,
-      type: actionOptions.type,
-      subject: actionOptions.subject ?? id,
-      message: actionOptions.message,
-      data: parseJsonObject(actionOptions.data, { test: true }),
-      metadata: parseJsonObject(actionOptions.metadata, {})
-    }, { honorFilters: actionOptions.honorFilters });
-    print(result, wantsJson(actionOptions, command), `${result.status}: ${result.channelId}`);
+    const json = wantsJson(actionOptions, command);
+    try {
+      const result = await createClient(options).testChannel(id, {
+        source: actionOptions.source ?? options.source,
+        type: actionOptions.type,
+        subject: actionOptions.subject ?? id,
+        message: actionOptions.message,
+        data: parseJsonObject(actionOptions.data, { test: true }),
+        metadata: parseJsonObject(actionOptions.metadata, {})
+      }, { honorFilters: actionOptions.honorFilters });
+      print(result, json, `${result.status}: ${result.channelId}`);
+    } catch (error) {
+      fail(error, json);
+    }
   });
   channels.command("match").description("Check whether a sample event matches one channel without delivering").argument("<id>", "Channel identifier").option("--source <source>", "Event source override").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events match preview").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
-    const result = await createClient(options).matchChannel(id, {
-      source: actionOptions.source ?? options.source,
-      type: actionOptions.type,
-      subject: actionOptions.subject ?? id,
-      message: actionOptions.message,
-      data: parseJsonObject(actionOptions.data, { test: true }),
-      metadata: parseJsonObject(actionOptions.metadata, {})
-    });
-    print(result, wantsJson(actionOptions, command), `${result.matched ? "matched" : "skipped"}: ${result.channelId}`);
+    const json = wantsJson(actionOptions, command);
+    try {
+      const result = await createClient(options).matchChannel(id, {
+        source: actionOptions.source ?? options.source,
+        type: actionOptions.type,
+        subject: actionOptions.subject ?? id,
+        message: actionOptions.message,
+        data: parseJsonObject(actionOptions.data, { test: true }),
+        metadata: parseJsonObject(actionOptions.metadata, {})
+      });
+      print(result, json, `${result.matched ? "matched" : "skipped"}: ${result.channelId}`);
+    } catch (error) {
+      fail(error, json);
+    }
   });
   return channels;
 }
@@ -7116,7 +8483,8 @@ function registerEventCommands(program, options) {
     }, { deliver: actionOptions.deliver, dedupe: actionOptions.dedupe });
     print(result, wantsJson(actionOptions, command), `${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`);
   });
-  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+  const defaultListLimit = options.defaultEventListLimit ?? DEFAULT_EVENT_LIST_LIMIT;
+  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", `Limit to the most recent <n> events (default ${defaultListLimit}; use 0 for all)`, parseNumber, defaultListLimit).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
     let rows = await createClient(options).listEvents();
     if (actionOptions.source)
       rows = rows.filter((event) => event.source === actionOptions.source);
@@ -7135,14 +8503,16 @@ function registerEventCommands(program, options) {
     for (const event of rows)
       console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
   });
-  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--cursor <cursor>", "Opaque replay cursor from a previous page").option("--limit <n>", "Maximum events to replay", parseNumber).option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
     const result = await createClient(options).replay({
       eventId: actionOptions.id,
       source: actionOptions.source,
       type: actionOptions.type,
+      cursor: actionOptions.cursor,
+      limit: actionOptions.limit,
       dryRun: actionOptions.dryRun
     });
-    print(result, wantsJson(actionOptions, command), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
+    print(result, wantsJson(actionOptions, command), replaySummary(result.events.length, result.deliveries.length, result.nextCursor));
   });
   return events;
 }
@@ -7160,11 +8530,15 @@ function collectValues(value, previous) {
   previous.push(value);
   return previous;
 }
+function replaySummary(events, deliveries, nextCursor) {
+  const suffix = nextCursor ? `, next cursor: ${nextCursor}` : "";
+  return `Replayed ${events} event(s), ${deliveries} delivery result(s)${suffix}`;
+}
 
 // src/cli/index.tsx
 import { render } from "ink";
 
-// node_modules/commander/esm.mjs
+// ../../node_modules/.bun/commander@12.1.0/node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
   program,
@@ -7182,19 +8556,19 @@ var {
 
 // src/cli/index.tsx
 import chalk2 from "chalk";
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { join as join12, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cli/components/App.tsx
 import { useState as useState7 } from "react";
 import { Box as Box8, Text as Text10, useApp, useInput as useInput5 } from "ink";
 
-// node_modules/ink-select-input/build/Indicator.js
+// ../../node_modules/.bun/ink-select-input@6.2.0+fa875fef9f949ebd/node_modules/ink-select-input/build/Indicator.js
 import React from "react";
 import { Box, Text } from "ink";
 
-// node_modules/is-unicode-supported/index.js
+// ../../node_modules/.bun/is-unicode-supported@2.1.0/node_modules/is-unicode-supported/index.js
 import process2 from "process";
 function isUnicodeSupported() {
   const { env } = process2;
@@ -7205,7 +8579,7 @@ function isUnicodeSupported() {
   return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 
-// node_modules/figures/index.js
+// ../../node_modules/.bun/figures@6.1.0/node_modules/figures/index.js
 var common = {
   circleQuestionMark: "(?)",
   questionMarkPrefix: "(?)",
@@ -7481,23 +8855,23 @@ var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
 var figures_default = figures;
 var replacements = Object.entries(specialMainSymbols);
 
-// node_modules/ink-select-input/build/Indicator.js
+// ../../node_modules/.bun/ink-select-input@6.2.0+fa875fef9f949ebd/node_modules/ink-select-input/build/Indicator.js
 function Indicator({ isSelected = false }) {
   return React.createElement(Box, { marginRight: 1 }, isSelected ? React.createElement(Text, { color: "blue" }, figures_default.pointer) : React.createElement(Text, null, " "));
 }
 var Indicator_default = Indicator;
-// node_modules/ink-select-input/build/Item.js
+// ../../node_modules/.bun/ink-select-input@6.2.0+fa875fef9f949ebd/node_modules/ink-select-input/build/Item.js
 import * as React2 from "react";
 import { Text as Text2 } from "ink";
 function Item({ isSelected = false, label }) {
   return React2.createElement(Text2, { color: isSelected ? "blue" : undefined }, label);
 }
 var Item_default = Item;
-// node_modules/ink-select-input/build/SelectInput.js
+// ../../node_modules/.bun/ink-select-input@6.2.0+fa875fef9f949ebd/node_modules/ink-select-input/build/SelectInput.js
 import { isDeepStrictEqual } from "util";
 import React3, { useState, useEffect, useRef, useCallback } from "react";
 
-// node_modules/to-rotated/index.js
+// ../../node_modules/.bun/to-rotated@1.0.0/node_modules/to-rotated/index.js
 function toRotated(array, steps) {
   if (!Array.isArray(array)) {
     throw new TypeError(`Expected an array, got \`${typeof array}\`.`);
@@ -7519,7 +8893,7 @@ function toRotated(array, steps) {
   ];
 }
 
-// node_modules/ink-select-input/build/SelectInput.js
+// ../../node_modules/.bun/ink-select-input@6.2.0+fa875fef9f949ebd/node_modules/ink-select-input/build/SelectInput.js
 import { Box as Box2, useInput } from "ink";
 function SelectInput({ items = [], isFocused = true, initialIndex = 0, indicatorComponent = Indicator_default, itemComponent = Item_default, limit: customLimit, onSelect, onHighlight }) {
   const hasLimit = typeof customLimit === "number" && items.length > customLimit;
@@ -7815,7 +9189,7 @@ function HookSelect({
 import { useState as useState4, useEffect as useEffect3 } from "react";
 import { Box as Box6, Text as Text7, useInput as useInput4 } from "ink";
 
-// node_modules/ink-text-input/build/index.js
+// ../../node_modules/.bun/ink-text-input@6.0.0+fa875fef9f949ebd/node_modules/ink-text-input/build/index.js
 import React5, { useState as useState3, useEffect as useEffect2 } from "react";
 import { Text as Text6, useInput as useInput3 } from "ink";
 import chalk from "chalk";
@@ -7993,7 +9367,7 @@ function SearchView({
 import { useState as useState6, useEffect as useEffect5 } from "react";
 import { Box as Box7, Text as Text9 } from "ink";
 
-// node_modules/ink-spinner/build/index.js
+// ../../node_modules/.bun/ink-spinner@5.0.0+fa875fef9f949ebd/node_modules/ink-spinner/build/index.js
 var import_cli_spinners = __toESM(require_cli_spinners(), 1);
 import React7, { useState as useState5, useEffect as useEffect4 } from "react";
 import { Text as Text8 } from "ink";
@@ -8359,10 +9733,12 @@ function App({ initialHooks, overwrite = false }) {
 init_registry();
 init_installer();
 init_profiles();
+init_manifest();
+init_resolve();
 import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
-var __dirname4 = dirname3(fileURLToPath3(import.meta.url));
-var pkgPath = existsSync7(join7(__dirname4, "..", "package.json")) ? join7(__dirname4, "..", "package.json") : join7(__dirname4, "..", "..", "package.json");
-var pkg2 = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+var __dirname4 = dirname5(fileURLToPath3(import.meta.url));
+var pkgPath = existsSync12(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) {
   if (options.project)
@@ -8390,6 +9766,16 @@ function truncateText2(value, max = 96) {
     return text;
   return `${text.slice(0, Math.max(0, max - 3))}...`;
 }
+function readToken(tokenFile) {
+  if (tokenFile) {
+    try {
+      return readFileSync10(tokenFile, "utf-8").trim();
+    } catch {
+      return;
+    }
+  }
+  return process.env.CF_API_TOKEN;
+}
 function readmePreview(readme, max = 280) {
   const blocks = readme.split(/\n\s*\n/).map((part) => part.trim()).filter(Boolean).filter((part) => !part.startsWith("#")).filter((part) => !part.startsWith("```")).filter((part) => !/^\[!\[/.test(part));
   const preview = blocks[0] ?? readme.split(`
@@ -8430,7 +9816,38 @@ program2.name("hooks").description("Install hooks for AI coding agents").version
 program2.command("interactive", { isDefault: true }).alias("i").description("Interactive hook browser").action(() => {
   render(/* @__PURE__ */ jsxDEV8(App, {}, undefined, false, undefined, this));
 });
-program2.command("init").description("Register a new agent profile with a unique ID").option("-a, --agent <type>", "Agent type: claude, gemini, custom", "claude").option("-n, --name <name>", "Optional display name for the agent").option("-j, --json", "Output as JSON", false).action((options) => {
+program2.command("init").description("Register a new agent profile with a unique ID").option("-a, --agent <type>", "Agent type: claude, gemini, custom", "claude").option("-n, --name <name>", "Optional display name for the agent").option("-j, --json", "Output as JSON", false).option("--cloudflare", "Configure a remote registry (Cloudflare worker)", false).option("--api-url <url>", "Remote registry API URL (with --cloudflare)").option("--api-key <ref>", "Vault key NAME for the registry API key (never the value; with --cloudflare)").action(async (options) => {
+  if (options.cloudflare) {
+    const { writeConfig: writeConfig2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+    if (!options.apiUrl) {
+      const message = "--cloudflare requires --api-url <url>";
+      if (options.json)
+        console.log(JSON.stringify({ error: message }));
+      else
+        console.log(chalk2.red(message));
+      return;
+    }
+    const config = { api_url: options.apiUrl.replace(/\/+$/, ""), api_key_ref: options.apiKey };
+    const path = writeConfig2(config);
+    if (options.json) {
+      console.log(JSON.stringify({ ok: true, api_url: config.api_url, api_key_ref: config.api_key_ref ?? null, config_path: path }));
+      return;
+    }
+    console.log(chalk2.green(`
+\u2713 Remote registry configured
+`));
+    console.log(`  ${chalk2.dim("API URL:")}    ${config.api_url}`);
+    console.log(`  ${chalk2.dim("API key ref:")} ${config.api_key_ref ?? "(none; serve will refuse publishes)"}`);
+    console.log(`  ${chalk2.dim("Config:")}      ${path}`);
+    console.log();
+    console.log(chalk2.dim("  Presence of an API URL selects the remote registry; absence means local."));
+    if (config.api_key_ref) {
+      console.log(chalk2.dim(`  Run the server with the key resolved from the vault, never the value:`));
+      console.log(`    secrets exec ${config.api_key_ref} --as HASNA_HOOKS_API_KEY -- hooks serve`);
+    }
+    console.log();
+    return;
+  }
   const agentType = options.agent;
   if (!["claude", "gemini", "custom"].includes(agentType)) {
     if (options.json) {
@@ -8461,15 +9878,27 @@ program2.command("init").description("Register a new agent profile with a unique
   console.log();
 });
 program2.command("run").argument("<hook>", "Hook to run").option("--profile <id>", "Agent profile ID").description("Execute a hook (called by AI coding agents)").action(async (hook, options) => {
-  const meta = getHook(hook);
-  if (!meta) {
+  const { resolveHook: resolveHook2, resolveScriptPath: resolveScriptPath2 } = await Promise.resolve().then(() => (init_resolve(), exports_resolve));
+  const { sha256Of: sha256Of2, checkScriptHash: checkScriptHash2 } = await Promise.resolve().then(() => (init_store(), exports_store));
+  const resolved = resolveHook2(hook);
+  if (!resolved) {
     console.error(JSON.stringify({ error: `Hook '${hook}' not found` }));
     process.exit(1);
   }
-  const hookDir = getHookPath(hook);
-  const hookScript = join7(hookDir, "src", "hook.ts");
-  if (!existsSync7(hookScript)) {
-    console.error(JSON.stringify({ error: `Hook script not found: ${hookScript}` }));
+  const hookScript = resolveScriptPath2(hook);
+  if (!hookScript || !existsSync12(hookScript)) {
+    console.error(JSON.stringify({ error: `Hook script not found: ${hookScript ?? hook}` }));
+    process.exit(1);
+  }
+  const content = readFileSync10(hookScript);
+  const check = checkScriptHash2(hook, sha256Of2(content));
+  if (!check.ok) {
+    console.error(JSON.stringify({
+      error: `Hook '${hook}' script changed since it was trusted (sha256 ${check.expected} != ${check.actual}). Run 'hooks trust ${hook}' to trust the new content.`,
+      hook,
+      expected_sha256: check.expected,
+      actual_sha256: check.actual
+    }));
     process.exit(1);
   }
   const stdin = await new Response(Bun.stdin.stream()).text();
@@ -8490,22 +9919,27 @@ program2.command("run").argument("<hook>", "Hook to run").option("--profile <id>
       } catch {}
     }
   }
-  const proc = Bun.spawn(["bun", "run", hookScript], {
-    stdin: new Response(hookStdin),
-    stdout: "pipe",
-    stderr: "pipe",
-    env: process.env
+  const { readCustomManifest: readCustomManifest2 } = await Promise.resolve().then(() => (init_manifest(), exports_manifest));
+  const { executeVerifiedScript: executeVerifiedScript2 } = await Promise.resolve().then(() => (init_run(), exports_run));
+  const custom = readCustomManifest2(hook);
+  const args = custom?.manifest.args ?? [];
+  const timeout = custom?.manifest.timeout_ms;
+  const { stdout, stderr, exitCode } = await executeVerifiedScript2({
+    name: hook,
+    scriptPath: hookScript,
+    content,
+    args,
+    stdin: hookStdin,
+    env: process.env,
+    timeout
   });
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-  const exitCode = await proc.exited;
   if (stdout)
     process.stdout.write(stdout);
   if (stderr)
     process.stderr.write(stderr);
   process.exit(exitCode);
 });
-program2.command("install").alias("add").argument("[hooks...]", "Hooks to install").option("-o, --overwrite", "Overwrite existing hooks", false).option("-a, --all", "Install all available hooks", false).option("-c, --category <category>", "Install all hooks in a category").option("-g, --global", "Install globally (~/.claude/settings.json)", false).option("-p, --project", "Install for current project (.claude/settings.json)", false).option("-t, --target <target>", "Agent target: claude, gemini, codewith, all (default: claude)", "claude").option("--profile <id>", "Agent profile ID to scope hooks to").option("--dry-run", "Preview what would be installed without writing to settings", false).option("--apply-codewith", "Explicitly append Codewith TOML to a config file (prefer open-configs for managed configs)", false).option("--codewith-config <path>", "Explicit Codewith config path required with --apply-codewith").option("-j, --json", "Output as JSON", false).description("Install one or more hooks").action((hooks, options) => {
+program2.command("install").alias("add").argument("[hooks...]", "Hooks to install").option("-o, --overwrite", "Overwrite existing hooks", false).option("-a, --all", "Install all available hooks", false).option("-c, --category <category>", "Install all hooks in a category").option("-g, --global", "Install globally (~/.claude/settings.json)", false).option("-p, --project", "Install for current project (.claude/settings.json)", false).option("-t, --target <target>", "Agent target: claude, gemini, codewith, all (default: claude)", "claude").option("--profile <id>", "Agent profile ID to scope hooks to").option("--dry-run", "Preview what would be installed without writing to settings", false).option("--apply-codewith", "Explicitly append Codewith TOML to a config file (prefer open-configs for managed configs)", false).option("--codewith-config <path>", "Explicit Codewith config path required with --apply-codewith").option("-j, --json", "Output as JSON", false).description("Install one or more hooks (registry names, local paths, git URLs, or manifest URLs)").action(async (hooks, options) => {
   const scope = resolveScope(options);
   const target = resolveTarget(options);
   let toInstall = hooks;
@@ -8537,11 +9971,21 @@ program2.command("install").alias("add").argument("[hooks...]", "Hooks to instal
     }
     return;
   }
+  const { isCustomSource: isCustomSource2, installCustomSource: installCustomSource2 } = await Promise.resolve().then(() => (init_custom_install(), exports_custom_install));
+  const customSources = toInstall.filter((n) => !getHook(n) && isCustomSource2(n));
   if (options.dryRun) {
     const known = toInstall.filter((n) => getHook(n));
-    const unknown = toInstall.filter((n) => !getHook(n));
+    const unknown = toInstall.filter((n) => !getHook(n) && !isCustomSource2(n));
     if (options.json) {
-      console.log(JSON.stringify({ dryRun: true, would_install: known, unknown, scope, target, mode: target === "codewith" ? "fragment" : "write" }));
+      console.log(JSON.stringify({
+        dryRun: true,
+        would_install: known,
+        custom_sources: customSources,
+        unknown,
+        scope,
+        target,
+        mode: target === "codewith" ? "fragment" : "write"
+      }));
       return;
     }
     console.log(chalk2.bold(`
@@ -8551,6 +9995,9 @@ Dry run \u2014 would install (${scope}, ${target}):
       const meta = getHook(name);
       console.log(chalk2.cyan(`  ${name}`) + chalk2.dim(` [${meta.event}${meta.matcher ? ` ${meta.matcher}` : ""}]`));
     }
+    for (const source of customSources) {
+      console.log(chalk2.cyan(`  ${source}`) + chalk2.dim(" [custom source: would fetch and install]"));
+    }
     if (unknown.length > 0) {
       console.log();
       for (const name of unknown) {
@@ -8561,8 +10008,29 @@ Dry run \u2014 would install (${scope}, ${target}):
     return;
   }
   const results = [];
-  for (const name of toInstall) {
-    if (!getHook(name)) {
+  const installedCustom = [];
+  for (const source of customSources) {
+    try {
+      const custom = await installCustomSource2(source);
+      installedCustom.push(custom.name);
+      if (options.json) {
+        console.log(JSON.stringify({ custom: { source, name: custom.name, version: custom.version } }));
+      } else {
+        console.log(chalk2.green(`\u2713 Installed custom hook '${custom.name}' v${custom.version} from ${source}`));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({ hook: source, success: false, error: message });
+      if (options.json) {
+        console.log(JSON.stringify({ error: `Custom hook install failed for ${source}: ${message}` }));
+      } else {
+        console.log(chalk2.red(`\u2717 ${message}`));
+      }
+    }
+  }
+  const namesToRegister = [...new Set([...toInstall.filter((n) => !isCustomSource2(n)), ...installedCustom])];
+  for (const name of namesToRegister) {
+    if (!getHook(name) && !installedCustom.includes(name)) {
       const suggestions = suggestHooks(name);
       const hint = suggestions.length ? ` \u2014 did you mean: ${suggestions.join(", ")}?` : "";
       results.push({ hook: name, success: false, error: `Hook '${name}' not found${hint}` });
@@ -8752,8 +10220,9 @@ Categories:
     console.log(`  ${category} (${count})`);
   }
 });
-program2.command("info").argument("<hook>", "Hook name").option("-j, --json", "Output as JSON", false).description("Show detailed info about a hook").action((hook, options) => {
-  const meta = getHook(hook);
+program2.command("info").argument("<hook>", "Hook name").option("-j, --json", "Output as JSON", false).description("Show detailed info about a hook").action(async (hook, options) => {
+  const { resolveHookMeta: resolveHookMeta2 } = await Promise.resolve().then(() => (init_resolve(), exports_resolve));
+  const meta = resolveHookMeta2(hook) ?? getHook(hook);
   if (!meta) {
     const suggestions = suggestHooks(hook);
     const hint = suggestions.length ? ` \u2014 did you mean: ${suggestions.join(", ")}?` : "";
@@ -8766,8 +10235,12 @@ program2.command("info").argument("<hook>", "Hook name").option("-j, --json", "O
   }
   const globalInstalled = getRegisteredHooks("global").includes(meta.name);
   const projectInstalled = getRegisteredHooks("project").includes(meta.name);
+  const { readCustomManifest: readCustomManifest2 } = await Promise.resolve().then(() => (init_manifest(), exports_manifest));
+  const custom = readCustomManifest2(meta.name);
+  const source = custom ? "custom" : "bundled";
+  const sourceNote = custom ? "custom (~/.hasna/hooks/hooks/) overrides the bundled registry" : "bundled registry";
   if (options.json) {
-    console.log(JSON.stringify({ ...meta, global: globalInstalled, project: projectInstalled }));
+    console.log(JSON.stringify({ ...meta, source, source_note: sourceNote, global: globalInstalled, project: projectInstalled }));
     return;
   }
   console.log(chalk2.bold(`
@@ -8780,6 +10253,7 @@ ${meta.displayName}
   console.log(`  ${chalk2.dim("Event:")}     ${meta.event}`);
   console.log(`  ${chalk2.dim("Matcher:")}   ${meta.matcher || "(none)"}`);
   console.log(`  ${chalk2.dim("Tags:")}      ${meta.tags.join(", ")}`);
+  console.log(`  ${chalk2.dim("Source:")}    ${source} (${sourceNote})`);
   console.log(`  ${chalk2.dim("Command:")}   hooks run ${meta.name}`);
   console.log();
   if (globalInstalled) {
@@ -8798,28 +10272,36 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
   const settingsPath = getSettingsPath(scope);
   const issues = [];
   const healthy = [];
-  const settingsExist = existsSync7(settingsPath);
+  const settingsExist = existsSync12(settingsPath);
   if (!settingsExist) {
     issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
   }
   const registered = getRegisteredHooks(scope);
   for (const name of registered) {
-    const meta = getHook(name);
+    const custom = readCustomManifest(name);
+    const meta = custom ? resolveHookMeta(name) : getHook(name);
     let hookHealthy = true;
-    if (!hookExists(name)) {
-      issues.push({ hook: name, issue: "Hook not found in @hasna/hooks package", severity: "error" });
-      hookHealthy = false;
-      continue;
-    }
-    const hookDir = getHookPath(name);
-    const hookScript = join7(hookDir, "src", "hook.ts");
-    if (!existsSync7(hookScript)) {
-      issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
-      hookHealthy = false;
+    if (custom) {
+      if (!existsSync12(custom.scriptPath)) {
+        issues.push({ hook: name, issue: `Custom hook script missing: ${custom.scriptPath}`, severity: "error" });
+        hookHealthy = false;
+      }
+    } else {
+      if (!hookExists(name)) {
+        issues.push({ hook: name, issue: "Hook not found in @hasna/hooks package", severity: "error" });
+        hookHealthy = false;
+        continue;
+      }
+      const hookDir = getHookPath(name);
+      const hookScript = join12(hookDir, "src", "hook.ts");
+      if (!existsSync12(hookScript)) {
+        issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
+        hookHealthy = false;
+      }
     }
     if (meta && settingsExist) {
       try {
-        const settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
+        const settings = JSON.parse(readFileSync10(settingsPath, "utf-8"));
         const eventHooks = settings.hooks?.[meta.event] || [];
         const found = eventHooks.some((entry) => entry.hooks?.some((h) => {
           const match = h.command?.match(/^hooks run ([\w-]+)/);
@@ -8866,7 +10348,7 @@ Hook Health Check (${scope})
   }
   console.log();
 });
-program2.command("update").argument("[hooks...]", "Hooks to update (defaults to all installed)").option("-g, --global", "Update global hooks", false).option("-p, --project", "Update project hooks", false).option("-j, --json", "Output as JSON", false).description("Re-register hooks (picks up new package version)").action((hooks, options) => {
+program2.command("update").argument("[hooks...]", "Hooks to update (defaults to all installed)").option("-g, --global", "Update global hooks", false).option("-p, --project", "Update project hooks", false).option("-j, --json", "Output as JSON", false).description("Re-register hooks (picks up new package version) and refresh the lock pins").action(async (hooks, options) => {
   const scope = resolveScope(options);
   const installed = getInstalledHooks(scope);
   const toUpdate = hooks.length > 0 ? hooks : installed;
@@ -8878,6 +10360,9 @@ program2.command("update").argument("[hooks...]", "Hooks to update (defaults to
     }
     return;
   }
+  const { resolveHook: resolveHook2 } = await Promise.resolve().then(() => (init_resolve(), exports_resolve));
+  const { sha256File: sha256File2, setPinnedHook: setPinnedHook2, upsertHookRecord: upsertHookRecord2 } = await Promise.resolve().then(() => (init_store(), exports_store));
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
   const results = [];
   for (const name of toUpdate) {
     if (!installed.includes(name)) {
@@ -8885,6 +10370,20 @@ program2.command("update").argument("[hooks...]", "Hooks to update (defaults to
       continue;
     }
     const result = installHook(name, { scope, overwrite: true });
+    const resolved = resolveHook2(name);
+    if (result.success && resolved) {
+      const hash = await sha256File2(resolved.scriptPath);
+      setPinnedHook2(resolved.name, { version: resolved.version, sha256: hash, source: resolved.source });
+      upsertHookRecord2(getDb2(), {
+        name: resolved.name,
+        version: resolved.version,
+        sha256: hash,
+        source_type: resolved.source,
+        last_verified_at: new Date().toISOString()
+      });
+      results.push({ ...result, pinned: { version: resolved.version, sha256: hash } });
+      continue;
+    }
     results.push(result);
   }
   if (options.json) {
@@ -8899,7 +10398,7 @@ Updating hooks...
 `));
   for (const result of results) {
     if (result.success) {
-      console.log(chalk2.green(`\u2713 ${result.hook} updated`));
+      console.log(chalk2.green(`\u2713 ${result.hook} updated`) + (result.pinned ? chalk2.dim(` (pinned ${result.pinned.version})`) : ""));
     } else {
       console.log(chalk2.red(`\u2717 ${result.hook}: ${result.error}`));
     }
@@ -8917,10 +10416,10 @@ program2.command("docs").argument("[hook]", "Hook name (shows general docs if om
       return;
     }
     const hookPath = getHookPath(hook);
-    const readmePath = join7(hookPath, "README.md");
+    const readmePath = join12(hookPath, "README.md");
     let readme = "";
-    if (existsSync7(readmePath)) {
-      readme = readFileSync5(readmePath, "utf-8");
+    if (existsSync12(readmePath)) {
+      readme = readFileSync10(readmePath, "utf-8");
     }
     if (options.json) {
       console.log(JSON.stringify({ ...meta, readme }));
@@ -9102,14 +10601,14 @@ Upgrading @hasna/hooks (${pm})...
 });
 program2.command("profile-export").description("Export all agent profiles as JSON (for backup/cross-machine setup)").option("-o, --output <file>", "Write to file instead of stdout").option("-j, --json", "Output as JSON (default: true)", false).action(async (options) => {
   const profiles = exportProfiles();
-  const json = JSON.stringify(profiles, null, 2);
+  const json2 = JSON.stringify(profiles, null, 2);
   if (options.output) {
-    const { writeFileSync: writeFileSync3 } = await import("fs");
-    writeFileSync3(options.output, json + `
+    const { writeFileSync: writeFileSync7 } = await import("fs");
+    writeFileSync7(options.output, json2 + `
 `);
     console.log(chalk2.green(`\u2713 Exported ${profiles.length} profile(s) to ${options.output}`));
   } else {
-    console.log(json);
+    console.log(json2);
   }
 });
 program2.command("profile-import").argument("<file>", "JSON file to import profiles from (use - for stdin)").description("Import agent profiles from a JSON export file").option("-j, --json", "Output result as JSON", false).action(async (file, options) => {
@@ -9117,9 +10616,9 @@ program2.command("profile-import").argument("<file>", "JSON file to import profi
   if (file === "-") {
     raw = await new Response(Bun.stdin.stream()).text();
   } else {
-    const { readFileSync: readFileSync6 } = await import("fs");
+    const { readFileSync: readFileSync11 } = await import("fs");
     try {
-      raw = readFileSync6(file, "utf-8");
+      raw = readFileSync11(file, "utf-8");
     } catch {
       if (options.json) {
         console.log(JSON.stringify({ error: `Cannot read file: ${file}` }));
@@ -9314,7 +10813,7 @@ storageCmd.command("status").description("Show storage sync status").option("-j,
   Storage Status
 `));
   console.log(`  Configured: ${status.configured ? chalk2.green(`yes (${status.activeEnv})`) : chalk2.red("no")}`);
-  console.log(`  Mode:       ${status.mode}`);
+  console.log(`  Backend:    ${status.backend}`);
   console.log(`  Tables:     ${status.tables.join(", ")}`);
   console.log(`  Sync rows:  ${status.sync.length}`);
 });
@@ -9376,6 +10875,126 @@ storageCmd.command("sync").description("Bidirectional storage sync: pull then pu
     process.exitCode = 1;
   }
 });
+program2.command("trust").argument("<hook>", "Hook to trust").option("-j, --json", "Output as JSON", false).description("Trust the current script content of a hook (re-pins its sha256)").action(async (hook, options) => {
+  const { resolveHook: resolveHook2 } = await Promise.resolve().then(() => (init_resolve(), exports_resolve));
+  const { retrustHook: retrustHook2 } = await Promise.resolve().then(() => (init_store(), exports_store));
+  const resolved = resolveHook2(hook);
+  if (!resolved) {
+    if (options.json)
+      console.log(JSON.stringify({ error: `Hook '${hook}' not found` }));
+    else
+      console.log(chalk2.red(`Hook '${hook}' not found`));
+    return;
+  }
+  const result = retrustHook2(resolved.name, resolved.scriptPath, resolved.version, resolved.source);
+  if (options.json) {
+    console.log(JSON.stringify({ ok: true, hook: resolved.name, version: resolved.version, sha256: result.actual, source: resolved.source }));
+    return;
+  }
+  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) => {
+  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
+  });
+});
+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 diff = plan.diff;
+    if (options.json) {
+      console.log(JSON.stringify({ dry_run: plan.dryRun, api_url: plan.apiUrl ?? null, diff }));
+      return;
+    }
+    const source = plan.apiUrl ? plan.apiUrl : "bundled registry";
+    console.log(chalk2.bold(`
+Hook sync (${source})${plan.dryRun ? " \u2014 dry run" : ""}
+`));
+    if (diff.added.length > 0) {
+      console.log(chalk2.green(`  + ${diff.added.length} to add:`));
+      for (const name of diff.added)
+        console.log(chalk2.green(`    ${name}`));
+    }
+    if (diff.updated.length > 0) {
+      console.log(chalk2.yellow(`  ~ ${diff.updated.length} to update:`));
+      for (const name of diff.updated)
+        console.log(chalk2.yellow(`    ${name}`));
+    }
+    if (diff.skipped.length > 0) {
+      console.log(chalk2.dim(`  - ${diff.skipped.length} not in remote lock (left untouched)`));
+    }
+    console.log(chalk2.dim(`  = ${diff.unchanged.length} unchanged`));
+    if (plan.dryRun)
+      console.log(chalk2.dim(`
+  Dry run: nothing was written.`));
+    else
+      console.log(chalk2.green(`
+\u2713 Synced (${diff.added.length} added, ${diff.updated.length} updated, ${diff.unchanged.length} unchanged)`));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (options.json) {
+      console.log(JSON.stringify({ error: message, changed: false }));
+    } else {
+      console.error(chalk2.red(`\u2717 ${message}`));
+      console.error(chalk2.dim("  Nothing was changed (fail-closed)."));
+    }
+    process.exitCode = 1;
+  }
+});
+program2.command("cf").description("Provision and deploy the hooks registry to Cloudflare").option("--deploy", "Provision D1 + R2 via the Cloudflare API", true).option("--dry-run", "Print the plan without calling the Cloudflare API", false).option("--account-id <id>", "Cloudflare account id (defaults to CF_ACCOUNT_ID env)").option("--database-name <name>", "D1 database name (default hooks-registry)").option("--bucket-name <name>", "R2 bucket name (default hooks-registry-artifacts)").option("--token-file <path>", "Read the API token from a file (defaults to CF_API_TOKEN env)").option("-j, --json", "Output as JSON", false).action(async (options) => {
+  const token = readToken(options.tokenFile);
+  const accountId = options.accountId ?? process.env.CF_ACCOUNT_ID;
+  if (!options.dryRun) {
+    if (!token) {
+      console.error(chalk2.red("CF_API_TOKEN is not set (or --token-file path is unreadable)."));
+      console.error(chalk2.dim("  Resolve it from the vault, never paste the value:"));
+      console.error(chalk2.dim("    secrets exec <vault-key> --as CF_API_TOKEN -- hooks cf deploy"));
+      process.exit(1);
+    }
+    if (!accountId) {
+      console.error(chalk2.red("CF_ACCOUNT_ID is not set (or pass --account-id)."));
+      process.exit(1);
+    }
+  }
+  const { provisionCloudflareResources: provisionCloudflareResources2 } = await Promise.resolve().then(() => exports_provision);
+  const result = await provisionCloudflareResources2({
+    token: token ?? "",
+    accountId: accountId ?? "",
+    databaseName: options.databaseName ?? "hooks-registry",
+    bucketName: options.bucketName ?? "hooks-registry-artifacts",
+    dryRun: options.dryRun
+  });
+  if (options.json) {
+    console.log(JSON.stringify({ dry_run: options.dryRun, ...result }));
+    return;
+  }
+  if (options.dryRun) {
+    console.log(chalk2.bold(`
+cf deploy dry run \u2014 would provision:
+`));
+  } else {
+    console.log(chalk2.bold(`
+Cloudflare provisioning complete:
+`));
+    console.log(`  ${chalk2.dim("D1:")}    ${result.d1Created ? chalk2.green(`created '${options.databaseName ?? "hooks-registry"}'`) : chalk2.dim(`exists (${result.d1DatabaseId})`)}`);
+    console.log(`  ${chalk2.dim("R2:")}    ${result.r2Created ? chalk2.green(`created '${options.bucketName ?? "hooks-registry-artifacts"}'`) : chalk2.dim("exists")}`);
+  }
+  console.log(`
+  ${chalk2.bold("Worker upload (run these with wrangler):")}`);
+  for (const cmd of result.commands) {
+    console.log(`    ${cmd}`);
+  }
+  console.log();
+  console.log(chalk2.dim("  Worker upload is not performed by this command \u2014 the worker needs the workerd"));
+  console.log(chalk2.dim("  target, which only wrangler can bundle. Copy src/cf/wrangler.toml.example to"));
+  console.log(chalk2.dim("  wrangler.toml, fill in the D1 database id, then run the commands above."));
+  console.log();
+});
 program2.command("mcp").option("-s, --stdio", "Use stdio transport (one process per agent)", false).option("--sse", "Use legacy SSE transport (port 39427)", false).option("--http", "Use Streamable HTTP transport (explicit; this is also the default)", false).option("-p, --port <port>", "Port for HTTP/SSE transport (defaults to 8847 for HTTP, 39427 for SSE)").description("Start MCP server for AI agent integration (default: shared Streamable HTTP)").action(async (options) => {
   if (options.stdio) {
     const { startStdioServer: startStdioServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));