@hasna/hooks 0.9.0 → 0.9.1

package/bin/hooks-mcp.js

@@ -0,0 +1,4862 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/lib/app-home.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { homedir as pathsResolverHomedir } from "os";
+import { join as pathsResolverJoin } from "path";
+function pathsResolverAssertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!PATHS_RESOLVER_APP_SLUG_RE.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function pathsResolverAssertKind(kind) {
+  if (!Object.keys(PATHS_RESOLVER_KIND_ENV).includes(kind)) {
+    throw new TypeError(`paths: invalid path kind "${kind}" \u2014 expected one of ${Object.keys(PATHS_RESOLVER_KIND_ENV).join(", ")}`);
+  }
+}
+function pathsResolverBaseDir(kind, options) {
+  pathsResolverAssertKind(kind);
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_KIND_ENV[kind]];
+  if (typeof override === "string" && override.length > 0)
+    return override;
+  const home = options.home ?? pathsResolverHomedir();
+  const platform = options.platform ?? process.platform;
+  if (platform === "darwin") {
+    switch (kind) {
+      case "config":
+      case "data":
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
+      case "state":
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return pathsResolverJoin(home, ".config", "hasna");
+    case "data":
+      return pathsResolverJoin(home, ".local", "share", "hasna");
+    case "state":
+      return pathsResolverJoin(home, ".local", "state", "hasna");
+    case "cache":
+      return pathsResolverJoin(home, ".cache", "hasna");
+  }
+}
+function pathsResolverResolve(kind, options) {
+  pathsResolverAssertApp(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin("internal", options.app) : options.app;
+  return pathsResolverJoin(pathsResolverBaseDir(kind, options), appSegment);
+}
+function dataDir(options) {
+  return pathsResolverResolve("data", options);
+}
+function getHomeDir(env = process.env) {
+  return env.HOME || env.USERPROFILE || homedir();
+}
+function getResolverDataRoot(env = process.env) {
+  return dataDir({ app: "hooks", home: getHomeDir(env), env });
+}
+function getLegacyDataRoot(env = process.env) {
+  return join(getHomeDir(env), ".hasna", "hooks");
+}
+function adoptResolverDataRoot(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join(resolved, STORE_MARKER));
+}
+function getExplicitDataDir(env = process.env) {
+  const dir = env.HASNA_HOOKS_DATA_DIR ?? env.HOOKS_DATA_DIR;
+  if (typeof dir === "string" && dir.trim().length > 0)
+    return dir.trim();
+  return;
+}
+function getExactDataRoot(env = process.env) {
+  const dir = env.HASNA_HOOKS_HOME?.trim() || env.HOOKS_HOME?.trim();
+  if (dir)
+    return resolve(dir);
+  return;
+}
+function getEffectiveDataRoot(env = process.env) {
+  const explicit = getExplicitDataDir(env);
+  if (explicit)
+    return explicit;
+  const exact = getExactDataRoot(env);
+  if (exact)
+    return exact;
+  const resolved = getResolverDataRoot(env);
+  return adoptResolverDataRoot(resolved, env) ? resolve(resolved) : getLegacyDataRoot(env);
+}
+function getReportedDbPath(env = process.env) {
+  const explicit = getExplicitDbPath(env);
+  if (explicit)
+    return explicit;
+  return join(getEffectiveDataRoot(env), "hooks.db");
+}
+function getExplicitDbPath(env = process.env) {
+  const db = env.HASNA_HOOKS_DB_PATH ?? env.HOOKS_DB_PATH;
+  if (typeof db === "string" && db.trim().length > 0)
+    return db.trim();
+  return;
+}
+var PATHS_RESOLVER_KIND_ENV, PATHS_RESOLVER_APP_SLUG_RE, STORE_MARKER = "hooks.db";
+var init_app_home = __esm(() => {
+  PATHS_RESOLVER_KIND_ENV = {
+    config: "HASNA_CONFIG_HOME",
+    data: "HASNA_DATA_HOME",
+    state: "HASNA_STATE_HOME",
+    cache: "HASNA_CACHE_HOME"
+  };
+  PATHS_RESOLVER_APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+});
+
+// src/lib/registry.ts
+function getHooksByCategory(category) {
+  return HOOKS.filter((h) => h.category === category);
+}
+function getHookEvents(hook) {
+  return hook.events && hook.events.length > 0 ? hook.events : [hook.event];
+}
+function searchHooks(query) {
+  const q = query.toLowerCase();
+  return HOOKS.filter((h) => h.name.toLowerCase().includes(q) || h.displayName.toLowerCase().includes(q) || h.description.toLowerCase().includes(q) || h.tags.some((t) => t.includes(q)));
+}
+function getHook(name) {
+  return HOOKS.find((h) => h.name === name);
+}
+var CATEGORIES, HOOKS;
+var init_registry = __esm(() => {
+  init_app_home();
+  CATEGORIES = [
+    "Git Safety",
+    "Code Quality",
+    "Security",
+    "Notifications",
+    "Context Management",
+    "Workflow Automation",
+    "Environment",
+    "Permissions",
+    "Observability",
+    "Agent Teams"
+  ];
+  HOOKS = [
+    {
+      name: "gitguard",
+      displayName: "Git Guard",
+      description: "Blocks destructive git operations like reset --hard, push --force, clean -f",
+      version: "0.1.0",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "Bash",
+      tags: ["git", "safety", "destructive", "guard"]
+    },
+    {
+      name: "branchprotect",
+      displayName: "Branch Protect",
+      description: "Prevents editing files directly on main/master branch",
+      version: "0.1.0",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "Write|Edit|NotebookEdit",
+      tags: ["git", "branch", "protection", "main"]
+    },
+    {
+      name: "checkpoint",
+      displayName: "Checkpoint",
+      description: "Creates shadow git snapshots before file modifications for easy rollback",
+      version: "0.1.0",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "Write|Edit|NotebookEdit",
+      tags: ["git", "snapshot", "rollback", "backup"]
+    },
+    {
+      name: "worktree-guard",
+      displayName: "Worktree Guard",
+      description: "Warns on feature work outside managed repos worktrees and blocks scoped destructive operations",
+      version: "0.1.0",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "^(Bash|Write|Edit|MultiEdit|NotebookEdit|apply_patch|ApplyPatch|functions\\.apply_patch|mcp__.*)$",
+      tags: ["git", "worktree", "repos", "multi-agent", "safety", "dangerous-ops"]
+    },
+    {
+      name: "workspace-repos-guard",
+      displayName: "Workspace Repos Guard",
+      description: "Blocks writes and deletes that break the protected repo-checkout structure (~/.hasna/repos/clones canonical, plus legacy ~/workspace/repos during the migration window): writes to a protected root, top-level entry creation, non-org folders, and any delete under a protected root",
+      version: "0.1.0",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "^(Bash|Write|Edit|MultiEdit|NotebookEdit|apply_patch|ApplyPatch|functions\\.apply_patch)$",
+      tags: ["workspace", "repos", "structure", "guard", "safety", "orgs", "multi-agent"]
+    },
+    {
+      name: "trash-guard",
+      displayName: "Trash Guard",
+      description: "Rewrites rm issued through Bash into `trash guard`, so the delete lands in a recoverable trash store; refuses the delete when there is nothing to redirect to (trash absent, a delete verb it cannot rewrite, or the protected class: /, ~, ~/.hasna, ~/.ssh, ~/.aws)",
+      version: "0.1.1",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "^(Bash|apply_patch|ApplyPatch|functions\\.apply_patch)$",
+      tags: ["rm", "delete", "trash", "recoverable", "guard", "safety", "bash"],
+      rewritesInput: true,
+      timeoutSeconds: 5
+    },
+    {
+      name: "checktests",
+      displayName: "Check Tests",
+      description: "Checks for missing tests after file edits",
+      version: "0.1.6",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["tests", "coverage", "quality"]
+    },
+    {
+      name: "checklint",
+      displayName: "Check Lint",
+      description: "Runs linting after file edits and creates tasks for errors",
+      version: "0.1.7",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["lint", "style", "quality"]
+    },
+    {
+      name: "checkfiles",
+      displayName: "Check Files",
+      description: "Runs headless agent to review files and create tasks",
+      version: "0.1.4",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["review", "files", "quality"]
+    },
+    {
+      name: "checkbugs",
+      displayName: "Check Bugs",
+      description: "Checks for bugs via headless agent",
+      version: "0.1.6",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["bugs", "analysis", "quality"]
+    },
+    {
+      name: "checkdocs",
+      displayName: "Check Docs",
+      description: "Checks for missing documentation and creates tasks",
+      version: "0.2.1",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["docs", "documentation", "quality"]
+    },
+    {
+      name: "checktasks",
+      displayName: "Check Tasks",
+      description: "Validates task completion and tracks progress",
+      version: "1.0.8",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["tasks", "tracking", "quality"]
+    },
+    {
+      name: "checksecurity",
+      displayName: "Check Security",
+      description: "Runs security checks via headless agents",
+      version: "0.1.6",
+      category: "Security",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["security", "audit", "vulnerabilities"]
+    },
+    {
+      name: "packageage",
+      displayName: "Package Age",
+      description: "Checks package age before install to prevent typosquatting",
+      version: "0.1.1",
+      category: "Security",
+      event: "PreToolUse",
+      matcher: "Bash",
+      tags: ["npm", "packages", "typosquatting", "supply-chain"]
+    },
+    {
+      name: "pre-bash",
+      displayName: "Pre Bash",
+      description: "Codewith Bash gate for staged secrets scans before commit/push and comms rechecks before risky operations",
+      version: "0.1.0",
+      category: "Security",
+      event: "PreToolUse",
+      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",
+      description: "Sends push notifications to phone via ntfy.sh",
+      version: "0.1.0",
+      category: "Notifications",
+      event: "Stop",
+      matcher: "",
+      tags: ["notification", "phone", "push", "ntfy"]
+    },
+    {
+      name: "agentmessages",
+      displayName: "Agent Messages",
+      description: "Inter-agent messaging integration for service-message",
+      version: "0.1.0",
+      category: "Notifications",
+      event: "Stop",
+      matcher: "",
+      tags: ["messaging", "agents", "inter-agent"]
+    },
+    {
+      name: "contextrefresh",
+      displayName: "Context Refresh",
+      description: "Re-injects important context every N prompts to prevent drift",
+      version: "0.1.0",
+      category: "Context Management",
+      event: "Notification",
+      matcher: "",
+      tags: ["context", "memory", "prompts", "refresh"]
+    },
+    {
+      name: "precompact",
+      displayName: "Pre-Compact",
+      description: "Saves session state before context compaction",
+      version: "0.1.0",
+      category: "Context Management",
+      event: "Notification",
+      matcher: "",
+      tags: ["context", "compaction", "state", "backup"]
+    },
+    {
+      name: "knowledge-context",
+      displayName: "Knowledge Context",
+      description: "Injects deterministic Knowledge context packs into Codewith SessionStart, UserPromptSubmit, and SubagentStart",
+      version: "0.1.6",
+      category: "Context Management",
+      event: "SessionStart",
+      events: ["SessionStart", "UserPromptSubmit", "SubagentStart"],
+      matcher: "",
+      tags: ["knowledge", "context", "codewith", "deterministic", "session-start", "prompt", "subagent"]
+    },
+    {
+      name: "autoformat",
+      displayName: "Auto Format",
+      description: "Runs project formatter (Prettier, Biome, Ruff, Black, gofmt) after file edits",
+      version: "0.1.0",
+      category: "Workflow Automation",
+      event: "PostToolUse",
+      matcher: "Edit|Write",
+      tags: ["format", "prettier", "biome", "ruff", "black", "gofmt", "style"]
+    },
+    {
+      name: "autostage",
+      displayName: "Auto Stage",
+      description: "Automatically git-stages files after Claude edits them",
+      version: "0.1.0",
+      category: "Workflow Automation",
+      event: "PostToolUse",
+      matcher: "Edit|Write",
+      tags: ["git", "stage", "add", "auto"]
+    },
+    {
+      name: "tddguard",
+      displayName: "TDD Guard",
+      description: "Blocks implementation edits unless corresponding test files exist",
+      version: "0.1.0",
+      category: "Workflow Automation",
+      event: "PreToolUse",
+      matcher: "Edit|Write",
+      tags: ["tdd", "tests", "red-green-refactor", "enforcement"]
+    },
+    {
+      name: "envsetup",
+      displayName: "Env Setup",
+      description: "Warns when nvm, virtualenv, asdf, or rbenv may need activation before commands",
+      version: "0.1.0",
+      category: "Environment",
+      event: "PreToolUse",
+      matcher: "Bash",
+      tags: ["nvm", "virtualenv", "asdf", "rbenv", "environment", "python", "node"]
+    },
+    {
+      name: "permissionguard",
+      displayName: "Permission Guard",
+      description: "Auto-approves safe read-only commands and blocks dangerous operations",
+      version: "0.1.0",
+      category: "Permissions",
+      event: "PreToolUse",
+      matcher: "Bash",
+      tags: ["permission", "allowlist", "blocklist", "safety", "auto-approve"]
+    },
+    {
+      name: "protectfiles",
+      displayName: "Protect Files",
+      description: "Blocks access to .env, secrets, SSH keys, and lock files",
+      version: "0.1.0",
+      category: "Permissions",
+      event: "PreToolUse",
+      matcher: "Edit|Write|Read|Bash",
+      tags: ["security", "env", "secrets", "keys", "lock-files", "protect"]
+    },
+    {
+      name: "promptguard",
+      displayName: "Prompt Guard",
+      description: "Blocks prompt injection attempts and credential access requests",
+      version: "0.1.0",
+      category: "Permissions",
+      event: "PreToolUse",
+      matcher: "",
+      tags: ["prompt", "injection", "security", "validation", "guard"]
+    },
+    {
+      name: "prompt-guard",
+      displayName: "Prompt Guard (Codewith)",
+      description: "Codewith UserPromptSubmit guard for obvious pasted prompt-injection and fake policy/freeze instructions",
+      version: "0.1.0",
+      category: "Permissions",
+      event: "UserPromptSubmit",
+      matcher: "",
+      tags: ["codewith", "prompt", "injection", "policy", "freeze"]
+    },
+    {
+      name: "desktopnotify",
+      displayName: "Desktop Notify",
+      description: "Sends native desktop notifications via osascript (macOS) or notify-send (Linux)",
+      version: "0.1.0",
+      category: "Notifications",
+      event: "Stop",
+      matcher: "",
+      tags: ["notification", "desktop", "macos", "linux", "native"]
+    },
+    {
+      name: "slacknotify",
+      displayName: "Slack Notify",
+      description: "Sends Slack webhook notifications when Claude finishes",
+      version: "0.1.0",
+      category: "Notifications",
+      event: "Stop",
+      matcher: "",
+      tags: ["notification", "slack", "webhook", "team"]
+    },
+    {
+      name: "soundnotify",
+      displayName: "Sound Notify",
+      description: "Plays a system sound when Claude finishes (macOS/Linux)",
+      version: "0.1.0",
+      category: "Notifications",
+      event: "Stop",
+      matcher: "",
+      tags: ["notification", "sound", "audio", "alert"]
+    },
+    {
+      name: "sessionlog",
+      displayName: "Session Log",
+      description: `Logs every tool call to SQLite (${getReportedDbPath()})`,
+      version: "0.1.0",
+      category: "Observability",
+      event: "PostToolUse",
+      matcher: "",
+      tags: ["logging", "audit", "session", "history", "jsonl"]
+    },
+    {
+      name: "commandlog",
+      displayName: "Command Log",
+      description: `Logs every Bash command to SQLite (${getReportedDbPath()})`,
+      version: "0.1.0",
+      category: "Observability",
+      event: "PostToolUse",
+      matcher: "Bash",
+      tags: ["logging", "bash", "commands", "audit"]
+    },
+    {
+      name: "costwatch",
+      displayName: "Cost Watch",
+      description: "Estimates session token usage, persists cost history to SQLite, and warns on budget overrun",
+      version: "0.1.0",
+      category: "Observability",
+      event: "Stop",
+      matcher: "",
+      tags: ["cost", "tokens", "budget", "usage", "monitoring"]
+    },
+    {
+      name: "errornotify",
+      displayName: "Error Notify",
+      description: `Detects tool failures and logs errors to SQLite (${getReportedDbPath()})`,
+      version: "0.1.0",
+      category: "Observability",
+      event: "PostToolUse",
+      matcher: "",
+      tags: ["errors", "failures", "logging", "debugging"]
+    },
+    {
+      name: "spiral-detector",
+      displayName: "Spiral Detector",
+      description: "Interrupts sessions after five consecutive identical command failures",
+      version: "0.1.0",
+      category: "Observability",
+      event: "PostToolUse",
+      matcher: "",
+      tags: ["spiral", "failures", "retries", "safety", "interrupt"]
+    },
+    {
+      name: "stylescheck",
+      displayName: "Styles Check",
+      description: "Blocks frontend files with design anti-patterns: hardcoded colors, magic font sizes, inline styles",
+      version: "0.1.0",
+      category: "Code Quality",
+      event: "PreToolUse",
+      matcher: "Write|Edit",
+      tags: ["design", "styles", "frontend", "css", "tailwind", "design-system", "anti-patterns"]
+    },
+    {
+      name: "taskgate",
+      displayName: "Task Gate",
+      description: "Validates task completion criteria before allowing tasks to be marked done",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "PostToolUse",
+      matcher: "",
+      tags: ["tasks", "completion", "gate", "quality", "agent-teams"]
+    },
+    {
+      name: "session-start",
+      displayName: "Session Start",
+      description: "Codewith SessionStart digest for blockers, announcements, identity registration, and heartbeat context",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "SessionStart",
+      matcher: "",
+      tags: ["codewith", "session", "context", "conversations", "heartbeat"]
+    },
+    {
+      name: "stop-sync",
+      displayName: "Stop Sync",
+      description: "Codewith Stop turn-end heartbeat and best-effort task evidence helper",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "Stop",
+      matcher: "",
+      tags: ["codewith", "stop", "heartbeat", "todos", "turn-end"]
+    },
+    {
+      name: "typecheck-gate",
+      displayName: "Typecheck Gate",
+      description: "Runs TypeScript type checking on Stop and blocks if type errors are found",
+      version: "0.1.0",
+      category: "Code Quality",
+      event: "Stop",
+      matcher: "",
+      tags: ["typescript", "typecheck", "types", "quality", "gate"]
+    },
+    {
+      name: "affected-tests",
+      displayName: "Affected Tests",
+      description: "Maps edited files to their test files and runs them automatically after edits",
+      version: "0.1.0",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["tests", "test-runner", "affected", "quality"]
+    },
+    {
+      name: "conflict-detect",
+      displayName: "Conflict Detect",
+      description: "Blocks edits on files with unresolved git merge conflict markers",
+      version: "0.1.0",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "Edit|Write",
+      tags: ["git", "conflicts", "merge", "safety"]
+    },
+    {
+      name: "failure-to-task",
+      displayName: "Failure to Task",
+      description: "Creates a todo task automatically when test or build commands fail",
+      version: "0.1.0",
+      category: "Workflow Automation",
+      event: "PostToolUse",
+      matcher: "Bash",
+      tags: ["failures", "tasks", "tests", "build", "automation"]
+    },
+    {
+      name: "filelock",
+      displayName: "File Lock",
+      description: "Auto-checks file locks before edits to prevent multi-agent conflicts",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "PreToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["locking", "coordination", "multi-agent", "conflict"]
+    },
+    {
+      name: "announce-start",
+      displayName: "Announce Start",
+      description: "On SessionStart, auto-registers agent, reads messages, and announces to space",
+      version: "0.2.0",
+      category: "Agent Teams",
+      event: "SessionStart",
+      matcher: "",
+      tags: ["announcement", "start", "register", "messages", "agent-teams"]
+    },
+    {
+      name: "announce-stop",
+      displayName: "Announce Stop",
+      description: "On Stop, releases file locks, posts session summary, and updates task statuses",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "Stop",
+      matcher: "",
+      tags: ["announcement", "stop", "locks", "summary", "agent-teams"]
+    },
+    {
+      name: "dm-inject",
+      displayName: "DM Inject",
+      description: "Injects unread direct messages into agent context on Notification events",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "Notification",
+      matcher: "",
+      tags: ["messages", "dm", "context", "inject", "agent-teams"]
+    },
+    {
+      name: "fleet-catchup",
+      displayName: "Fleet Catchup",
+      description: "On SessionStart, injects unread blockers, channel notifications, and the announcements digest into context (deterministic CLI reads, fail-open)",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "SessionStart",
+      matcher: "",
+      tags: ["fleet", "catchup", "blockers", "announcements", "context", "agent-teams"]
+    },
+    {
+      name: "agent-rules-version-check",
+      displayName: "Agent Rules Version Check",
+      description: "On SessionStart, compares the rendered hasna:agent-operating-rules sentinel version against configs state and warns on mismatch",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "SessionStart",
+      matcher: "",
+      tags: ["fleet", "rules", "version", "sentinel", "configs", "drift", "agent-teams"]
+    },
+    {
+      name: "fleet-blockers-gate",
+      displayName: "Fleet Blockers Gate",
+      description: "Before tool calls, blocks mutating tools while an unread [FREEZE] blocker is active (TTL-cached conversations check, fail-open <500ms)",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "PreToolUse",
+      matcher: "",
+      tags: ["fleet", "freeze", "blockers", "gate", "safety", "agent-teams"]
+    }
+  ];
+});
+
+// src/config.ts
+import { join as join2 } from "path";
+function getHooksDataDir() {
+  return getEffectiveDataRoot();
+}
+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");
+}
+var init_config = __esm(() => {
+  init_app_home();
+});
+
+// src/lib/semver.ts
+var NUMERIC_ID = "(0|[1-9]\\d{0,15})", ALNUM_ID = "\\d*[A-Za-z-][0-9A-Za-z-]*", SEMVER_PATTERN;
+var init_semver = __esm(() => {
+  SEMVER_PATTERN = new RegExp(`^${NUMERIC_ID}\\.${NUMERIC_ID}\\.${NUMERIC_ID}` + `(?:-(?:${NUMERIC_ID}|${ALNUM_ID})(?:\\.(?:${NUMERIC_ID}|${ALNUM_ID}))*)?` + `(?:\\+[0-9A-Za-z.-]+)?$`);
+});
+
+// src/lib/manifest.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync } from "fs";
+import { basename, dirname, isAbsolute, join as join3, normalize, resolve as resolve2, sep } from "path";
+import { z } from "zod";
+function parseManifest(json) {
+  const parsed = JSON.parse(json);
+  return manifestSchema.parse(parsed);
+}
+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 = resolve2(target);
+  const rootLexical = resolve2(root);
+  if (!isWithin(lexical, rootLexical)) {
+    throw new ScriptContainmentError(target, root, raw);
+  }
+  return lexical;
+}
+function realpathNearest(path) {
+  const tail = [];
+  let cur = path;
+  while (!existsSync2(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 isInlineScript(manifest) {
+  return manifest.script_kind === "inline" || manifest.script_kind === undefined && manifest.script.includes(`
+`);
+}
+function scriptRelFor(manifest) {
+  if (isInlineScript(manifest)) {
+    const ext = manifest.script.trim().startsWith("#!") ? ".sh" : ".ts";
+    return `script${ext}`;
+  }
+  const rel = normalize(manifest.script);
+  if (isAbsolute(rel)) {
+    throw new Error(`manifest script must be relative or inline, got absolute path '${manifest.script}'`);
+  }
+  return rel;
+}
+function resolveScript(manifest, manifestDir) {
+  if (isInlineScript(manifest))
+    return { path: scriptRelFor(manifest), content: manifest.script };
+  const rel = scriptRelFor(manifest);
+  const resolved = assertContained(join3(manifestDir, rel), manifestDir, manifest.script);
+  if (!existsSync2(resolved)) {
+    throw new Error(`manifest script file not found: ${resolved}`);
+  }
+  return { path: rel, content: readFileSync(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 (!existsSync2(manifestPath))
+    return;
+  try {
+    const manifest = parseManifest(readFileSync(manifestPath, "utf-8"));
+    const script = resolveScript(manifest, dir);
+    const scriptIsInline = isInlineScript(manifest);
+    return { manifest, scriptPath: join3(dir, script.path), scriptContent: script.content, scriptIsInline };
+  } catch (err) {
+    if (err instanceof ScriptContainmentError)
+      throw err;
+    return;
+  }
+}
+var HOOK_NAME_RE, manifestSchema, ScriptContainmentError;
+var init_manifest = __esm(() => {
+  init_config();
+  init_semver();
+  HOOK_NAME_RE = /^[\w-]+$/;
+  manifestSchema = z.object({
+    name: z.string().regex(HOOK_NAME_RE, "hook name must be /^[\\w-]+$/"),
+    version: z.string().regex(SEMVER_PATTERN, "version must be full semver (e.g. 1.2.3 or 1.2.3-beta.1)"),
+    description: z.string().optional(),
+    events: z.array(z.string()).min(1, "at least one event is required"),
+    script: z.string().min(1, "script must name a relative path or inline content"),
+    script_kind: z.enum(["inline", "file"]).optional(),
+    args: z.array(z.string()).optional(),
+    timeout_ms: z.number().int().positive().optional(),
+    env: z.record(z.string(), z.string()).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,
+  resolveBundledHooksDir: () => resolveBundledHooksDir
+});
+import { dirname as dirname2, join as join4 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { fileURLToPath } from "url";
+function resolveBundledHooksDir(moduleDir = dirname2(fileURLToPath(import.meta.url))) {
+  const sourceLayout = join4(moduleDir, "..", "..", "hooks");
+  if (existsSync3(join4(sourceLayout, "hook-gitguard")))
+    return sourceLayout;
+  return join4(moduleDir, "..", "hooks");
+}
+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 = resolveBundledHooksDir();
+  const direct = join4(bundledBase, short);
+  if (existsSync3(direct))
+    return direct;
+  const prefixed = join4(bundledBase, `hook-${short}`);
+  return existsSync3(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 existsSync3(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,
+      timeoutMs: custom.manifest.timeout_ms ?? null
+    };
+  }
+  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,
+    timeoutMs: null
+  };
+}
+var init_resolve = __esm(() => {
+  init_registry();
+  init_manifest();
+});
+
+// src/db/schema.ts
+var CREATE_HOOK_EVENTS_TABLE = `
+  CREATE TABLE IF NOT EXISTS hook_events (
+    id           TEXT PRIMARY KEY,
+    timestamp    TEXT NOT NULL,
+    session_id   TEXT NOT NULL,
+    hook_name    TEXT NOT NULL,
+    event_type   TEXT NOT NULL CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit', 'SubagentStart')),
+    tool_name    TEXT,
+    tool_input   TEXT,
+    result       TEXT CHECK (result IN ('continue', 'block', NULL)),
+    error        TEXT,
+    duration_ms  INTEGER,
+    project_dir  TEXT,
+    metadata     TEXT
+  )
+`, CREATE_INDEXES;
+var init_schema = __esm(() => {
+  CREATE_INDEXES = [
+    `CREATE INDEX IF NOT EXISTS idx_hook_events_timestamp  ON hook_events (timestamp)`,
+    `CREATE INDEX IF NOT EXISTS idx_hook_events_session_id ON hook_events (session_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_hook_events_hook_name  ON hook_events (hook_name)`,
+    `CREATE INDEX IF NOT EXISTS idx_hook_events_event_type ON hook_events (event_type)`,
+    `CREATE INDEX IF NOT EXISTS idx_hook_events_errors     ON hook_events (timestamp) WHERE error IS NOT NULL`
+  ];
+});
+
+// src/db/migrations/001_initial.ts
+function up(db) {
+  db.exec(CREATE_HOOK_EVENTS_TABLE);
+  for (const idx of CREATE_INDEXES) {
+    db.exec(idx);
+  }
+}
+var init_001_initial = __esm(() => {
+  init_schema();
+});
+
+// src/db/migrations/002_session_events.ts
+function up2(db) {
+  const row = db.query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?").get("hook_events");
+  if (!row?.sql)
+    return;
+  if (row.sql.includes("SessionStart"))
+    return;
+  db.exec("BEGIN");
+  try {
+    db.exec("ALTER TABLE hook_events RENAME TO hook_events_old");
+    db.exec(CREATE_HOOK_EVENTS_TABLE);
+    db.exec(`INSERT INTO hook_events
+         (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata)
+       SELECT id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata
+       FROM hook_events_old`);
+    db.exec("DROP TABLE hook_events_old");
+    for (const idx of CREATE_INDEXES) {
+      db.exec(idx);
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+var init_002_session_events = __esm(() => {
+  init_schema();
+});
+
+// src/db/migrations/003_user_prompt_submit_event.ts
+function up3(db) {
+  const row = db.query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?").get("hook_events");
+  if (!row?.sql)
+    return;
+  if (row.sql.includes("UserPromptSubmit"))
+    return;
+  db.exec("BEGIN");
+  try {
+    db.exec("ALTER TABLE hook_events RENAME TO hook_events_old");
+    db.exec(CREATE_HOOK_EVENTS_TABLE);
+    db.exec(`INSERT INTO hook_events
+         (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata)
+       SELECT id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata
+       FROM hook_events_old`);
+    db.exec("DROP TABLE hook_events_old");
+    for (const idx of CREATE_INDEXES) {
+      db.exec(idx);
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+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/005_subagent_start_event.ts
+function up5(db) {
+  const row = db.query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?").get("hook_events");
+  if (!row?.sql)
+    return;
+  if (row.sql.includes("SubagentStart"))
+    return;
+  db.exec("BEGIN");
+  try {
+    db.exec("ALTER TABLE hook_events RENAME TO hook_events_old");
+    db.exec(CREATE_HOOK_EVENTS_TABLE);
+    db.exec(`INSERT INTO hook_events
+         (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata)
+       SELECT id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata
+       FROM hook_events_old`);
+    db.exec("DROP TABLE hook_events_old");
+    for (const idx of CREATE_INDEXES) {
+      db.exec(idx);
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+var init_005_subagent_start_event = __esm(() => {
+  init_schema();
+});
+
+// src/db/migrations/index.ts
+function ensureMigrationsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version    TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    )
+  `);
+}
+function getApplied(db) {
+  const rows = db.query("SELECT version FROM schema_migrations").all();
+  return new Set(rows.map((r) => r.version));
+}
+function runMigrations(db) {
+  ensureMigrationsTable(db);
+  const applied = getApplied(db);
+  for (const migration of MIGRATIONS) {
+    if (applied.has(migration.version))
+      continue;
+    migration.up(db);
+    db.run("INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)", [
+      migration.version,
+      new Date().toISOString()
+    ]);
+  }
+}
+var MIGRATIONS;
+var init_migrations = __esm(() => {
+  init_001_initial();
+  init_002_session_events();
+  init_003_user_prompt_submit_event();
+  init_004_hooks_table();
+  init_005_subagent_start_event();
+  MIGRATIONS = [
+    { version: "001_initial", up },
+    { version: "002_session_events", up: up2 },
+    { version: "003_user_prompt_submit_event", up: up3 },
+    { version: "004_hooks_table", up: up4 },
+    { version: "005_subagent_start_event", up: up5 }
+  ];
+});
+
+// src/db/legacy-import.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir2 } from "os";
+function ensureMetaTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+}
+function isAlreadyDone(db) {
+  ensureMetaTable(db);
+  const row = db.query("SELECT value FROM _meta WHERE key = ?").get(META_KEY);
+  return row?.value === "1";
+}
+function markDone(db) {
+  db.run("INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)", [META_KEY, "1"]);
+}
+function nanoid() {
+  return crypto.randomUUID().replace(/-/g, "").slice(0, 21);
+}
+function importJsonlFile(db, filePath) {
+  let count = 0;
+  try {
+    const lines = readFileSync2(filePath, "utf-8").split(`
+`).filter(Boolean);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        db.run(`INSERT OR IGNORE INTO hook_events
+            (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, project_dir)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+          nanoid(),
+          entry.timestamp ?? new Date().toISOString(),
+          entry.session_id ?? "legacy",
+          "sessionlog",
+          "PostToolUse",
+          entry.tool_name ?? null,
+          entry.tool_input ? String(entry.tool_input).slice(0, 500) : null,
+          null
+        ]);
+        count++;
+      } catch {}
+    }
+  } catch {}
+  return count;
+}
+function importErrorsLog(db, filePath) {
+  let count = 0;
+  try {
+    const lines = readFileSync2(filePath, "utf-8").split(`
+`).filter(Boolean);
+    const linePattern = /^\[(.+?)\]\s+(?:\[session:(\S+)\]\s+)?(.+?)\s+\u2014\s+(.+)$/;
+    for (const line of lines) {
+      try {
+        const m = line.match(linePattern);
+        if (!m)
+          continue;
+        const [, timestamp, sessionPrefix, , errorMsg] = m;
+        db.run(`INSERT OR IGNORE INTO hook_events
+            (id, timestamp, session_id, hook_name, event_type, error)
+           VALUES (?, ?, ?, ?, ?, ?)`, [
+          nanoid(),
+          timestamp,
+          sessionPrefix ? `legacy-${sessionPrefix}` : "legacy",
+          "errornotify",
+          "PostToolUse",
+          errorMsg.slice(0, 500)
+        ]);
+        count++;
+      } catch {}
+    }
+  } catch {}
+  return count;
+}
+function runLegacyImport(db, homeDir = homedir2()) {
+  try {
+    if (isAlreadyDone(db))
+      return;
+    let total = 0;
+    const claudeProjectsDir = join5(homeDir, ".claude", "projects");
+    if (existsSync4(claudeProjectsDir)) {
+      try {
+        const projectDirs = readdirSync2(claudeProjectsDir);
+        for (const dir of projectDirs) {
+          const projectDir = join5(claudeProjectsDir, dir);
+          try {
+            const files = readdirSync2(projectDir);
+            for (const file of files) {
+              if (file.match(/^session-log-\d{4}-\d{2}-\d{2}\.jsonl$/)) {
+                total += importJsonlFile(db, join5(projectDir, file));
+              }
+              if (file === "errors.log") {
+                total += importErrorsLog(db, join5(projectDir, file));
+              }
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+    markDone(db);
+    if (total > 0) {
+      process.stderr.write(`[hooks] Imported ${total} legacy log entries into SQLite.
+`);
+    }
+  } catch (err) {
+    process.stderr.write(`[hooks] Legacy import failed (non-fatal): ${err}
+`);
+  }
+}
+var META_KEY = "legacy_import_done";
+var init_legacy_import = () => {};
+
+// src/db/retention.ts
+function runRetention(db, days) {
+  const envDays = parseInt(process.env.HOOKS_RETENTION_DAYS ?? "30");
+  const retentionDays = days ?? (isNaN(envDays) || envDays <= 0 ? 30 : envDays);
+  const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000).toISOString();
+  try {
+    db.run("DELETE FROM hook_events WHERE timestamp < ?", [cutoff]);
+    const changes = db.query("SELECT changes() as changes").get()?.changes ?? 0;
+    return changes;
+  } catch {
+    return 0;
+  }
+}
+
+// src/db/index.ts
+var exports_db = {};
+__export(exports_db, {
+  refuseLocalStore: () => refuseLocalStore,
+  localStoreRefusalMessage: () => localStoreRefusalMessage,
+  isLocalStoreRefused: () => isLocalStoreRefused,
+  getDbPath: () => getDbPath,
+  getDb: () => getDb,
+  createTestDb: () => createTestDb,
+  closeDb: () => closeDb,
+  allowLocalStore: () => allowLocalStore
+});
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, cpSync } from "fs";
+import { join as join6 } from "path";
+function refuseLocalStore(message) {
+  localStoreRefusal = message;
+}
+function allowLocalStore() {
+  localStoreRefusal = null;
+}
+function isLocalStoreRefused() {
+  return localStoreRefusal !== null;
+}
+function localStoreRefusalMessage() {
+  return localStoreRefusal;
+}
+function resolveDataDir() {
+  const effective = getEffectiveDataRoot();
+  const oldDir = join6(getHomeDir(), ".hooks");
+  if (!existsSync5(effective) && existsSync5(oldDir)) {
+    mkdirSync2(effective, { recursive: true });
+    cpSync(oldDir, effective, { recursive: true });
+  }
+  return effective;
+}
+function getDbPath() {
+  const explicitDb = process.env.HASNA_HOOKS_DB_PATH ?? process.env.HOOKS_DB_PATH;
+  if (explicitDb)
+    return explicitDb;
+  const dataDir2 = resolveDataDir();
+  return join6(dataDir2, "hooks.db");
+}
+function ensureDir(dbPath) {
+  const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+  if (dir && !existsSync5(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
+function getDb() {
+  if (localStoreRefusal !== null)
+    throw new Error(localStoreRefusal);
+  if (instance)
+    return instance;
+  const dbPath = getDbPath();
+  const isNew = dbPath === ":memory:" || !existsSync5(dbPath);
+  ensureDir(dbPath);
+  instance = new Database(dbPath);
+  instance.exec("PRAGMA busy_timeout=5000");
+  instance.exec("PRAGMA journal_mode=WAL");
+  instance.exec("PRAGMA foreign_keys=ON");
+  runMigrations(instance);
+  runRetention(instance);
+  instance.exec(`CREATE TABLE IF NOT EXISTS feedback (
+    id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    message TEXT NOT NULL,
+    email TEXT,
+    category TEXT DEFAULT 'general',
+    version TEXT,
+    machine_id TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  )`);
+  if (isNew) {
+    runLegacyImport(instance);
+  }
+  return instance;
+}
+function closeDb() {
+  if (instance) {
+    instance.close();
+    instance = null;
+  }
+}
+function createTestDb() {
+  const db = new Database(":memory:");
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA foreign_keys=ON");
+  return db;
+}
+var instance = null, localStoreRefusal = null;
+var init_db = __esm(() => {
+  init_app_home();
+  init_migrations();
+  init_legacy_import();
+});
+
+// src/lib/redact.ts
+function redactText(value) {
+  let out = value;
+  for (const pattern of SECRET_SHAPES) {
+    out = out.replace(pattern, REDACTED);
+  }
+  return out;
+}
+function redactValue(value) {
+  if (typeof value === "string")
+    return redactText(value);
+  if (Array.isArray(value))
+    return value.map(redactValue);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      out[key] = SECRET_KEY_NAMES.test(key) ? REDACTED : redactValue(child);
+    }
+    return out;
+  }
+  return value;
+}
+function redactEventPayload(text) {
+  if (text === null || text === undefined)
+    return null;
+  try {
+    const parsed = JSON.parse(text);
+    return redactText(JSON.stringify(redactValue(parsed)));
+  } catch {
+    return redactText(text);
+  }
+}
+function projectEventRowForRead(row) {
+  const out = { ...row };
+  for (const field of ["tool_input", "error", "metadata"]) {
+    const value = out[field];
+    if (typeof value === "string")
+      out[field] = redactEventPayload(value);
+    else if (value === null)
+      out[field] = null;
+  }
+  return out;
+}
+var REDACTED = "[REDACTED]", SECRET_KEY_NAMES, SECRET_SHAPES;
+var init_redact = __esm(() => {
+  SECRET_KEY_NAMES = /^(key|keys|token|tokens|secret|secrets|password|passwd|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret|refresh[_-]?token|authorization|auth|cookie|credential|credentials|session[_-]?id|otp|mfa[_-]?code|two[_-]?fa[_-]?code|verification[_-]?code|database_url|db_url|connection_string|dsn)$/i;
+  SECRET_SHAPES = [
+    /\bsk-(?:proj|svc|ant)-[A-Za-z0-9_-]{10,}/g,
+    /\bsk-[A-Za-z0-9]{16,}/g,
+    /\btpe_[A-Za-z0-9]{8,}/g,
+    /\b(?:rk|sk)_(?:live|test)_[A-Za-z0-9]{8,}/g,
+    /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+    /gh[pousr]_[A-Za-z0-9]{20,}/g,
+    /xox[baprs]-[A-Za-z0-9-]{20,}/g,
+    /AKIA[0-9A-Z]{16}/g,
+    /ASIA[0-9A-Z]{16}/g,
+    /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+    /-----BEGIN [A-Z0-9 ]*PRIVAT[E] KEY-----/g,
+    /-----BEGIN OPENSSH PRIVAT[E] KEY-----/g,
+    /\bBearer\s+[A-Za-z0-9._~+/=-]{6,}/g,
+    /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]+:[^/\s@]+@/gi,
+    /\b(?:password|passwd|pwd|token|api[_-]?key|secret|access[_-]?key|client[_-]?secret|authorization|auth|credential|database_url|db_url|connection_string|dsn)\s*[:=]\s*(?:"[^"]*"|'[^']*'|[^\s,;"']{6,})/gi
+  ];
+});
+
+// ../../node_modules/.bun/@hasna+contracts@1.0.2+e0db24ae03127387/node_modules/@hasna/contracts/dist/client/transport.js
+import { isIP } from "net";
+import { spawnSync } from "child_process";
+import { closeSync, fstatSync, openSync, readFileSync as readFileSync6 } from "fs";
+import { O_NOFOLLOW, O_NONBLOCK, O_RDONLY } from "constants";
+import { createRequire } from "module";
+import { hostname as osHostname } from "os";
+import { isAbsolute as isAbsolute2, join as join9 } from "path";
+function envToken(name) {
+  return name.toUpperCase().replace(/-/g, "_");
+}
+function clientTransportEnvKeys(name) {
+  const envSegment = envToken(name);
+  return {
+    apiUrlKeys: [`HASNA_${envSegment}_API_URL`, `${envSegment}_API_URL`],
+    apiKeyKeys: [`HASNA_${envSegment}_API_KEY`, `${envSegment}_API_KEY`]
+  };
+}
+function credentialOverrideEnvKey(name) {
+  return `HASNA_${envToken(name)}_API_KEY_OVERRIDE`;
+}
+function credentialPointerEnvKey(name) {
+  return `HASNA_${envToken(name)}_API_KEY_REF`;
+}
+function homeDir(env) {
+  const home = env.HOME?.trim();
+  return home ? home : null;
+}
+function absoluteOverride(env, key) {
+  const value = env[key]?.trim();
+  return value && isAbsolute2(value) ? value : null;
+}
+function hasnaHomeDir(env) {
+  const override = absoluteOverride(env, HASNA_HOME_ENV_KEY);
+  if (override)
+    return override;
+  const home = homeDir(env);
+  return home ? join9(home, HASNA_HOME_DIR) : null;
+}
+function appConfigDir(name, env) {
+  const configRoot = absoluteOverride(env, HASNA_CONFIG_HOME_ENV_KEY);
+  if (configRoot)
+    return join9(configRoot, name);
+  const root = hasnaHomeDir(env);
+  return root ? join9(root, name, CONFIG_SUBDIR) : null;
+}
+function credentialDiskSourceList(name, env, profile = null) {
+  if (!SAFE_APP_SLUG.test(name))
+    return [];
+  const directory = appConfigDir(name, env);
+  if (!directory)
+    return [];
+  const file = profile ? `${CREDENTIALS_FILE}-${profile}` : CREDENTIALS_FILE;
+  return [{ path: join9(directory, file), tier: "disk" }];
+}
+function credentialDiskSources(name, env) {
+  return credentialDiskSourceList(name, env, null).map((s) => s.path);
+}
+function profileDiskSources(name, env, profile) {
+  return credentialDiskSourceList(name, env, profile).map((s) => s.path);
+}
+function parseEnvFile(text) {
+  const values = new Map;
+  const unusable = new Set;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line.length === 0 || line.startsWith("#"))
+      continue;
+    const withoutExport = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
+    const equals = withoutExport.indexOf("=");
+    if (equals <= 0)
+      continue;
+    const key = withoutExport.slice(0, equals).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+      continue;
+    let value = withoutExport.slice(equals + 1).trim();
+    const quote = value[0];
+    if (quote === '"' || quote === "'") {
+      if (value.length < 2 || !value.endsWith(quote)) {
+        unusable.add(key);
+        continue;
+      }
+      value = value.slice(1, -1);
+    }
+    if (value.trim().length === 0) {
+      unusable.add(key);
+      continue;
+    }
+    if (values.has(key) && values.get(key) !== value)
+      unusable.add(key);
+    values.set(key, value);
+  }
+  return { values, unusable };
+}
+function configFileModeAllowed(mode) {
+  const permissions = mode & 4095;
+  return permissions === 256 || permissions === 384;
+}
+function configFileReadsCoherent(before, after) {
+  return before.dev === after.dev && before.ino === after.ino && before.size === after.size && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs;
+}
+function readAppConfigFile(path) {
+  const unsafe = (reason) => {
+    throw new CredentialFileUnsafeError(path, reason);
+  };
+  let fd = -1;
+  try {
+    fd = openSync(path, O_RDONLY | O_NOFOLLOW | O_NONBLOCK);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return null;
+    if (code === "ELOOP")
+      unsafe("the path is a symlink");
+    unsafe(`the path could not be opened (${code ?? "unknown error"})`);
+  }
+  try {
+    const before = fstatSync(fd);
+    if (!before.isFile())
+      unsafe("the path is not a regular file");
+    if (!configFileModeAllowed(before.mode)) {
+      unsafe(`permission mode ${(before.mode & 4095).toString(8).padStart(4, "0")} is not owner-only 0400 or 0600`);
+    }
+    const uid = process.getuid?.() ?? process.geteuid?.();
+    if (uid !== undefined && before.uid !== uid)
+      unsafe("the file is not owned by the current user");
+    if (before.size > MAX_CREDENTIAL_FILE_BYTES)
+      unsafe("the file exceeds the size limit");
+    const bytes = readFileSync6(fd);
+    const after = fstatSync(fd);
+    if (!configFileReadsCoherent(before, after)) {
+      unsafe("the file changed while being read");
+    }
+    return parseEnvFile(bytes.toString("utf8"));
+  } finally {
+    if (fd !== -1)
+      closeSync(fd);
+  }
+}
+function readCredentialFile(path, apiKeyKeys) {
+  const parsed = readAppConfigFile(path);
+  if (!parsed)
+    return null;
+  for (const key of apiKeyKeys) {
+    if (parsed.unusable.has(key)) {
+      throw new CredentialFileUnsafeError(path, `${key} is declared but blank or malformed`);
+    }
+  }
+  const values = apiKeyKeys.map((key) => parsed.values.get(key)?.trim()).filter((value) => Boolean(value));
+  if (new Set(values).size > 1) {
+    throw new CredentialFileUnsafeError(path, "credential aliases disagree");
+  }
+  return values[0] ?? null;
+}
+function appConfigDiskValue(name, env, keys) {
+  const wanted = keys.filter((key) => !CREDENTIAL_SHAPED_KEY.test(key));
+  if (wanted.length === 0)
+    return null;
+  for (const path of credentialDiskSources(name, env)) {
+    const parsed = readAppConfigFile(path);
+    if (!parsed)
+      continue;
+    if (wanted.some((key) => parsed.unusable.has(key))) {
+      return { key: wanted.find((key) => parsed.unusable.has(key)), value: "", path, unusable: true };
+    }
+    const values = wanted.map((key) => parsed.values.get(key)?.trim()).filter((value) => Boolean(value));
+    if (new Set(values).size > 1)
+      throw new CredentialFileUnsafeError(path, "configuration aliases disagree");
+    for (const key of wanted) {
+      if (parsed.unusable.has(key))
+        return { key, value: "", path, unusable: true };
+      const value = parsed.values.get(key)?.trim();
+      if (value)
+        return { key, value, path };
+    }
+  }
+  return null;
+}
+function assertUsableCredential(appName, source, value) {
+  if (VAULT_POINTER_SHAPE.test(value)) {
+    throw new CredentialResolutionError(appName, `The credential from ${source} looks like a secrets-vault pointer (a path-shaped reference like ` + `'namespace/app/live/api_key'). A vault path is NEVER accepted as a literal API key. ` + `Use ${credentialPointerEnvKey(appName)} to resolve the key through the vault, or provide the actual key value.`, [source]);
+  }
+  if (!ILLEGAL_IN_HEADER_VALUE.test(value))
+    return;
+  throw new CredentialResolutionError(appName, `The credential from ${source} contains characters that cannot be sent in an HTTP header ` + `(a control character or non-ASCII byte). A file written with CR-only line endings is the usual ` + `cause. Rewrite that credential file with one LF-terminated KEY=value line. ` + `The value is not shown here, and is deliberately never logged.`, [source]);
+}
+function sealCredential(fields) {
+  const { apiKey } = fields;
+  const visible = {
+    tier: fields.tier,
+    source: fields.source,
+    deliberate: fields.deliberate,
+    diskCandidates: Object.freeze([...fields.diskCandidates]),
+    warning: fields.warning
+  };
+  const sealed = { ...visible };
+  Object.defineProperty(sealed, "apiKey", {
+    value: apiKey,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  if (fields.pointerVaultKey !== undefined) {
+    Object.defineProperty(sealed, "pointerVaultKey", {
+      value: fields.pointerVaultKey,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+  Object.defineProperty(sealed, INSPECT_CUSTOM, {
+    value: () => ({ ...visible, apiKey: "[redacted]" }),
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  Object.defineProperty(sealed, CREDENTIAL_SEAL, {
+    value: true,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  return Object.freeze(sealed);
+}
+function firstEnvValue(env, keys) {
+  for (const key of keys) {
+    if (!Object.prototype.hasOwnProperty.call(env, key))
+      continue;
+    const value = env[key]?.trim();
+    if (value)
+      return { key, value };
+  }
+  return null;
+}
+function isAmbientEnvironment(env) {
+  return env === process.env || env[AMBIENT_ENVIRONMENT] === true;
+}
+function defaultKeychainRunner(argv) {
+  const result = spawnSync(KEYCHAIN_SECURITY_BIN, [...argv], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: KEYCHAIN_SPAWN_TIMEOUT_MS
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.error ? result.error.message : result.stderr ?? ""
+  };
+}
+function keychainTierEnabled(env, options) {
+  if ((options.platform ?? process.platform) !== "darwin")
+    return false;
+  if (options.enabled !== undefined)
+    return options.enabled;
+  return options.run !== undefined || isAmbientEnvironment(env);
+}
+function keychainAccount(env, options) {
+  const station = env[KEYCHAIN_STATION_ENV_KEY]?.trim();
+  if (station)
+    return station;
+  const host = (options.hostname ?? osHostname)().split(".")[0]?.trim() ?? "";
+  if (host)
+    return host;
+  const user = env.USER?.trim();
+  return user || null;
+}
+function keychainFailureHint(text) {
+  const line = text.split(/\r?\n/).find((entry) => entry.trim().length > 0)?.trim() ?? "";
+  const clean = line.replace(/[\u0000-\u001f\u007f]/g, "").slice(0, 200);
+  return clean ? `: ${clean}` : "";
+}
+function readKeychainItem(name, env, kind, options) {
+  if (!SAFE_APP_SLUG.test(name) || !keychainTierEnabled(env, options))
+    return null;
+  const account = keychainAccount(env, options);
+  if (!account)
+    return null;
+  const service = `${KEYCHAIN_SERVICE_PREFIX}.${name}.${kind}`;
+  const source = `keychain:${service}@${account}`;
+  const run = options.run ?? defaultKeychainRunner;
+  let result;
+  try {
+    result = run(["find-generic-password", "-a", account, "-s", service, "-w"]);
+  } catch (error) {
+    const reason = keychainFailureHint(error instanceof Error ? error.message : String(error));
+    throw new CredentialResolutionError(name, `The Keychain lookup for ${source} could not run${reason}. A Keychain failure is never resolved ` + `around: fix the keychain, or delete the item to fall through to the credential on disk.`, [source]);
+  }
+  if (result.status === KEYCHAIN_ITEM_NOT_FOUND_STATUS)
+    return null;
+  if (result.status !== 0) {
+    throw new CredentialResolutionError(name, `The Keychain lookup for ${source} failed (security exited ` + `${result.status ?? "without a status"}${keychainFailureHint(result.stderr)}). A Keychain item that ` + `exists but cannot be read is never resolved around: unlock the keychain, run from a session that ` + `may use it, or delete the item to fall through to the credential on disk.`, [source]);
+  }
+  const value = result.stdout.trim();
+  if (!value) {
+    throw new CredentialResolutionError(name, `${source} exists but holds an empty value; a declared item never falls through to another ` + `identity. Store a value in it or delete the item.`, [source]);
+  }
+  return { value, source };
+}
+function keychainConfigValue(name, env, options = {}) {
+  return readKeychainItem(name, env, "api-url", options);
+}
+function snapshotClientEnvironment(name, env) {
+  const keys = clientTransportEnvKeys(name);
+  const ambient = isAmbientEnvironment(env);
+  const snapshot = Object.create(null);
+  for (const key of [
+    ...keys.apiUrlKeys,
+    ...keys.apiKeyKeys,
+    credentialOverrideEnvKey(name),
+    credentialPointerEnvKey(name),
+    CREDENTIAL_PROFILE_ENV_KEY,
+    "HOME",
+    HASNA_HOME_ENV_KEY,
+    HASNA_CONFIG_HOME_ENV_KEY,
+    KEYCHAIN_STATION_ENV_KEY,
+    "USER"
+  ]) {
+    const descriptor = Object.getOwnPropertyDescriptor(env, key);
+    if (!descriptor)
+      continue;
+    if (!("value" in descriptor)) {
+      throw new CredentialResolutionError(name, `${key} is accessor-backed; client configuration requires own data properties.`, [key]);
+    }
+    if (descriptor.value !== undefined && typeof descriptor.value !== "string") {
+      throw new CredentialResolutionError(name, `${key} must be a string data property.`, [key]);
+    }
+    snapshot[key] = descriptor.value;
+  }
+  if (ambient) {
+    Object.defineProperty(snapshot, AMBIENT_ENVIRONMENT, {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+  return Object.freeze(snapshot);
+}
+function resolveCredential(name, env, options = {}) {
+  env = snapshotClientEnvironment(name, env);
+  const { apiKeyKeys } = clientTransportEnvKeys(name);
+  const diskPaths = credentialDiskSources(name, env);
+  if (options.apiKey !== undefined) {
+    const explicitKey = options.apiKey.trim();
+    if (!explicitKey) {
+      throw new CredentialResolutionError(name, "The explicit apiKey argument is blank; an explicit credential never falls through to another identity.", ["explicit apiKey argument"]);
+    }
+    assertUsableCredential(name, "the explicit apiKey argument", explicitKey);
+    return sealCredential({
+      apiKey: explicitKey,
+      tier: "argument",
+      source: "explicit apiKey argument",
+      deliberate: true,
+      diskCandidates: diskPaths,
+      warning: null
+    });
+  }
+  const overrideKeyName = credentialOverrideEnvKey(name);
+  const overrideRaw = Object.prototype.hasOwnProperty.call(env, overrideKeyName) ? env[overrideKeyName] : undefined;
+  if (overrideRaw !== undefined) {
+    const override = overrideRaw.trim();
+    if (!override) {
+      throw new CredentialResolutionError(name, `${overrideKeyName} is set but empty. It is a deliberate override, so it is not resolved around: ` + `either give it a real key or unset it to fall back to the credential on disk.`, [overrideKeyName]);
+    }
+    assertUsableCredential(name, overrideKeyName, override);
+    return sealCredential({
+      apiKey: override,
+      tier: "override",
+      source: overrideKeyName,
+      deliberate: true,
+      diskCandidates: diskPaths,
+      warning: null
+    });
+  }
+  const pointerKeyName = credentialPointerEnvKey(name);
+  const pointerRaw = Object.prototype.hasOwnProperty.call(env, pointerKeyName) ? env[pointerKeyName] : undefined;
+  if (pointerRaw !== undefined) {
+    const pointer = pointerRaw.trim();
+    if (!pointer) {
+      throw new CredentialResolutionError(name, `${pointerKeyName} is set but empty. It is a deliberate vault pointer, so it is not resolved around: ` + `either give it a vault item key or unset it to fall back to the credential on disk.`, [pointerKeyName]);
+    }
+    if (!VAULT_POINTER_SHAPE.test(pointer)) {
+      throw new CredentialResolutionError(name, `${pointerKeyName} must name a vault ITEM KEY (a path-shaped reference like ` + `'namespace/app/live/api_key'), not a credential value. A pointer that carries a literal is refused.`, [pointerKeyName]);
+    }
+    return sealCredential({
+      apiKey: "",
+      pointerVaultKey: pointer,
+      tier: "pointer",
+      source: pointerKeyName,
+      deliberate: true,
+      diskCandidates: diskPaths,
+      warning: null
+    });
+  }
+  if (options.profile !== undefined && !options.profile.trim()) {
+    throw new CredentialResolutionError(name, "The explicit profile argument is blank; an explicit identity selection never falls through.", ["explicit profile argument"]);
+  }
+  const profileRaw = Object.prototype.hasOwnProperty.call(env, CREDENTIAL_PROFILE_ENV_KEY) ? env[CREDENTIAL_PROFILE_ENV_KEY] : undefined;
+  if (profileRaw !== undefined && !profileRaw.trim()) {
+    throw new CredentialResolutionError(name, `${CREDENTIAL_PROFILE_ENV_KEY} is set but blank.`, [CREDENTIAL_PROFILE_ENV_KEY]);
+  }
+  const profile = options.profile?.trim() || profileRaw?.trim();
+  if (profile) {
+    const profileSource = options.profile?.trim() ? "explicit profile argument" : CREDENTIAL_PROFILE_ENV_KEY;
+    if (!SAFE_PROFILE.test(profile)) {
+      throw new CredentialResolutionError(name, `Profile name from ${profileSource} is not usable in a path. ` + `Use letters, digits, dot, dash, or underscore.`, [profileSource]);
+    }
+    const paths = profileDiskSources(name, env, profile);
+    for (const path of paths) {
+      const value = readCredentialFile(path, apiKeyKeys);
+      if (value) {
+        assertUsableCredential(name, path, value);
+        return sealCredential({
+          apiKey: value,
+          tier: "profile",
+          source: path,
+          deliberate: true,
+          diskCandidates: paths,
+          warning: null
+        });
+      }
+    }
+    throw new CredentialResolutionError(name, `Profile '${profile}' (from ${profileSource}) has no ${apiKeyKeys[0]} for '${name}'. ` + `Looked in: ${paths.join(", ") || "<no HOME in this environment>"}. ` + `A profile names WHICH identity to use, so it is never resolved around \u2014 ` + `create the profile's credential file or unset ${CREDENTIAL_PROFILE_ENV_KEY}.`, paths);
+  }
+  const definedEnvEntries = apiKeyKeys.filter((key) => Object.prototype.hasOwnProperty.call(env, key) && env[key] !== undefined).map((key) => ({ key, value: String(env[key]).trim() }));
+  const blankEnv = definedEnvEntries.find((entry) => entry.value.length === 0);
+  if (blankEnv) {
+    throw new CredentialResolutionError(name, `${blankEnv.key} is set but blank; a declared credential never falls through to another alias or identity.`, [blankEnv.key]);
+  }
+  if (definedEnvEntries.length > 1 && new Set(definedEnvEntries.map((entry) => entry.value)).size > 1) {
+    throw new CredentialResolutionError(name, `${definedEnvEntries.map((entry) => entry.key).join(" and ")} disagree; credential aliases must be identical or only one may be set.`, definedEnvEntries.map((entry) => entry.key));
+  }
+  const envHit = firstEnvValue(env, apiKeyKeys);
+  const keychainHit = readKeychainItem(name, env, "api-key", options.keychain ?? {});
+  if (keychainHit) {
+    assertUsableCredential(name, keychainHit.source, keychainHit.value);
+    const warning = envHit && envHit.value !== keychainHit.value ? `Credential sources disagree for '${name}': ${keychainHit.source} and ${envHit.key} hold ` + `different keys. ${keychainHit.source} wins, because the Keychain is re-read on every call while ` + `an environment variable is a snapshot. Reconcile them \u2014 a rotation that updated only one leaves ` + `the other to fail 401 wherever it is loaded first.` : null;
+    return sealCredential({
+      apiKey: keychainHit.value,
+      tier: "keychain",
+      source: keychainHit.source,
+      deliberate: false,
+      diskCandidates: diskPaths,
+      warning
+    });
+  }
+  const diskSourceList = credentialDiskSourceList(name, env, null);
+  const diskHits = diskSourceList.map((src) => ({ src, value: readCredentialFile(src.path, apiKeyKeys) })).filter((hit) => hit.value !== null);
+  if (diskHits.length > 0) {
+    const winner = diskHits[0];
+    assertUsableCredential(name, winner.src.path, winner.value);
+    const divergentSources = [
+      ...diskHits.slice(1).filter((hit) => hit.value !== winner.value).map((hit) => hit.src.path),
+      ...envHit && envHit.value !== winner.value ? [envHit.key] : []
+    ];
+    const warning = divergentSources.length > 0 ? `Credential sources disagree for '${name}': ${winner.src.path} and ` + `${divergentSources.join(", ")} hold different keys. ${winner.src.path} wins, because a file on ` + `disk is re-read on every call while an environment variable is a snapshot. Reconcile them \u2014 ` + `a rotation that updated only one leaves the other to fail 401 wherever it is loaded first.` : null;
+    return sealCredential({
+      apiKey: winner.value,
+      tier: winner.src.tier,
+      source: winner.src.path,
+      deliberate: false,
+      diskCandidates: diskPaths,
+      warning
+    });
+  }
+  if (envHit) {
+    assertUsableCredential(name, envHit.key, envHit.value);
+    return sealCredential({
+      apiKey: envHit.value,
+      tier: "env",
+      source: envHit.key,
+      deliberate: false,
+      diskCandidates: diskPaths,
+      warning: null
+    });
+  }
+  return null;
+}
+function defaultFleetGatewayBaseUrl(name) {
+  return `${DEFAULT_FLEET_GATEWAY_ORIGIN}/${validateAppSlug(name)}`;
+}
+function isValidDnsDomain(value) {
+  if (value.length === 0 || value.length > 253 || ASCII_CONTROL_PATTERN.test(value) || /[^\x00-\x7f]/.test(value)) {
+    return false;
+  }
+  return value.split(".").every((label) => label.length <= 63 && !label.startsWith("xn--") && DNS_LABEL_PATTERN.test(label));
+}
+function validateAppSlug(name) {
+  if (name.length > 63 || !DNS_LABEL_PATTERN.test(name)) {
+    throw new Error("App name must be one lowercase DNS label.");
+  }
+  return name;
+}
+function rawAuthority(value) {
+  const match = /^[a-z][a-z0-9+.-]*:\/\//i.exec(value);
+  if (!match)
+    throw new Error("API URL must be absolute.");
+  const afterScheme = value.slice(match[0].length);
+  const boundary = afterScheme.search(/[/?#]/);
+  const authority = boundary === -1 ? afterScheme : afterScheme.slice(0, boundary);
+  if (!authority)
+    throw new Error("API URL must include a hostname.");
+  return authority;
+}
+function assertCanonicalPort(port) {
+  if (!/^[0-9]+$/.test(port) || port.length > 1 && port.startsWith("0")) {
+    throw new Error("API URL authority must contain a canonical port between 1 and 65535.");
+  }
+  const numericPort = Number(port);
+  if (!Number.isSafeInteger(numericPort) || numericPort < 1 || numericPort > 65535) {
+    throw new Error("API URL authority must contain a canonical port between 1 and 65535.");
+  }
+}
+function canonicalAuthorityHostname(authority) {
+  let rawHostname;
+  if (authority.startsWith("[")) {
+    const closingBracket = authority.indexOf("]");
+    if (closingBracket === -1) {
+      throw new Error("API URL authority must contain a canonical hostname.");
+    }
+    rawHostname = authority.slice(0, closingBracket + 1);
+    const portSuffix = authority.slice(closingBracket + 1);
+    if (portSuffix) {
+      if (!portSuffix.startsWith(":")) {
+        throw new Error("API URL authority must contain a canonical hostname and port.");
+      }
+      assertCanonicalPort(portSuffix.slice(1));
+    }
+    if (isIP(rawHostname.slice(1, -1)) !== 6) {
+      throw new Error("API URL authority must contain a canonical IPv6 literal.");
+    }
+  } else {
+    const firstColon = authority.indexOf(":");
+    const lastColon = authority.lastIndexOf(":");
+    if (firstColon !== lastColon) {
+      throw new Error("IPv6 API URL authorities must use brackets.");
+    }
+    if (lastColon !== -1) {
+      const port = authority.slice(lastColon + 1);
+      assertCanonicalPort(port);
+      rawHostname = authority.slice(0, lastColon);
+    } else {
+      rawHostname = authority;
+    }
+    const ipVersion = isIP(rawHostname);
+    const numericAddressParts = rawHostname.split(".");
+    const looksLikeNonCanonicalIpv4 = numericAddressParts.every((part) => /^(?:0x[0-9a-f]+|[0-9]+)$/i.test(part));
+    if (ipVersion !== 4 && looksLikeNonCanonicalIpv4 || ipVersion !== 4 && !isValidDnsDomain(rawHostname.toLowerCase())) {
+      throw new Error("API URL authority must contain a canonical ASCII hostname.");
+    }
+  }
+  return rawHostname.toLowerCase();
+}
+function isDeliberateLoopbackHttpAuthority(authority) {
+  return /^(?:localhost|127\.0\.0\.1|\[::1\])(?::[0-9]+)?$/i.test(authority);
+}
+function toV1BaseUrl(apiUrl) {
+  if (ASCII_CONTROL_PATTERN.test(apiUrl)) {
+    throw new Error("API URL must not contain ASCII control characters.");
+  }
+  const input = apiUrl.trim();
+  const authority = rawAuthority(input);
+  if (authority.includes("@") || authority.includes("\\") || authority.includes("%") || /[^\x00-\x7f]/.test(authority)) {
+    throw new Error("API URL authority must be canonical ASCII without credentials.");
+  }
+  const canonicalHostname = canonicalAuthorityHostname(authority);
+  const url = new URL(input);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("API URL must use http or https.");
+  }
+  if (url.username || url.password) {
+    throw new Error("API URL must not include credentials.");
+  }
+  if (!url.hostname || url.hostname.endsWith(".")) {
+    throw new Error("API URL must include a canonical hostname.");
+  }
+  if (url.hostname.toLowerCase() !== canonicalHostname) {
+    throw new Error("API URL authority must not rely on parser hostname normalization.");
+  }
+  if (url.hostname.split(".").some((label) => label.toLowerCase().startsWith("xn--"))) {
+    throw new Error("API URL must not use IDN or punycode hostnames.");
+  }
+  if (url.protocol === "http:" && !isDeliberateLoopbackHttpAuthority(authority)) {
+    throw new Error("API URL may use http only for an exact loopback authority.");
+  }
+  if (url.search || url.hash) {
+    throw new Error("API URL must not include a query string or fragment.");
+  }
+  let path = url.pathname.replace(/\/+$/, "");
+  if (path.endsWith("/v1"))
+    path = path.slice(0, -"/v1".length);
+  url.pathname = `${path}/v1`;
+  return url.toString().replace(/\/+$/, "");
+}
+function resolveClientTransportSnapshot(name, env = process.env, options = {}) {
+  env = snapshotClientEnvironment(name, env);
+  const keys = clientTransportEnvKeys(name);
+  const definedUrlEntries = keys.apiUrlKeys.filter((key) => Object.prototype.hasOwnProperty.call(env, key) && env[key] !== undefined).map((key) => ({ key, raw: String(env[key]) }));
+  const blankUrl = definedUrlEntries.find((entry) => entry.raw.trim().length === 0);
+  if (blankUrl) {
+    throw new ClientTransportConfigurationError(name, `${blankUrl.key} is set but blank; public clients require an explicit HTTPS API URL and never select local storage.`, [blankUrl.key]);
+  }
+  const controlledUrl = definedUrlEntries.find((entry) => ASCII_CONTROL_PATTERN.test(entry.raw));
+  if (controlledUrl) {
+    throw new ClientTransportConfigurationError(name, `${controlledUrl.key} contains ASCII control characters.`, [controlledUrl.key]);
+  }
+  const usableUrlEntries = definedUrlEntries.map((entry) => ({ key: entry.key, value: entry.raw.trim() }));
+  if (usableUrlEntries.length > 1 && new Set(usableUrlEntries.map((entry) => entry.value)).size > 1) {
+    throw new ClientTransportConfigurationError(name, `${usableUrlEntries.map((entry) => entry.key).join(" and ")} disagree; client authority aliases must be identical or only one may be set.`, usableUrlEntries.map((entry) => entry.key));
+  }
+  const envUrlHit = usableUrlEntries[0] ?? null;
+  const keychainUrlHit = keychainConfigValue(name, env, options.credentials?.keychain);
+  const diskConfigUrlHit = appConfigDiskValue(name, env, keys.apiUrlKeys);
+  if (diskConfigUrlHit?.unusable) {
+    throw new ClientTransportConfigurationError(name, `${diskConfigUrlHit.key} in ${diskConfigUrlHit.path} is declared but blank or malformed; public clients require a valid HTTPS service authority.`, [diskConfigUrlHit.path]);
+  }
+  const urlCandidates = [
+    ...envUrlHit ? [envUrlHit] : [],
+    ...keychainUrlHit ? [{ key: keychainUrlHit.source, value: keychainUrlHit.value }] : [],
+    ...diskConfigUrlHit ? [{ key: diskConfigUrlHit.path, value: diskConfigUrlHit.value.trim() }] : []
+  ];
+  const configuredUrl = urlCandidates[0] ?? null;
+  const divergentUrls = urlCandidates.filter((candidate) => candidate.value !== configuredUrl?.value);
+  if (configuredUrl && divergentUrls.length > 0) {
+    throw new ClientTransportConfigurationError(name, `${configuredUrl.key} and ${divergentUrls.map((candidate) => candidate.key).join(" and ")} select different service authorities; refusing to send a credential written for one authority to the other.`, urlCandidates.map((candidate) => candidate.key));
+  }
+  const warnings = [];
+  if (configuredUrl && !envUrlHit) {
+    warnings.push(`No ${keys.apiUrlKeys[0]} in the environment; the server URL in ${configuredUrl.key} was used, so this client connects to the server. ` + `Keep that entry aligned with the intended service authority.`);
+  }
+  const credential = resolveCredential(name, env, options.credentials);
+  if (!credential) {
+    const diskHint = credentialDiskSourcesForMessage(name, env);
+    const lead = configuredUrl ? `${configuredUrl.key} selects the HTTP server for '${name}', but no API key could be resolved` : `${keys.apiUrlKeys[0]} is not set and no API key could be resolved for '${name}'; a credential is required before the default fleet gateway authority applies`;
+    warnings.push(`${lead}; refusing to create an unauthenticated client \u2014 public clients never fall back to SQLite or another local store. ` + `Looked in the Keychain (macOS only), then for a credential file at ${diskHint}, then for ${keys.apiKeyKeys[0]} in the environment.`);
+    throw new ClientTransportConfigurationError(name, warnings.join(" "), [configuredUrl?.key ?? keys.apiUrlKeys[0]]);
+  }
+  if (credential.warning)
+    warnings.push(credential.warning);
+  let urlHit;
+  if (configuredUrl) {
+    urlHit = configuredUrl;
+  } else {
+    try {
+      urlHit = { key: DEFAULT_AUTHORITY_SOURCE, value: defaultFleetGatewayBaseUrl(name) };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ClientTransportConfigurationError(name, `No ${keys.apiUrlKeys[0]} is configured and the default fleet gateway authority cannot be composed for '${name}': ${message}`, [keys.apiUrlKeys[0]]);
+    }
+  }
+  const apiUrlSource = urlHit.key;
+  let baseUrl;
+  try {
+    baseUrl = toV1BaseUrl(urlHit.value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new ClientTransportConfigurationError(name, `Invalid API URL from ${apiUrlSource}: ${message}`, [apiUrlSource]);
+  }
+  return {
+    resolution: {
+      transport: "http",
+      transportSource: urlHit.key,
+      baseUrl,
+      apiUrlSource,
+      apiKeyPresent: true,
+      apiKeySource: credential.source,
+      apiKeyTier: credential.tier,
+      misconfigured: false,
+      warning: warnings.length > 0 ? warnings.join(" ") : null
+    },
+    credential
+  };
+}
+function resolveClientTransport(name, env = process.env, options = {}) {
+  return resolveClientTransportSnapshot(name, env, options).resolution;
+}
+function credentialDiskSourcesForMessage(name, env) {
+  const paths = credentialDiskSources(name, env);
+  return paths.length > 0 ? paths.join(" or ") : "<no HOME or HASNA_HOME set in this environment, so no credential file was consulted>";
+}
+var CREDENTIAL_PROFILE_ENV_KEY = "HASNA_PROFILE", CredentialResolutionError, CredentialFileUnsafeError, HASNA_HOME_ENV_KEY = "HASNA_HOME", HASNA_CONFIG_HOME_ENV_KEY = "HASNA_CONFIG_HOME", KEYCHAIN_STATION_ENV_KEY = "HASNA_STATION", HASNA_HOME_DIR = ".hasna", CONFIG_SUBDIR = "config", CREDENTIALS_FILE = "credentials", KEYCHAIN_SECURITY_BIN = "/usr/bin/security", KEYCHAIN_SERVICE_PREFIX = "hasna.credentials", KEYCHAIN_ITEM_NOT_FOUND_STATUS = 44, KEYCHAIN_SPAWN_TIMEOUT_MS = 1e4, MAX_CREDENTIAL_FILE_BYTES, SAFE_APP_SLUG, SAFE_PROFILE, ILLEGAL_IN_HEADER_VALUE, VAULT_POINTER_SHAPE, CREDENTIAL_SHAPED_KEY, INSPECT_CUSTOM, CREDENTIAL_SEAL, AMBIENT_ENVIRONMENT, SECRETS_PACKAGE_SPECIFIER, requireSecretsSdk, DEFAULT_FLEET_GATEWAY_ORIGIN = "https://api.hasna.com", DEFAULT_AUTHORITY_SOURCE = "default", ASCII_CONTROL_PATTERN, DNS_LABEL_PATTERN, ClientTransportConfigurationError, IDEMPOTENT_METHODS, AUTHORITY_OVERRIDE_HEADERS;
+var init_transport = __esm(() => {
+  CredentialResolutionError = class CredentialResolutionError extends Error {
+    appName;
+    attempted;
+    constructor(appName, message, attempted) {
+      super(message);
+      this.name = "CredentialResolutionError";
+      this.appName = appName;
+      this.attempted = attempted;
+    }
+  };
+  CredentialFileUnsafeError = class CredentialFileUnsafeError extends Error {
+    path;
+    constructor(path, reason) {
+      super(`Refusing unsafe credential/config file ${path}: ${reason}.`);
+      this.name = "CredentialFileUnsafeError";
+      this.path = path;
+    }
+  };
+  MAX_CREDENTIAL_FILE_BYTES = 64 * 1024;
+  SAFE_APP_SLUG = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+  SAFE_PROFILE = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
+  ILLEGAL_IN_HEADER_VALUE = /[^\t\x20-\x7e]/;
+  VAULT_POINTER_SHAPE = /^[a-z0-9][a-z0-9-]*(?:\/[a-z0-9][a-z0-9-_.]*){2,}$/;
+  CREDENTIAL_SHAPED_KEY = /(?:^|_)(?:API_KEY|KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTH)(?:_|$)/;
+  INSPECT_CUSTOM = Symbol.for("nodejs.util.inspect.custom");
+  CREDENTIAL_SEAL = Symbol.for("hasna:contracts:sealedCredential");
+  AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
+  SECRETS_PACKAGE_SPECIFIER = "@hasna/" + "secrets";
+  requireSecretsSdk = createRequire(import.meta.url);
+  ASCII_CONTROL_PATTERN = /[\u0000-\u001f\u007f]/;
+  DNS_LABEL_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+  ClientTransportConfigurationError = class ClientTransportConfigurationError extends Error {
+    appName;
+    sources;
+    constructor(appName, message, sources = []) {
+      super(message);
+      this.name = "ClientTransportConfigurationError";
+      this.appName = appName;
+      this.sources = Object.freeze([...sources]);
+    }
+  };
+  IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+  AUTHORITY_OVERRIDE_HEADERS = new Set([
+    "host",
+    ":authority",
+    "forwarded",
+    "x-forwarded-host",
+    "x-original-host"
+  ]);
+});
+
+// src/lib/local-opt-in.ts
+function isHooksLocalOptIn(env = process.env) {
+  return HOOKS_LOCAL_OPT_IN_ENV_KEYS.some((key) => (env[key] ?? "").trim() !== "");
+}
+function hooksAuthorityEnvKeys() {
+  const keys = clientTransportEnvKeys("hooks");
+  return [
+    ...keys.apiUrlKeys,
+    ...keys.apiKeyKeys,
+    credentialOverrideEnvKey("hooks"),
+    credentialPointerEnvKey("hooks"),
+    CREDENTIAL_PROFILE_ENV_KEY
+  ];
+}
+function hasHooksEnvAuthorityIntent(env = process.env) {
+  return hooksAuthorityEnvKeys().some((key) => (env[key] ?? "").trim() !== "");
+}
+function selectsHooksLocalStore(env = process.env) {
+  return !hasHooksEnvAuthorityIntent(env) && isHooksLocalOptIn(env);
+}
+function hooksHostedRouteLocalStoreRefusal(authority) {
+  return "REMOTE_COMMAND_UNSUPPORTED: this command is local-only \u2014 it reads the on-box SQLite store " + `(hooks.db), which the hosted hooks registry authority (${authority}) does not serve; local SQLite ` + `is opt-in only (${HOOKS_LOCAL_OPT_IN_HINT}) and is disabled by default \u2014 refusing to open a local ` + "store on the hosted route.";
+}
+function hooksEventSinkRefusal() {
+  return "REMOTE_COMMAND_UNSUPPORTED: hook event not recorded \u2014 the hook event log is local-only (on-box " + "SQLite hooks.db) and the hosted hooks registry has no event route; local SQLite is opt-in only " + `(${HOOKS_LOCAL_OPT_IN_HINT}) and is disabled by default. Nothing was written.`;
+}
+function hooksResolverEnv(env) {
+  const blanks = hooksAuthorityEnvKeys().filter((key) => (key in env) && (env[key] ?? "").trim() === "");
+  if (blanks.length === 0)
+    return env;
+  const next = { ...env };
+  for (const key of blanks)
+    delete next[key];
+  return next;
+}
+function isAmbientHooksEnv(env) {
+  if (typeof process !== "undefined" && env === process.env)
+    return true;
+  return env[CONTRACTS_AMBIENT_ENVIRONMENT] === true;
+}
+function hooksResolverInputs(env, credentials = {}) {
+  const normalised = hooksResolverEnv(env);
+  if (normalised === env)
+    return { env: normalised, credentials };
+  const keychain = { ...credentials.keychain };
+  if (keychain.enabled === undefined && keychain.run === undefined) {
+    keychain.enabled = isAmbientHooksEnv(env);
+  }
+  return { env: normalised, credentials: { ...credentials, keychain } };
+}
+var HOOKS_LOCAL_OPT_IN_ENV_KEYS, HOOKS_LOCAL_OPT_IN_HINT = "HASNA_HOOKS_LOCAL=1 (alias HOOKS_LOCAL=1)", CONTRACTS_AMBIENT_ENVIRONMENT;
+var init_local_opt_in = __esm(() => {
+  init_transport();
+  HOOKS_LOCAL_OPT_IN_ENV_KEYS = ["HASNA_HOOKS_LOCAL", "HOOKS_LOCAL"];
+  CONTRACTS_AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
+});
+
+// src/lib/hook-env.ts
+import { dirname as dirname4, isAbsolute as isAbsolute3 } from "path";
+import { existsSync as existsSync9, realpathSync as realpathSync2, statSync } from "fs";
+import { tmpdir } from "os";
+function isDeniedEnvName(name) {
+  const upper = name.toUpperCase();
+  if (DENY_PREFIXES.some((prefix) => upper.startsWith(prefix)))
+    return true;
+  if (DENY_SUFFIXES.some((suffix) => upper.endsWith(suffix)))
+    return true;
+  return DENY_CONTAINS.some((token) => upper.includes(token));
+}
+function isInterpreterInjectionEnvName(name) {
+  if (INTERPRETER_INJECTION.has(name))
+    return true;
+  return INTERPRETER_INJECTION_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+function isBashFunctionEnvName(name) {
+  return name.startsWith("BASH_FUNC_");
+}
+function isUnsafePathEntry(entry, home) {
+  if (entry === "" || !isAbsolute3(entry))
+    return true;
+  if (home && (entry === home || entry.startsWith(home + "/")))
+    return true;
+  if (entry === "/tmp" || entry.startsWith("/tmp/"))
+    return true;
+  if (entry === "/var/tmp" || entry.startsWith("/var/tmp/"))
+    return true;
+  const canonical = (path) => {
+    try {
+      return realpathSync2(path);
+    } catch {
+      return path;
+    }
+  };
+  const resolved = canonical(entry);
+  for (const root of [home, tmpdir(), "/tmp", "/var/tmp"].filter((value) => Boolean(value))) {
+    const blocked = canonical(root);
+    if (resolved === blocked || resolved.startsWith(blocked + "/"))
+      return true;
+  }
+  try {
+    if ((statSync(entry).mode & 2) !== 0)
+      return true;
+  } catch {}
+  return false;
+}
+function sanitizeHookPath(pathValue, home) {
+  const baseline = PATH_BASELINE.slice();
+  if (process.platform === "darwin" && existsSync9("/opt/homebrew/bin"))
+    baseline.push("/opt/homebrew/bin");
+  const bunDir = dirname4(process.execPath);
+  const seen = new Set;
+  const out = [];
+  for (const dir of baseline) {
+    if (seen.has(dir))
+      continue;
+    seen.add(dir);
+    out.push(dir);
+  }
+  if (!seen.has(bunDir)) {
+    seen.add(bunDir);
+    out.push(bunDir);
+  }
+  for (const entry of pathValue.split(":")) {
+    if (seen.has(entry))
+      continue;
+    if (isUnsafePathEntry(entry, home))
+      continue;
+    seen.add(entry);
+    out.push(entry);
+  }
+  return out.join(":");
+}
+function buildHookEnv(source, extra) {
+  const out = {};
+  for (const name of ALLOWLIST) {
+    if (name === "PATH")
+      continue;
+    const value = source[name] ?? extra?.[name];
+    if (value !== undefined && value !== null)
+      out[name] = value;
+  }
+  const pathOverride = extra?.PATH;
+  if (pathOverride !== undefined && pathOverride !== null) {
+    out.PATH = pathOverride;
+  } else {
+    const parentPath = source.PATH;
+    if (parentPath !== undefined && parentPath !== null) {
+      out.PATH = sanitizeHookPath(parentPath, source.HOME ?? extra?.HOME);
+    }
+  }
+  for (const [from, to] of CONFIG_PROJECTIONS) {
+    const value = source[from] ?? extra?.[from];
+    if (value !== undefined && value !== null)
+      out[to] = value;
+  }
+  const merged = { ...source, ...extra ?? {} };
+  for (const [name, value] of Object.entries(merged)) {
+    if (out[name] !== undefined)
+      continue;
+    if (isDeniedEnvName(name))
+      continue;
+    if (isInterpreterInjectionEnvName(name))
+      continue;
+    if (isBashFunctionEnvName(name))
+      continue;
+    if (value !== undefined && value !== null)
+      out[name] = value;
+  }
+  return out;
+}
+var ALLOWLIST, INTERPRETER_INJECTION, INTERPRETER_INJECTION_PREFIXES, DENY_SUFFIXES, DENY_PREFIXES, DENY_CONTAINS, PATH_BASELINE, CONFIG_PROJECTIONS;
+var init_hook_env = __esm(() => {
+  ALLOWLIST = new Set(["PATH", "HOME", "LANG", "TZ", "SHELL", "TERM", "USER", "PWD"]);
+  INTERPRETER_INJECTION = new Set([
+    "BASH_ENV",
+    "ENV",
+    "BASHOPTS",
+    "SHELLOPTS",
+    "NODE_OPTIONS",
+    "NODE_PATH",
+    "PYTHONSTARTUP",
+    "PYTHONINSPECT",
+    "PYTHONPATH",
+    "PYTHONHOME",
+    "LD_PRELOAD",
+    "LD_LIBRARY_PATH",
+    "GCONV_PATH",
+    "LOCPATH",
+    "PERL5OPT",
+    "RUBYOPT",
+    "NODE_EXTRA_CA_CERTS",
+    "NODE_TLS_REJECT_UNAUTHORIZED",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    "CURL_CA_BUNDLE",
+    "GIT_SSL_CAINFO",
+    "AWS_CA_BUNDLE"
+  ]);
+  INTERPRETER_INJECTION_PREFIXES = ["GIT_CONFIG_"];
+  DENY_SUFFIXES = ["KEY", "TOKEN", "SECRET", "PASSWORD", "PASSWD", "CREDENTIAL", "CREDENTIALS", "URL", "URI"];
+  DENY_PREFIXES = [
+    "HASNA_",
+    "AWS_",
+    "AZURE_",
+    "GCP_",
+    "VAULT_",
+    "GOOGLE_",
+    "OPENAI_",
+    "ANTHROPIC_",
+    "POSTGRES_",
+    "MYSQL_",
+    "REDIS_",
+    "MONGO_",
+    "MEMENTOS_"
+  ];
+  DENY_CONTAINS = ["DATABASE_URL"];
+  PATH_BASELINE = ["/usr/bin", "/bin", "/usr/local/bin", "/sbin", "/usr/sbin"];
+  CONFIG_PROJECTIONS = [
+    ["HASNA_HOOKS_LOCAL", "HOOKS_LOCAL"],
+    ["HASNA_HOOKS_DATA_DIR", "HOOKS_DATA_DIR"],
+    ["HASNA_HOOKS_DB_PATH", "HOOKS_DB_PATH"],
+    ["HASNA_HOOKS_LOCK_PATH", "HOOKS_LOCK_PATH"],
+    ["HASNA_HOOKS_CONFIG_PATH", "HOOKS_CONFIG_PATH"]
+  ];
+});
+
+// src/lib/run.ts
+var exports_run = {};
+__export(exports_run, {
+  executeVerifiedScript: () => executeVerifiedScript,
+  HookTimeoutError: () => HookTimeoutError
+});
+import { randomBytes as randomBytes2 } from "crypto";
+import { rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute4, join as join10 } from "path";
+function extensionOf(scriptPath) {
+  const base = basename2(scriptPath);
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(dot + 1) : "ts";
+}
+function shebangInterpreter(firstLine) {
+  if (!firstLine.startsWith("#!"))
+    return null;
+  const rest = firstLine.slice(2).trim();
+  if (!rest)
+    return null;
+  const parts = rest.split(/\s+/);
+  if (parts[0] === "env" || parts[0] === "/usr/bin/env") {
+    return parts[1] && parts[1] !== "-S" ? basename2(parts[1]) : parts[2] ? basename2(parts[2]) : null;
+  }
+  return basename2(parts[0]);
+}
+function interpreterFor(name, scriptPath, content) {
+  const ext = extensionOf(scriptPath);
+  const firstLine = content.subarray(0, 512).toString("utf8").split(`
+`, 1)[0] ?? "";
+  const interp = shebangInterpreter(firstLine);
+  if (interp) {
+    if (interp === "bash" || interp === "sh")
+      return { command: ["/bin/bash"], tempExt: "sh" };
+    if (interp === "node" || interp === "bun")
+      return { command: [process.execPath, "run"], tempExt: BUN_EXTENSIONS.has(ext) ? ext : "ts" };
+    throw new Error(`Refusing to run hook '${name}': shebang '${firstLine}' is not a recognized interpreter (supported: bash/sh, node/bun)`);
+  }
+  if (BASH_EXTENSIONS.has(ext))
+    return { command: ["/bin/bash"], tempExt: "sh" };
+  if (BUN_EXTENSIONS.has(ext))
+    return { command: [process.execPath, "run"], tempExt: ext };
+  throw new Error(`Refusing to run hook '${name}': unsupported script extension '.${ext}' (supported: .sh .bash .ts .tsx .js .jsx .mjs .cjs .mts .cts, or a recognized shebang)`);
+}
+async function readPipeWithDeadline(stream, deadlineMs) {
+  const reader = stream.getReader();
+  const chunks = [];
+  const deadline = Date.now() + deadlineMs;
+  try {
+    while (true) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0)
+        break;
+      let result;
+      try {
+        result = await Promise.race([
+          reader.read(),
+          new Promise((_, reject) => {
+            const t = setTimeout(() => reject(new Error("pipe-drain-deadline")), remaining);
+            t.unref?.();
+          })
+        ]);
+      } catch {
+        break;
+      }
+      if (result.done)
+        break;
+      chunks.push(new TextDecoder().decode(result.value));
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {}
+  }
+  return chunks.join("");
+}
+async function executeVerifiedScript(options) {
+  const scriptDir = dirname5(options.scriptPath);
+  const interpreter = interpreterFor(options.name, options.scriptPath, options.content);
+  const tempPath = join10(scriptDir, `.hooks-verified-${randomBytes2(12).toString("hex")}.${interpreter.tempExt}`);
+  let proc = null;
+  let timedOut = false;
+  const timeoutTimer = options.timeout ? setTimeout(() => {
+    timedOut = true;
+    killGroup(proc, { leaderAlive: proc !== null && proc.exitCode === null });
+  }, options.timeout) : null;
+  try {
+    writeFileSync5(tempPath, options.content, { flag: "wx", mode: 384 });
+    proc = Bun.spawn([...interpreter.command, isAbsolute4(tempPath) ? tempPath : `./${tempPath}`, ...options.args ?? []], {
+      stdin: new Response(options.stdin),
+      stdout: "pipe",
+      stderr: "pipe",
+      env: buildHookEnv(process.env, options.env),
+      detached: true
+    });
+    const exitCode = await proc.exited;
+    if (timedOut) {
+      throw new HookTimeoutError(options.timeout);
+    }
+    const [stdoutText, stderrText] = await Promise.all([
+      readPipeWithDeadline(proc.stdout, 750),
+      readPipeWithDeadline(proc.stderr, 750)
+    ]);
+    killGroup(proc, { leaderAlive: false });
+    return { stdout: stdoutText, stderr: stderrText, exitCode };
+  } finally {
+    if (timeoutTimer)
+      clearTimeout(timeoutTimer);
+    try {
+      rmSync2(tempPath, { force: true });
+    } catch {}
+  }
+}
+function killGroup(proc, options) {
+  if (!proc)
+    return;
+  const pgid = proc.pid;
+  for (let pass = 0;pass < 5; pass++) {
+    let members = [];
+    try {
+      const res = Bun.spawnSync(["ps", "-eo", "pid=,pgid="], { stdout: "pipe", stderr: "pipe" });
+      if (res.exitCode === 0) {
+        members = res.stdout.toString().split(`
+`).map((line) => line.trim().split(/\s+/)).filter((cols) => cols.length === 2 && cols[1] === String(pgid)).map((cols) => Number(cols[0])).filter((pid) => Number.isInteger(pid) && pid > 1).filter((pid) => options.leaderAlive || pid !== proc.pid);
+      }
+    } catch {}
+    if (members.length === 0)
+      break;
+    let killed = 0;
+    for (const pid of members) {
+      try {
+        const probe = Bun.spawnSync(["ps", "-o", "pid=,pgid=", "-p", String(pid)], { stdout: "pipe", stderr: "pipe" });
+        const cols = probe.stdout.toString().trim().split(/\s+/);
+        if (cols.length === 2 && cols[1] === String(pgid)) {
+          process.kill(pid, "SIGKILL");
+          killed++;
+        }
+      } catch {}
+    }
+    if (killed === 0)
+      break;
+  }
+  if (options.leaderAlive) {
+    try {
+      process.kill(proc.pid, "SIGKILL");
+    } catch {}
+  }
+}
+var HookTimeoutError, BASH_EXTENSIONS, BUN_EXTENSIONS;
+var init_run = __esm(() => {
+  init_hook_env();
+  HookTimeoutError = class HookTimeoutError extends Error {
+    timeoutMs;
+    constructor(timeoutMs) {
+      super(`Hook timed out after ${timeoutMs}ms (process group killed)`);
+      this.name = "HookTimeoutError";
+      this.timeoutMs = timeoutMs;
+    }
+  };
+  BASH_EXTENSIONS = new Set(["sh", "bash"]);
+  BUN_EXTENSIONS = new Set(["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"]);
+});
+
+// src/lib/db-writer.ts
+var exports_db_writer = {};
+__export(exports_db_writer, {
+  writeHookEvent: () => writeHookEvent,
+  resolveHookEventSink: () => resolveHookEventSink,
+  resolveEventType: () => resolveEventType,
+  recordHookRun: () => recordHookRun,
+  normalizeEventType: () => normalizeEventType,
+  __resetHookEventSinkNotice: () => __resetHookEventSinkNotice
+});
+function resolveHookEventSink(env = process.env) {
+  if (isLocalStoreRefused())
+    return { kind: "refused", reason: localStoreRefusalMessage() ?? hooksEventSinkRefusal() };
+  if (selectsHooksLocalStore(env))
+    return { kind: "local" };
+  return { kind: "refused", reason: hooksEventSinkRefusal() };
+}
+function __resetHookEventSinkNotice() {
+  sinkRefusalPrinted = false;
+}
+function nanoid2() {
+  return crypto.randomUUID().replace(/-/g, "").slice(0, 21);
+}
+function writeHookEvent(event) {
+  const sink = resolveHookEventSink();
+  if (sink.kind !== "local") {
+    if (!sinkRefusalPrinted) {
+      sinkRefusalPrinted = true;
+      process.stderr.write(`[hooks db-writer] ${sink.reason}
+`);
+    }
+    return;
+  }
+  try {
+    const db = getDb();
+    const id = nanoid2();
+    const timestamp = event.timestamp ?? new Date().toISOString();
+    const toolInput = redactEventPayload(event.tool_input);
+    const error = redactEventPayload(event.error);
+    const metadata = redactEventPayload(event.metadata);
+    db.run(`INSERT INTO hook_events
+        (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      timestamp,
+      event.session_id,
+      event.hook_name,
+      event.event_type,
+      event.tool_name ?? null,
+      toolInput ? toolInput.slice(0, 500) : null,
+      event.result ?? null,
+      error ?? null,
+      event.duration_ms ?? null,
+      event.project_dir ?? null,
+      metadata ?? null
+    ]);
+  } catch (err) {
+    process.stderr.write(`[hooks db-writer] failed to write event: ${err}
+`);
+  }
+}
+function normalizeEventType(value) {
+  if (typeof value !== "string")
+    return null;
+  if (ALLOWED_EVENT_TYPES.has(value))
+    return value;
+  const bare = value.split(":")[0] ?? "";
+  return ALLOWED_EVENT_TYPES.has(bare) ? bare : null;
+}
+function resolveEventType(inputEvent, fallbackEvent) {
+  const fromInput = normalizeEventType(inputEvent);
+  if (fromInput)
+    return fromInput;
+  return normalizeEventType(fallbackEvent ?? null);
+}
+function recordHookRun(record) {
+  const eventType = record.eventType ? normalizeEventType(record.eventType) : null;
+  if (!eventType) {
+    process.stderr.write(`[hooks db-writer] skipped event for '${record.hookName}': unsupported event type '${String(record.eventType)}'
+`);
+    return;
+  }
+  const metadata = {
+    ...record.metadata ?? {},
+    version: record.version ?? null,
+    sha256: record.sha256 ?? null,
+    exit_code: record.exitCode
+  };
+  writeHookEvent({
+    session_id: record.sessionId ?? "cli",
+    hook_name: record.hookName,
+    event_type: eventType,
+    tool_name: record.toolName ?? null,
+    tool_input: record.toolInput !== undefined ? JSON.stringify(record.toolInput) : null,
+    result: record.result ?? null,
+    error: record.error ?? null,
+    duration_ms: record.durationMs,
+    project_dir: record.projectDir ?? null,
+    metadata: JSON.stringify(metadata)
+  });
+}
+var sinkRefusalPrinted = false, ALLOWED_EVENT_TYPES;
+var init_db_writer = __esm(() => {
+  init_db();
+  init_local_opt_in();
+  init_redact();
+  ALLOWED_EVENT_TYPES = new Set([
+    "PreToolUse",
+    "PostToolUse",
+    "Stop",
+    "Notification",
+    "SessionStart",
+    "SessionEnd",
+    "UserPromptSubmit",
+    "SubagentStart"
+  ]);
+});
+
+// src/mcp/server.ts
+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";
+init_registry();
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { join as join11, dirname as dirname6 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/lib/installer.ts
+init_registry();
+init_resolve();
+init_manifest();
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readdirSync as readdirSync3, rmdirSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
+import { homedir as homedir3 } from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/lib/registration.ts
+init_resolve();
+function matchersOverlap(a, b) {
+  return a === b || a.includes(b) || b.includes(a);
+}
+function hookEventsOf(info) {
+  return info.events?.length ? info.events : info.event ? [info.event] : [];
+}
+function findRewriteOverlaps(names, lookup) {
+  const rewriting = names.map((name) => ({ name, info: lookup(name) })).filter((row) => Boolean(row.info?.rewritesInput && row.info.matcher));
+  const overlaps = [];
+  for (let i = 0;i < rewriting.length; i++) {
+    for (let j = i + 1;j < rewriting.length; j++) {
+      const a = rewriting[i];
+      const b = rewriting[j];
+      const aEvents = hookEventsOf(a.info);
+      const bEvents = hookEventsOf(b.info);
+      const event = aEvents.find((name) => name === "PreToolUse" && bEvents.includes(name));
+      if (!event)
+        continue;
+      const aMatcher = a.info.matcher;
+      const bMatcher = b.info.matcher;
+      if (!matchersOverlap(aMatcher.toLowerCase(), bMatcher.toLowerCase()))
+        continue;
+      overlaps.push({ hooks: [a.name, b.name], event, matchers: [aMatcher, bMatcher] });
+    }
+  }
+  return overlaps;
+}
+function safeMatcherTest(pattern, value) {
+  try {
+    return new RegExp(pattern).test(value);
+  } catch {
+    return false;
+  }
+}
+function hookRegisteredInSettings(settings, name, eventSpec, hookMatcher) {
+  const separator = eventSpec.indexOf(":");
+  const eventName = separator === -1 ? eventSpec : eventSpec.slice(0, separator);
+  const specMatcher = separator === -1 ? "" : eventSpec.slice(separator + 1);
+  const matcher = specMatcher || hookMatcher || "";
+  const hooks = settings.hooks?.[eventName];
+  if (!Array.isArray(hooks))
+    return false;
+  return hooks.some((entry) => entry?.hooks?.some((h) => {
+    const match = h?.command?.match(/^hooks run ([\w-]+)/);
+    if (!match || match[1] !== name)
+      return false;
+    if (!matcher)
+      return true;
+    const entryMatcher = typeof entry.matcher === "string" ? entry.matcher : "";
+    if (!entryMatcher)
+      return true;
+    return entryMatcher === matcher || safeMatcherTest(entryMatcher, matcher) || safeMatcherTest(matcher, entryMatcher);
+  }));
+}
+
+// src/lib/store.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync } from "fs";
+init_db();
+init_config();
+import { randomBytes } from "crypto";
+function sha256Of(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function storeDb() {
+  return isLocalStoreRefused() ? null : getDb();
+}
+function getHookRecord(db, name) {
+  return db.query("SELECT * FROM hooks WHERE name = ?").get(name);
+}
+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
+  ]);
+}
+class LockFileError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LockFileError";
+  }
+}
+function assertLockShape(parsed, path) {
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new LockFileError(`hooks.lock (${path}) is malformed: expected a JSON object with a "hooks" map. ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it. ` + `Nothing was trusted or rewritten \u2014 hooks are left in the refuse-to-run state until the lock is repaired.`);
+  }
+  const hooks = parsed.hooks;
+  if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks)) {
+    throw new LockFileError(`hooks.lock (${path}) is malformed: missing or invalid "hooks" map. ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it. ` + `Nothing was trusted or rewritten \u2014 hooks are left in the refuse-to-run state until the lock is repaired.`);
+  }
+  for (const [name, entry] of Object.entries(hooks)) {
+    const e = entry;
+    if (e === null || typeof e !== "object" || typeof e.version !== "string" || typeof e.sha256 !== "string") {
+      throw new LockFileError(`hooks.lock (${path}) is malformed: entry for '${name}' is not a valid pin (version and sha256 strings required). ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it.`);
+    }
+  }
+}
+function readLock() {
+  const path = getLockPath();
+  if (!existsSync6(path))
+    return { hooks: {} };
+  let raw;
+  try {
+    raw = readFileSync3(path, "utf-8");
+  } catch {
+    throw new LockFileError(`hooks.lock (${path}) could not be read. Repair: fix permissions or move the file aside and run 'hooks sync'.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new LockFileError(`hooks.lock (${path}) is malformed: not valid JSON (${String((raw ?? "").slice(0, 80))}). ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it. ` + `Nothing was trusted or rewritten \u2014 hooks are left in the refuse-to-run state until the lock is repaired.`);
+  }
+  assertLockShape(parsed, path);
+  return parsed;
+}
+function writeLock(lock) {
+  const path = getLockPath();
+  mkdirSync3(path.substring(0, path.lastIndexOf("/")) || ".", { recursive: true });
+  const sorted = {};
+  for (const name of Object.keys(lock.hooks).sort()) {
+    sorted[name] = lock.hooks[name];
+  }
+  const tmp = `${path}.tmp-${randomBytes(8).toString("hex")}`;
+  writeFileSync2(tmp, JSON.stringify({ hooks: sorted }, null, 2) + `
+`, "utf-8");
+  renameSync(tmp, path);
+  return path;
+}
+function setPinnedHook(name, entry) {
+  const lock = readLock();
+  lock.hooks[name] = entry;
+  return writeLock(lock);
+}
+function getPinnedHook(name) {
+  return readLock().hooks[name];
+}
+function checkScriptHash(name, actual) {
+  const db = storeDb();
+  const record = db ? getHookRecord(db, name) : null;
+  const pin = getPinnedHook(name);
+  const expected = record?.sha256 ?? pin?.sha256 ?? null;
+  if (expected !== null && expected !== actual) {
+    return { ok: false, pinned: true, expected, actual, name };
+  }
+  if (expected === null) {
+    const now2 = new Date().toISOString();
+    const version = pin?.version ?? record?.version ?? "0.0.0";
+    const source = pin?.source ?? record?.source_type ?? "local";
+    if (db) {
+      upsertHookRecord(db, {
+        name,
+        version,
+        sha256: actual,
+        source_type: source,
+        last_verified_at: now2
+      });
+    }
+    setPinnedHook(name, { version, sha256: actual, source });
+    return { ok: true, pinned: false, expected: null, actual, name };
+  }
+  const now = new Date().toISOString();
+  if (db) {
+    upsertHookRecord(db, {
+      name,
+      version: record?.version ?? pin?.version ?? "0.0.0",
+      sha256: expected,
+      source_type: record?.source_type ?? pin?.source ?? "local",
+      last_verified_at: now
+    });
+  }
+  return { ok: true, pinned: true, expected, actual, name };
+}
+
+// src/lib/installer.ts
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var HOOKS_DIR = existsSync7(join7(__dirname2, "..", "..", "hooks", "hook-gitguard")) ? join7(__dirname2, "..", "..", "hooks") : join7(__dirname2, "..", "hooks");
+function normalizeHookName(name) {
+  return name.startsWith("hook-") ? name : `hook-${name}`;
+}
+function shortHookName(name) {
+  return name.startsWith("hook-") ? name.slice("hook-".length) : name;
+}
+function removeHookEntriesByName(entries, hookName) {
+  return entries.filter((entry) => !entry.hooks?.some((h) => {
+    const match = h.command?.match(/^hooks run ([\w-]+)/);
+    return match && match[1] === hookName;
+  }));
+}
+var EVENT_MAP = {
+  claude: {
+    PreToolUse: "PreToolUse",
+    PostToolUse: "PostToolUse",
+    Stop: "Stop",
+    Notification: "Notification",
+    SessionStart: "SessionStart",
+    SessionEnd: "SessionEnd",
+    UserPromptSubmit: null,
+    SubagentStart: null
+  },
+  gemini: {
+    PreToolUse: "BeforeTool",
+    PostToolUse: "AfterTool",
+    Stop: "AfterAgent",
+    Notification: "Notification",
+    SessionStart: null,
+    SessionEnd: null,
+    UserPromptSubmit: null,
+    SubagentStart: null
+  },
+  codewith: {
+    PreToolUse: "PreToolUse",
+    PostToolUse: "PostToolUse",
+    Stop: "Stop",
+    Notification: null,
+    SessionStart: "SessionStart",
+    SessionEnd: null,
+    UserPromptSubmit: "UserPromptSubmit",
+    SubagentStart: "SubagentStart"
+  }
+};
+function getTargetSettingsDir(target) {
+  if (target === "codewith")
+    return ".codewith";
+  if (target === "gemini")
+    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" && scope === "global" && 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" ? join7(process.cwd(), dir, "config.toml") : join7(process.cwd(), dir, "settings.json");
+  }
+  return target === "codewith" ? join7(homedir3(), dir, "config.toml") : join7(homedir3(), dir, "settings.json");
+}
+function getHookPath(name) {
+  const shortName = shortHookName(name);
+  const resolved = resolveHookDir(shortName);
+  if (resolved)
+    return resolved;
+  return join7(HOOKS_DIR, normalizeHookName(shortName));
+}
+function hookExists(name) {
+  return existsSync7(getHookPath(name));
+}
+function readSettings(scope = "global", target = "claude") {
+  const path = getSettingsPath(scope, target);
+  try {
+    if (existsSync7(path)) {
+      return JSON.parse(readFileSync4(path, "utf-8"));
+    }
+  } catch (error) {
+    console.warn(`[hooks] Failed to read settings at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return {};
+}
+function writeSettings(settings, scope = "global", target = "claude") {
+  const path = getSettingsPath(scope, target);
+  const dir = dirname3(path);
+  if (!existsSync7(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  writeFileSync3(path, JSON.stringify(settings, null, 2) + `
+`);
+}
+function getTargetEventName(internalEvent, target) {
+  return EVENT_MAP[target]?.[internalEvent] ?? null;
+}
+function isEventSupported(internalEvent, target) {
+  return getTargetEventName(internalEvent, target) !== null;
+}
+function tomlString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function codewithMatcher(matcher) {
+  if (!matcher)
+    return;
+  if (matcher.startsWith("^"))
+    return matcher;
+  if (matcher.includes("|"))
+    return `^(${matcher})$`;
+  return `^${matcher}$`;
+}
+function codewithTimeout(name) {
+  switch (name) {
+    case "knowledge-context":
+      return 6;
+    case "session-start":
+      return 8;
+    case "pre-bash":
+      return 20;
+    case "prompt-guard":
+      return 3;
+    case "worktree-guard":
+    case "trash-guard":
+    case "stop-sync":
+      return 5;
+    default:
+      return 10;
+  }
+}
+function codewithStatusMessage(name) {
+  switch (name) {
+    case "knowledge-context":
+      return "Loading Knowledge context";
+    case "session-start":
+      return "Checking Hasna session context";
+    case "pre-bash":
+      return "Checking Bash safety";
+    case "prompt-guard":
+      return "Checking prompt safety";
+    case "worktree-guard":
+      return "Checking worktree safety";
+    case "trash-guard":
+      return "Redirecting rm into trash";
+    case "stop-sync":
+      return "Syncing turn-end heartbeat";
+    default:
+      return `Running ${name}`;
+  }
+}
+function buildCodewithTomlFragment(name, profile) {
+  const shortName = shortHookName(name);
+  const meta = resolveHookMeta(shortName);
+  if (!meta)
+    throw new Error(`Hook '${shortName}' not found`);
+  const command = profile ? `hooks run ${shortName} --profile ${profile}` : `hooks run ${shortName}`;
+  const matcher = codewithMatcher(meta.matcher);
+  const fragments = [];
+  for (const event of getHookEvents(meta)) {
+    const eventKey = getTargetEventName(event, "codewith");
+    if (!eventKey) {
+      throw new Error(`Hook '${shortName}' uses event '${event}', which is not supported by the Codewith target`);
+    }
+    const lines = [
+      `[[hooks.${eventKey}]]`
+    ];
+    if (matcher)
+      lines.push(`matcher = ${tomlString(matcher)}`);
+    lines.push("", `[[hooks.${eventKey}.hooks]]`, `type = "command"`, `command = ${tomlString(command)}`, `timeout = ${codewithTimeout(shortName)}`, `statusMessage = ${tomlString(codewithStatusMessage(shortName))}`);
+    fragments.push(lines.join(`
+`));
+  }
+  return `${fragments.join(`
+
+`)}
+`;
+}
+function readCodewithConfig(scope, configPath) {
+  const path = getSettingsPath(scope, "codewith", configPath);
+  try {
+    return existsSync7(path) ? readFileSync4(path, "utf-8") : "";
+  } catch {
+    return "";
+  }
+}
+function appendCodewithFragment(fragment, scope, configPath) {
+  const path = getSettingsPath(scope, "codewith", configPath);
+  const dir = dirname3(path);
+  if (!existsSync7(dir))
+    mkdirSync4(dir, { recursive: true });
+  const existing = existsSync7(path) ? readFileSync4(path, "utf-8") : "";
+  const sep2 = existing.trim() ? `
+
+` : "";
+  writeFileSync3(path, `${existing.replace(/\s*$/, "")}${sep2}${fragment}`);
+  return path;
+}
+function detectConflict(name, scope, target) {
+  const meta = resolveHookMeta(name);
+  if (!meta || !meta.matcher)
+    return;
+  const events = new Set(getHookEvents(meta));
+  const registered = getRegisteredHooksForTarget(scope, target);
+  for (const existingName of registered) {
+    if (existingName === name)
+      continue;
+    const existing = getHook(existingName);
+    if (!existing || !existing.matcher)
+      continue;
+    if (!getHookEvents(existing).some((event) => events.has(event)))
+      continue;
+    if (matchersOverlap(meta.matcher.toLowerCase(), existing.matcher.toLowerCase())) {
+      return `conflicts with '${existingName}' (same event ${meta.event}, overlapping matcher '${existing.matcher}')`;
+    }
+  }
+  return;
+}
+function detectRewriteConflict(name, scope, target, lookup = getHook) {
+  const meta = resolveHookMeta(name);
+  if (!meta?.matcher || !meta.rewritesInput)
+    return;
+  if (!getHookEvents(meta).includes("PreToolUse"))
+    return;
+  for (const existingName of getRegisteredHooksForTarget(scope, target)) {
+    if (existingName === name)
+      continue;
+    const existing = lookup(existingName);
+    if (!existing?.matcher || !existing.rewritesInput)
+      continue;
+    if (!getHookEvents(existing).includes("PreToolUse"))
+      continue;
+    if (!matchersOverlap(meta.matcher.toLowerCase(), existing.matcher.toLowerCase()))
+      continue;
+    return `both '${name}' and '${existingName}' rewrite the tool input on overlapping PreToolUse matchers ('${meta.matcher}' / '${existing.matcher}'). Only one rewrite per tool call is applied, so one guard would silently disappear \u2014 install one of them, or narrow a matcher so they no longer overlap.`;
+  }
+  return;
+}
+function installForTarget(name, scope, overwrite, target, profile, codewithMode = "fragment", codewithConfigPath) {
+  const shortName = shortHookName(name);
+  if (!hookExists(shortName)) {
+    return { hook: shortName, success: false, error: `Hook '${shortName}' not found`, target };
+  }
+  if (target === "codewith") {
+    try {
+      const fragment = buildCodewithTomlFragment(shortName, profile);
+      if (codewithMode !== "write") {
+        return {
+          hook: shortName,
+          success: true,
+          scope,
+          target,
+          fragment,
+          applied: false,
+          note: "Codewith install is fragment-only by default; configs should own applying this TOML."
+        };
+      }
+      if (!codewithConfigPath) {
+        return {
+          hook: shortName,
+          success: false,
+          error: "Direct Codewith writes require an explicit --codewith-config path; refusing to write default ~/.codewith/config.toml.",
+          scope,
+          target,
+          fragment,
+          applied: false
+        };
+      }
+      const existing = readCodewithConfig(scope, codewithConfigPath);
+      if (!overwrite && new RegExp(`command\\s*=\\s*["']hooks run ${shortName}(?:\\s|["'])`).test(existing)) {
+        return { hook: shortName, success: false, error: "Already installed. Use --overwrite to append another fragment.", scope, target };
+      }
+      const path = appendCodewithFragment(fragment, scope, codewithConfigPath);
+      return {
+        hook: shortName,
+        success: true,
+        scope,
+        target,
+        fragment,
+        applied: true,
+        configPath: path,
+        note: "Direct Codewith config write was explicitly requested; prefer configs for managed machines."
+      };
+    } catch (error) {
+      return {
+        hook: shortName,
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        target
+      };
+    }
+  }
+  const registered = getRegisteredHooksForTarget(scope, target);
+  if (registered.includes(shortName) && !overwrite) {
+    return { hook: shortName, success: false, error: "Already installed. Use --overwrite to replace.", scope, target };
+  }
+  const conflict = detectConflict(shortName, scope, target);
+  const rewriteConflict = detectRewriteConflict(shortName, scope, target);
+  if (rewriteConflict) {
+    return { hook: shortName, success: false, error: `Refused: ${rewriteConflict}`, scope, target };
+  }
+  try {
+    registerHook(shortName, scope, target, profile);
+    return { hook: shortName, success: true, scope, target, ...conflict ? { conflict } : {} };
+  } catch (error) {
+    return {
+      hook: shortName,
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      target
+    };
+  }
+}
+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 = resolveHookMeta(shortName);
+    if (meta) {
+      const unsupportedTargets = ["claude", "codewith"].filter((agentTarget) => getHookEvents(meta).some((event) => !isEventSupported(event, agentTarget)));
+      if (unsupportedTargets.length > 0) {
+        return {
+          hook: shortName,
+          success: false,
+          error: `Event(s) '${getHookEvents(meta).join(", ")}' are not supported by target(s): ${unsupportedTargets.join(", ")}`,
+          target: "all"
+        };
+      }
+    }
+    const claudeResult = installForTarget(name, scope, overwrite, "claude", profile);
+    if (!claudeResult.success) {
+      return {
+        ...claudeResult,
+        error: `Failed for target 'claude': ${claudeResult.error}`,
+        target: "all"
+      };
+    }
+    const codewithResult = installForTarget(name, scope, overwrite, "codewith", profile, codewithMode, codewithConfigPath);
+    if (!codewithResult.success) {
+      return {
+        ...codewithResult,
+        error: `Failed for target 'codewith': ${codewithResult.error}`,
+        target: "all"
+      };
+    }
+    return { ...claudeResult, target: "all" };
+  }
+  return installForTarget(name, scope, overwrite, target, profile, codewithMode, codewithConfigPath);
+}
+function registerHook(name, scope = "global", target = "claude", profile) {
+  const meta = resolveHookMeta(name);
+  if (!meta)
+    return;
+  const eventKeys = getHookEvents(meta).map((event) => {
+    const eventKey = getTargetEventName(event, target);
+    if (eventKey === null) {
+      throw new Error(`Event '${event}' is not supported by target '${target}'`);
+    }
+    return eventKey;
+  });
+  const uniqueEventKeys = [...new Set(eventKeys)];
+  if (uniqueEventKeys.length === 0) {
+    throw new Error(`Hook '${name}' has no installable events for target '${target}'`);
+  }
+  const settings = readSettings(scope, target);
+  if (!settings.hooks)
+    settings.hooks = {};
+  removeHookFromAllEvents(settings, name);
+  const hookCommand = profile ? `hooks run ${name} --profile ${profile}` : `hooks run ${name}`;
+  for (const eventKey of uniqueEventKeys) {
+    if (!settings.hooks[eventKey])
+      settings.hooks[eventKey] = [];
+    const hookEntry = { type: "command", command: hookCommand };
+    if (typeof meta.timeoutSeconds === "number" && meta.timeoutSeconds > 0) {
+      hookEntry.timeout = meta.timeoutSeconds;
+    }
+    const entry = {
+      hooks: [hookEntry]
+    };
+    if (meta.matcher) {
+      entry.matcher = meta.matcher;
+    }
+    settings.hooks[eventKey].push(entry);
+  }
+  writeSettings(settings, scope, target);
+}
+function removeHookFromAllEvents(settings, name) {
+  if (!settings.hooks)
+    return;
+  for (const key of Object.keys(settings.hooks)) {
+    settings.hooks[key] = removeHookEntriesByName(settings.hooks[key], name);
+    if (settings.hooks[key].length === 0) {
+      delete settings.hooks[key];
+    }
+  }
+}
+function unregisterHook(name, scope = "global", target = "claude") {
+  const settings = readSettings(scope, target);
+  if (!settings.hooks)
+    return;
+  removeHookFromAllEvents(settings, name);
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeSettings(settings, scope, target);
+}
+function getRegisteredHooksForTarget(scope = "global", target = "claude") {
+  if (target === "codewith") {
+    const config = readCodewithConfig(scope);
+    const registered2 = [];
+    const re = /command\s*=\s*["']hooks run ([\w-]+)(?:\s+--profile\s+[\w-]+)?["']/g;
+    let match;
+    while (match = re.exec(config)) {
+      registered2.push(match[1]);
+    }
+    return [...new Set(registered2)];
+  }
+  const settings = readSettings(scope, target);
+  if (!settings.hooks)
+    return [];
+  const registered = [];
+  for (const eventKey of Object.keys(settings.hooks)) {
+    for (const entry of settings.hooks[eventKey]) {
+      for (const hook of entry.hooks || []) {
+        const newMatch = hook.command?.match(/^hooks run ([\w-]+)(?:\s+--profile\s+[\w-]+)?$/);
+        const oldMatch = hook.command?.match(/^hook-([\w-]+)$/);
+        const match = newMatch || oldMatch;
+        if (match) {
+          registered.push(match[1]);
+        }
+      }
+    }
+  }
+  return [...new Set(registered)];
+}
+function getRegisteredHooks(scope = "global") {
+  return getRegisteredHooksForTarget(scope, "claude");
+}
+function removeHook(name, scope = "global", target = "claude") {
+  const shortName = shortHookName(name);
+  if (target === "all") {
+    const claudeRemoved = removeHookForTarget(shortName, scope, "claude");
+    const geminiRemoved = removeHookForTarget(shortName, scope, "gemini");
+    return claudeRemoved || geminiRemoved;
+  }
+  if (target === "codewith") {
+    return false;
+  }
+  return removeHookForTarget(shortName, scope, target);
+}
+function removeHookForTarget(name, scope, target) {
+  const registered = getRegisteredHooksForTarget(scope, target);
+  if (!registered.includes(name)) {
+    return false;
+  }
+  unregisterHook(name, scope, target);
+  return true;
+}
+
+// src/lib/profiles.ts
+init_app_home();
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4, readdirSync as readdirSync4, rmSync, cpSync as cpSync2 } from "fs";
+import { join as join8 } from "path";
+function getProfilesDir() {
+  const newDir = join8(getEffectiveDataRoot(), "profiles");
+  const oldDir = join8(getHomeDir(), ".hooks", "profiles");
+  if (!existsSync8(newDir) && existsSync8(oldDir)) {
+    mkdirSync5(newDir, { recursive: true });
+    cpSync2(oldDir, newDir, { recursive: true });
+  }
+  return newDir;
+}
+function ensureProfilesDir() {
+  const dir = getProfilesDir();
+  if (!existsSync8(dir)) {
+    mkdirSync5(dir, { recursive: true });
+  }
+}
+function profilePath(id) {
+  return join8(getProfilesDir(), `${id}.json`);
+}
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function createProfile(input) {
+  ensureProfilesDir();
+  const id = shortUuid();
+  const now = new Date().toISOString();
+  const profile = {
+    agent_id: id,
+    agent_type: input.agent_type,
+    created_at: now,
+    last_seen_at: now,
+    preferences: {}
+  };
+  if (input.name) {
+    profile.name = input.name;
+  }
+  writeFileSync4(profilePath(id), JSON.stringify(profile, null, 2) + `
+`);
+  return profile;
+}
+function getProfile(id) {
+  const path = profilePath(id);
+  try {
+    if (!existsSync8(path))
+      return null;
+    return JSON.parse(readFileSync5(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listProfiles() {
+  const dir = getProfilesDir();
+  if (!existsSync8(dir))
+    return [];
+  try {
+    const files = readdirSync4(dir).filter((f) => f.endsWith(".json"));
+    const profiles = [];
+    for (const file of files) {
+      try {
+        const content = readFileSync5(join8(dir, file), "utf-8");
+        profiles.push(JSON.parse(content));
+      } catch {}
+    }
+    return profiles.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+  } catch {
+    return [];
+  }
+}
+
+// src/mcp/server.ts
+init_manifest();
+init_resolve();
+init_redact();
+
+// src/mcp/authority.ts
+init_db();
+init_local_opt_in();
+
+// src/lib/transport.ts
+init_transport();
+init_config();
+init_local_opt_in();
+var localNoticePrinted = false;
+function announceLocal(notice, reason) {
+  if (localNoticePrinted)
+    return;
+  localNoticePrinted = true;
+  const line = `hooks: LOCAL mode \u2014 ${reason}; using the bundled registry and the local store at ` + `${getHooksDataDir()}, not a remote registry. Set HASNA_HOOKS_API_KEY (or the Keychain item ` + `hasna.credentials.hooks.api-key / ~/.hasna/hooks/config/credentials) to go remote.`;
+  if (notice)
+    notice(line);
+  else if (typeof process !== "undefined")
+    process.stderr.write(`${line}
+`);
+}
+function hooksRegistryOrigin(v1BaseUrl) {
+  return v1BaseUrl.replace(/\/+$/, "").replace(/\/v1$/, "");
+}
+function rethrowHooksAuthorityFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const name = error instanceof Error ? error.name : "";
+  if (name === "CredentialResolutionError" || name === "CredentialFileUnsafeError") {
+    throw new Error(`REMOTE_API_CREDENTIAL_INVALID: ${message} There is no local fallback: ` + "local mode is opt-in only (HASNA_HOOKS_LOCAL=1) and is disabled by default \u2014 failing closed", { cause: error });
+  }
+  if (/no API key could be resolved/.test(message)) {
+    if (/is not set and no API key could be resolved/.test(message)) {
+      throw new Error("REMOTE_API_CONFIG_MISSING: no hooks registry credential resolved from the Keychain item " + `hasna.credentials.hooks.api-key, ~/.hasna/hooks/config/credentials, or HASNA_HOOKS_API_KEY. ${message} ` + "There is no local fallback: local mode is opt-in only (HASNA_HOOKS_LOCAL=1, alias HOOKS_LOCAL=1) " + "and is disabled by default \u2014 failing closed instead of serving the local store", { cause: error });
+    }
+    throw new Error("REMOTE_API_KEY_MISSING: the remote hooks registry requires HASNA_HOOKS_API_KEY, the Keychain item " + `hasna.credentials.hooks.api-key, or ~/.hasna/hooks/config/credentials. ${message} ` + "There is no local fallback: local mode is opt-in only (HASNA_HOOKS_LOCAL=1) and is disabled by default \u2014 failing closed", { cause: error });
+  }
+  throw new Error(`REMOTE_API_URL_INVALID: ${message} local mode fallback is disabled`, { cause: error });
+}
+function resolveHooksTransport(env = process.env, options = {}) {
+  if (selectsHooksLocalStore(env)) {
+    announceLocal(options.notice, "HASNA_HOOKS_LOCAL is set and nothing configures a registry authority");
+    return { mode: "local", source: "local-opt-in", authority: null };
+  }
+  const { env: resolverEnv, credentials } = hooksResolverInputs(env, options.credentials);
+  const tier1 = options.credentials?.apiKey;
+  const credentialOptions = tier1 !== undefined ? { ...credentials, apiKey: tier1 } : credentials;
+  let resolution;
+  let credential;
+  try {
+    credential = resolveCredential("hooks", resolverEnv, credentialOptions);
+    resolution = resolveClientTransport("hooks", resolverEnv, {
+      credentials: credential ? { ...credentialOptions, apiKey: credential.apiKey } : credentialOptions
+    });
+  } catch (error) {
+    rethrowHooksAuthorityFailure(error);
+  }
+  if (!credential) {
+    throw new Error("REMOTE_API_CONFIG_MISSING: no hooks registry credential resolved; " + "local mode fallback is disabled");
+  }
+  return {
+    mode: "remote",
+    source: `${credential.source}+${resolution.apiUrlSource ?? "default"}`,
+    authority: {
+      origin: hooksRegistryOrigin(resolution.baseUrl),
+      apiKey: credential.apiKey,
+      apiUrlSource: resolution.apiUrlSource,
+      apiKeySource: credential.source,
+      apiKeyTier: credential.tier,
+      v1BaseUrl: resolution.baseUrl,
+      warning: resolution.warning
+    }
+  };
+}
+
+// src/mcp/authority.ts
+function resolveHooksMcpAuthority(env = process.env) {
+  const transport = resolveHooksTransport(env);
+  if (transport.mode === "local" || !transport.authority) {
+    return { route: "local", source: "local-opt-in" };
+  }
+  return { route: "hosted", v1BaseUrl: transport.authority.v1BaseUrl, source: transport.source };
+}
+function decideHooksMcpAuthority(env = process.env) {
+  const authority = resolveHooksMcpAuthority(env);
+  if (authority.route === "hosted") {
+    refuseLocalStore(hooksHostedRouteLocalStoreRefusal(authority.v1BaseUrl));
+  }
+  return authority;
+}
+
+// src/db/storage-sync.ts
+init_db();
+
+// src/db/pg-migrations.ts
+var PG_MIGRATIONS = [
+  `CREATE TABLE IF NOT EXISTS hook_events (
+    id           TEXT PRIMARY KEY,
+    timestamp    TEXT NOT NULL,
+    session_id   TEXT NOT NULL,
+    hook_name    TEXT NOT NULL,
+    event_type   TEXT NOT NULL CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit', 'SubagentStart')),
+    tool_name    TEXT,
+    tool_input   TEXT,
+    result       TEXT CHECK (result IN ('continue', 'block', NULL)),
+    error        TEXT,
+    duration_ms  INTEGER,
+    project_dir  TEXT,
+    metadata     TEXT
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_timestamp  ON hook_events (timestamp)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_session_id ON hook_events (session_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_hook_name  ON hook_events (hook_name)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_event_type ON hook_events (event_type)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_errors     ON hook_events (timestamp) WHERE error IS NOT NULL`,
+  `CREATE TABLE IF NOT EXISTS schema_migrations (
+    version    TEXT PRIMARY KEY,
+    applied_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS _meta (
+    key   TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS feedback (
+    id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    message TEXT NOT NULL,
+    email TEXT,
+    category TEXT DEFAULT 'general',
+    version TEXT,
+    machine_id TEXT,
+    created_at TEXT NOT NULL DEFAULT NOW()::text
+  )`,
+  `ALTER TABLE hook_events DROP CONSTRAINT IF EXISTS hook_events_event_type_check`,
+  `ALTER TABLE hook_events ADD CONSTRAINT hook_events_event_type_check
+    CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit'))`,
+  `ALTER TABLE hook_events DROP CONSTRAINT IF EXISTS hook_events_event_type_check`,
+  `ALTER TABLE hook_events ADD CONSTRAINT hook_events_event_type_check
+    CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit', 'SubagentStart'))`
+];
+
+// src/db/remote-storage.ts
+import pg from "pg";
+function translatePlaceholders(sql) {
+  let index = 0;
+  return sql.replace(/\?/g, () => `$${++index}`);
+}
+function normalizeParams(params) {
+  const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
+  return flat.map((value) => value === undefined ? null : value);
+}
+function sslConfigFor(connectionString) {
+  const wantsSsl = wantsSslFor(connectionString);
+  if (!wantsSsl)
+    return;
+  const insecure = process.env.HASNA_HOOKS_PG_INSECURE_TLS === "1" || process.env.HOOKS_PG_INSECURE_TLS === "1";
+  if (insecure && false) {}
+  return insecure ? { rejectUnauthorized: false } : { rejectUnauthorized: true };
+}
+function wantsSslFor(connectionString) {
+  let raw;
+  try {
+    raw = new URL(connectionString).search.replace(/^\?/, "");
+  } catch {
+    raw = connectionString;
+  }
+  try {
+    raw = decodeURIComponent(raw);
+  } catch {}
+  const paramValue = (name) => {
+    const match = raw.match(new RegExp(`(?:^|[&\\s])${name}\\s*=\\s*([^&\\s]+)`, "i"));
+    return match ? match[1].toLowerCase() : undefined;
+  };
+  const sslmode = paramValue("sslmode");
+  if (sslmode !== undefined)
+    return sslmode !== "disable" && sslmode !== "allow";
+  const ssl = paramValue("ssl");
+  if (ssl !== undefined)
+    return ssl !== "false" && ssl !== "0" && ssl !== "no";
+  return false;
+}
+
+class PgAdapterAsync {
+  pool;
+  constructor(connectionString) {
+    this.pool = new pg.Pool({ connectionString, ssl: sslConfigFor(connectionString) });
+  }
+  async run(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
+    return { changes: result.rowCount ?? 0 };
+  }
+  async all(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
+    return result.rows;
+  }
+  async close() {
+    await this.pool.end();
+  }
+}
+
+// src/db/storage-sync.ts
+init_redact();
+var STORAGE_TABLES = [
+  "hook_events",
+  "schema_migrations",
+  "_meta",
+  "feedback"
+];
+var STORAGE_BACKENDS = ["sqlite", "postgresql"];
+var HOOKS_STORAGE_ENV = "HASNA_HOOKS_DATABASE_URL";
+var HOOKS_STORAGE_FALLBACK_ENV = "HOOKS_DATABASE_URL";
+var HOOKS_STORAGE_BACKEND_ENV = "HASNA_HOOKS_STORAGE_BACKEND";
+var HOOKS_STORAGE_BACKEND_FALLBACK_ENV = "HOOKS_STORAGE_BACKEND";
+var STORAGE_DATABASE_ENV = [HOOKS_STORAGE_ENV, HOOKS_STORAGE_FALLBACK_ENV];
+var RETIRED_STORAGE_MODE_ENV = ["HASNA_HOOKS_STORAGE_MODE", "HOOKS_STORAGE_MODE"];
+var PRIMARY_KEYS = {
+  hook_events: ["id"],
+  schema_migrations: ["version"],
+  _meta: ["key"],
+  feedback: ["id"]
+};
+function readEnv(name) {
+  const value = process.env[name]?.trim();
+  return value || undefined;
+}
+var RETIRED_MODE_REPLACEMENT = {
+  local: "sqlite",
+  hybrid: "postgresql",
+  remote: "postgresql",
+  self_hosted: "postgresql",
+  "self-hosted": "postgresql",
+  selfhosted: "postgresql",
+  cloud: "postgresql"
+};
+var BACKEND_ALIASES = {
+  sqlite: "sqlite",
+  sqlite3: "sqlite",
+  postgresql: "postgresql",
+  postgres: "postgresql",
+  pg: "postgresql"
+};
+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) {
+    if (readEnv(name))
+      return name;
+  }
+  return null;
+}
+function getStorageDatabaseEnv() {
+  const name = getStorageDatabaseEnvName();
+  return name ? { name } : null;
+}
+function getStorageDatabaseUrl() {
+  const env = getStorageDatabaseEnv();
+  return env ? readEnv(env.name) ?? null : null;
+}
+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();
+  if (!url) {
+    throw new Error("Missing HASNA_HOOKS_DATABASE_URL or HOOKS_DATABASE_URL");
+  }
+  return new PgAdapterAsync(url);
+}
+async function runStorageMigrations(remote) {
+  await remote.run("CREATE EXTENSION IF NOT EXISTS pgcrypto");
+  for (const sql of PG_MIGRATIONS)
+    await remote.run(sql);
+}
+async function storagePush(options) {
+  const remote = await getStoragePg();
+  const db = getDb();
+  try {
+    await runStorageMigrations(remote);
+    const results = [];
+    for (const table of resolveTables(options?.tables)) {
+      results.push(await pushTable(db, remote, table));
+    }
+    recordSyncMeta(db, "push", results);
+    return results;
+  } finally {
+    await remote.close();
+  }
+}
+async function storagePull(options) {
+  const remote = await getStoragePg();
+  const db = getDb();
+  try {
+    await runStorageMigrations(remote);
+    const results = [];
+    for (const table of resolveTables(options?.tables)) {
+      results.push(await pullTable(remote, db, table));
+    }
+    recordSyncMeta(db, "pull", results);
+    return results;
+  } finally {
+    await remote.close();
+  }
+}
+async function storageSync(options) {
+  const pull = await storagePull(options);
+  const push = await storagePush(options);
+  return { pull, push };
+}
+function getSyncMetaAll() {
+  const db = getDb();
+  ensureSyncMetaTable(db);
+  return db.query("SELECT table_name, last_synced_at, direction FROM _hooks_sync_meta ORDER BY table_name, direction").all();
+}
+function getStorageStatus() {
+  const activeEnv = getStorageDatabaseEnv();
+  return {
+    configured: Boolean(activeEnv),
+    backend: getStorageBackend(),
+    env: STORAGE_DATABASE_ENV,
+    activeEnv: activeEnv?.name ?? null,
+    service: "hooks",
+    tables: STORAGE_TABLES,
+    sync: getSyncMetaAll()
+  };
+}
+function resolveTables(tables) {
+  if (!tables || tables.length === 0)
+    return [...STORAGE_TABLES];
+  const allowed = new Set(STORAGE_TABLES);
+  const requested = tables.map((table) => table.trim()).filter(Boolean);
+  const invalid = requested.filter((table) => !allowed.has(table));
+  if (invalid.length > 0)
+    throw new Error(`Unknown hooks sync table(s): ${invalid.join(", ")}`);
+  return requested;
+}
+async function pushTable(db, remote, table) {
+  const result = { table, rowsRead: 0, rowsWritten: 0, errors: [] };
+  try {
+    if (!tableExists(db, table))
+      return result;
+    const rows = db.query(`SELECT * FROM ${quoteIdent(table)}`).all();
+    result.rowsRead = rows.length;
+    if (rows.length === 0)
+      return result;
+    const projected = table === "hook_events" ? rows.map((row) => ({
+      ...row,
+      tool_input: typeof row.tool_input === "string" ? redactEventPayload(row.tool_input) : row.tool_input,
+      error: typeof row.error === "string" ? redactEventPayload(row.error) : row.error,
+      metadata: typeof row.metadata === "string" ? redactEventPayload(row.metadata) : row.metadata
+    })) : rows;
+    const remoteColumns = await getRemoteColumns(remote, table);
+    const columns = filterRemoteColumns(remoteColumns, Object.keys(projected[0]));
+    result.rowsWritten = await upsertPg(remote, table, columns, projected, remoteColumns);
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}
+async function pullTable(remote, db, table) {
+  const result = { table, rowsRead: 0, rowsWritten: 0, errors: [] };
+  try {
+    if (!tableExists(db, table))
+      return result;
+    const rows = await remote.all(`SELECT * FROM ${quoteIdent(table)}`);
+    result.rowsRead = rows.length;
+    if (rows.length === 0)
+      return result;
+    const projected = table === "hook_events" ? rows.map((row) => ({
+      ...row,
+      tool_input: typeof row.tool_input === "string" ? redactEventPayload(row.tool_input) : row.tool_input,
+      error: typeof row.error === "string" ? redactEventPayload(row.error) : row.error,
+      metadata: typeof row.metadata === "string" ? redactEventPayload(row.metadata) : row.metadata
+    })) : rows;
+    const columns = filterLocalColumns(db, table, Object.keys(projected[0]));
+    result.rowsWritten = upsertSqlite(db, table, columns, projected);
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}
+async function getRemoteColumns(remote, table) {
+  const rows = await remote.all("SELECT column_name, data_type FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ?", table);
+  return new Map(rows.map((row) => [row.column_name, row.data_type]));
+}
+function filterRemoteColumns(remoteColumns, columns) {
+  if (remoteColumns.size === 0)
+    return columns;
+  return columns.filter((column) => remoteColumns.has(column));
+}
+function filterLocalColumns(db, table, columns) {
+  const rows = db.query(`PRAGMA table_info(${quoteIdent(table)})`).all();
+  const allowed = new Set(rows.map((row) => row.name));
+  return columns.filter((column) => allowed.has(column));
+}
+async function upsertPg(remote, table, columns, rows, remoteColumns) {
+  if (columns.length === 0)
+    return 0;
+  const primaryKeys = PRIMARY_KEYS[table];
+  const columnList = columns.map(quoteIdent).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const keyList = primaryKeys.map(quoteIdent).join(", ");
+  const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
+  const fallbackKey = primaryKeys[0];
+  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = EXCLUDED.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = EXCLUDED.${quoteIdent(fallbackKey)}`;
+  for (const row of rows) {
+    await remote.run(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders})
+       ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}`, ...columns.map((column) => coerceForPg(row[column], remoteColumns.get(column))));
+  }
+  return rows.length;
+}
+function upsertSqlite(db, table, columns, rows) {
+  if (columns.length === 0)
+    return 0;
+  const primaryKeys = PRIMARY_KEYS[table];
+  const columnList = columns.map(quoteIdent).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const keyList = primaryKeys.map(quoteIdent).join(", ");
+  const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
+  const fallbackKey = primaryKeys[0];
+  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = excluded.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = excluded.${quoteIdent(fallbackKey)}`;
+  const statement = db.query(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders})
+     ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}`);
+  const insert = db.transaction((batch) => {
+    for (const row of batch)
+      statement.run(...columns.map((column) => coerceForSqlite(row[column])));
+  });
+  insert(rows);
+  return rows.length;
+}
+function recordSyncMeta(db, direction, results) {
+  ensureSyncMetaTable(db);
+  const now = new Date().toISOString();
+  const statement = db.query(`
+    INSERT INTO _hooks_sync_meta (table_name, last_synced_at, direction)
+    VALUES (?, ?, ?)
+    ON CONFLICT(table_name, direction) DO UPDATE SET last_synced_at = excluded.last_synced_at
+  `);
+  for (const result of results) {
+    if (result.errors.length > 0)
+      continue;
+    statement.run(result.table, now, direction);
+  }
+}
+function ensureSyncMetaTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _hooks_sync_meta (
+      table_name TEXT NOT NULL,
+      last_synced_at TEXT,
+      direction TEXT NOT NULL CHECK(direction IN ('push', 'pull')),
+      PRIMARY KEY (table_name, direction)
+    )
+  `);
+}
+function tableExists(db, table) {
+  const row = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
+  return Boolean(row);
+}
+function quoteIdent(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function coerceForPg(value, dataType) {
+  if (value === undefined || value === null)
+    return null;
+  if (dataType === "boolean") {
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "number")
+      return value !== 0;
+    if (typeof value === "string")
+      return value === "1" || value.toLowerCase() === "true";
+  }
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array)
+    return value;
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return value;
+}
+function coerceForSqlite(value) {
+  if (value === undefined || value === null)
+    return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean")
+    return value;
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array)
+    return value;
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
+// src/mcp/server.ts
+var __dirname3 = dirname6(fileURLToPath3(import.meta.url));
+var pkg = { name: "@hasna/hooks", version: "0.0.0" };
+try {
+  for (const rel of ["../../package.json", "../package.json", "../../../package.json"]) {
+    const p = join11(__dirname3, rel);
+    if (existsSync10(p)) {
+      pkg = JSON.parse(readFileSync7(p, "utf-8"));
+      break;
+    }
+  }
+} catch {}
+async function runVerifiedHook(name, stdin, timeoutMs) {
+  const { resolveHook: resolveHook2, resolveScriptPath: resolveScriptPath2 } = await Promise.resolve().then(() => (init_resolve(), exports_resolve));
+  const resolved = resolveHook2(name);
+  const hookScript = resolveScriptPath2(name);
+  if (!resolved || !hookScript || !existsSync10(hookScript)) {
+    throw new Error(`Hook '${name}' not found`);
+  }
+  const content = readFileSync7(hookScript);
+  const sha = sha256Of(content);
+  const check = checkScriptHash(name, sha);
+  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, HookTimeoutError: HookTimeoutError2 } = await Promise.resolve().then(() => (init_run(), exports_run));
+  const started = Date.now();
+  let ran;
+  try {
+    ran = await executeVerifiedScript2({ name, scriptPath: hookScript, content, stdin, timeout: timeoutMs });
+  } catch (err) {
+    try {
+      const { recordHookRun: recordHookRun2, resolveEventType: resolveEventType2 } = await Promise.resolve().then(() => (init_db_writer(), exports_db_writer));
+      let inputJson = {};
+      try {
+        inputJson = JSON.parse(stdin);
+      } catch {}
+      recordHookRun2({
+        hookName: name,
+        eventType: resolveEventType2(inputJson.hook_event_name, resolved.events[0] ?? "PostToolUse"),
+        version: resolved.version,
+        sha256: sha,
+        sessionId: typeof inputJson.session_id === "string" ? inputJson.session_id : null,
+        toolName: typeof inputJson.tool_name === "string" ? inputJson.tool_name : null,
+        toolInput: inputJson.tool_input,
+        error: err instanceof Error ? err.message.slice(0, 500) : String(err),
+        exitCode: -1,
+        durationMs: Date.now() - started,
+        projectDir: process.cwd()
+      });
+    } catch {}
+    if (err instanceof HookTimeoutError2)
+      throw err;
+    throw err;
+  }
+  const durationMs = Date.now() - started;
+  try {
+    const { recordHookRun: recordHookRun2, resolveEventType: resolveEventType2 } = await Promise.resolve().then(() => (init_db_writer(), exports_db_writer));
+    let inputJson = {};
+    try {
+      inputJson = JSON.parse(stdin);
+    } catch {}
+    let outputJson = {};
+    try {
+      outputJson = JSON.parse(ran.stdout);
+    } catch {}
+    const blocked = outputJson.decision === "block" || outputJson.continue === false;
+    recordHookRun2({
+      hookName: name,
+      eventType: resolveEventType2(inputJson.hook_event_name, resolved.events[0] ?? "PostToolUse"),
+      version: resolved.version,
+      sha256: sha,
+      sessionId: typeof inputJson.session_id === "string" ? inputJson.session_id : null,
+      toolName: typeof inputJson.tool_name === "string" ? inputJson.tool_name : null,
+      toolInput: inputJson.tool_input,
+      result: blocked ? "block" : "continue",
+      error: ran.exitCode !== 0 ? (ran.stderr || `hook exited with code ${ran.exitCode}`).slice(0, 500) : null,
+      exitCode: ran.exitCode,
+      durationMs,
+      projectDir: process.cwd()
+    });
+  } catch {}
+  return ran;
+}
+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,
+    hint: omitted > 0 ? `Use limit, compact:false, or ${detail} for more detail.` : `Use compact:false or ${detail} for full details.`
+  };
+}
+function compactEvent(row) {
+  return {
+    id: row.id,
+    timestamp: row.timestamp,
+    hook_name: row.hook_name,
+    tool_name: row.tool_name ?? undefined,
+    session_id: row.session_id ? String(row.session_id).slice(0, 12) : undefined,
+    error: row.error ? truncateText(row.error, 180) : undefined,
+    tool_input_preview: row.tool_input ? truncateText(row.tool_input, 180) : undefined
+  };
+}
+function projectLogRows(rows) {
+  return rows.map((row) => projectEventRowForRead({ ...row }));
+}
+var _hooksAgents = new Map;
+function createHooksServer() {
+  const server = new McpServer({
+    name: "@hasna/hooks",
+    version: pkg.version
+  });
+  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: 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) {
+      const cat = CATEGORIES.find((c) => c.toLowerCase() === category.toLowerCase());
+      if (!cat) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: `Unknown category: ${category}`, available: [...CATEGORIES] }) }] };
+      }
+      const hooks = getHooksByCategory(cat);
+      return { content: [{ type: "text", text: JSON.stringify(compact ? compactHookResult(hooks, maxRows, "hooks_info") : hooks) }] };
+    }
+    const result = {};
+    for (const cat of CATEGORIES) {
+      result[cat] = getHooksByCategory(cat);
+    }
+    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: 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: 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` }) }] };
+    }
+    const globalInstalled = getRegisteredHooks("global").includes(meta.name);
+    const projectInstalled = getRegisteredHooks("project").includes(meta.name);
+    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: 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: 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) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: `Unknown category: ${category}`, available: [...CATEGORIES] }) }] };
+    }
+    const hooks = getHooksByCategory(cat).map((h) => h.name);
+    const results = hooks.map((name) => installHook(name, { scope, overwrite }));
+    return formatInstallResults(results, { category: cat, scope });
+  });
+  defineTool("hooks_install_all", "Install all available hooks", {
+    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: 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: z2.enum(["global", "project"]).default("global").describe("Scope to check")
+  }, async ({ scope }) => {
+    const settingsPath = getSettingsPath(scope);
+    const issues = [];
+    const healthy = [];
+    const settingsExist = existsSync10(settingsPath);
+    if (!settingsExist) {
+      issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
+    }
+    const registered = getRegisteredHooks(scope);
+    for (const name of registered) {
+      const custom = readCustomManifest(name);
+      const meta = custom ? resolveHookMeta(name) : getHook(name);
+      let hookHealthy = true;
+      if (custom) {
+        if (!existsSync10(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 (!existsSync10(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(readFileSync7(settingsPath, "utf-8"));
+          if (!hookRegisteredInSettings(settings, name, meta.event, meta.matcher)) {
+            const eventName = meta.event.split(":")[0];
+            issues.push({ hook: name, issue: `Not registered under correct event (${eventName})`, severity: "error" });
+            hookHealthy = false;
+          }
+        } catch {}
+      }
+      if (hookHealthy)
+        healthy.push(name);
+    }
+    for (const overlap of findRewriteOverlaps(registered, (name) => getHook(name))) {
+      issues.push({
+        hook: overlap.hooks.join(" + "),
+        issue: `Both rewrite the tool input on overlapping ${overlap.event} matchers ('${overlap.matchers[0]}' / '${overlap.matchers[1]}'); only one rewrite is applied per tool call, so one of these guards is silently disarmed. Remove one, or narrow a matcher so they no longer overlap.`,
+        severity: "error"
+      });
+    }
+    return { content: [{ type: "text", text: JSON.stringify({ healthy: issues.length === 0, healthy_hooks: healthy, issues, registered, scope }) }] };
+  });
+  defineTool("hooks_categories", "List all hook categories with counts", {}, async () => {
+    const result = CATEGORIES.map((cat) => ({
+      name: cat,
+      count: getHooksByCategory(cat).length
+    }));
+    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: 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);
+      if (!meta) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
+      }
+      const hookPath = getHookPath(name);
+      const readmePath = join11(hookPath, "README.md");
+      let readme = "";
+      if (existsSync10(readmePath)) {
+        readme = readFileSync7(readmePath, "utf-8");
+      }
+      if (verbose) {
+        return { content: [{ type: "text", text: JSON.stringify({ ...meta, readme }) }] };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            ...compactHook(meta),
+            displayName: meta.displayName,
+            version: meta.version,
+            description: truncateText(meta.description, 220),
+            readme_preview: truncateText(readme, 500),
+            readme_lines: readme ? readme.split(`
+`).length : 0,
+            hint: "Call hooks_docs with verbose:true for the full README or hooks_info for metadata."
+          })
+        }]
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          overview: "Hooks are scripts that run at specific points in an AI coding agent session. Install @hasna/hooks globally, then register hooks \u2014 no files are copied to your project.",
+          events: {
+            PreToolUse: "Fires before a tool executes. Can block the operation.",
+            PostToolUse: "Fires after a tool executes. Runs asynchronously.",
+            Stop: "Fires when the agent finishes responding. Useful for notifications.",
+            Notification: "Fires on notification events like context compaction.",
+            SessionStart: "Fires when a session starts or resumes. Can inject context.",
+            SessionEnd: "Fires when a session terminates. Useful for cleanup and final announcements."
+          },
+          commands: {
+            install: "hooks install <name>",
+            installProject: "hooks install <name> --project",
+            installAll: "hooks install --all",
+            remove: "hooks remove <name>",
+            list: "hooks list",
+            search: "hooks search <query>",
+            doctor: "hooks doctor"
+          }
+        })
+      }]
+    };
+  });
+  defineTool("hooks_registered", "Get currently registered hooks for a scope. Compact by default.", {
+    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) => {
+      const meta = getHook(name);
+      return { name, event: meta?.event, matcher: meta?.matcher ?? "", version: meta?.version, description: meta?.description };
+    });
+    if (!compact)
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    const maxRows = boundedLimit(limit, 25, 100);
+    const visible = result.slice(0, maxRows).map((hook) => ({
+      name: hook.name,
+      event: hook.event,
+      matcher: hook.matcher,
+      version: hook.version
+    }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          hooks: visible,
+          count: visible.length,
+          total: result.length,
+          omitted: Math.max(0, result.length - visible.length),
+          hint: "Use compact:false for descriptions or hooks_info for one hook."
+        })
+      }]
+    };
+  });
+  defineTool("hooks_run", "Execute a hook programmatically with the given input and return its output", {
+    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().int().positive().max(600000).optional().describe("Timeout in milliseconds (default: the hook's manifest timeout_ms or 10000)")
+  }, async ({ name, input, profile, timeout_ms }) => {
+    const { resolveHook: resolveHook2 } = await Promise.resolve().then(() => (init_resolve(), exports_resolve));
+    const resolved = resolveHook2(name);
+    if (!resolved) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
+    }
+    const effectiveTimeout = timeout_ms ?? resolved.timeoutMs ?? 1e4;
+    let hookInput = { ...input };
+    if (profile) {
+      const p = getProfile(profile);
+      if (p) {
+        hookInput.agent = {
+          agent_id: p.agent_id,
+          agent_type: p.agent_type,
+          name: p.name,
+          preferences: p.preferences
+        };
+      }
+    }
+    try {
+      const ran = await runVerifiedHook(name, JSON.stringify(hookInput), effectiveTimeout);
+      const stdoutText = ran.stdout;
+      const stderrText = ran.stderr;
+      let output = {};
+      try {
+        output = JSON.parse(stdoutText);
+      } catch {
+        output = stdoutText ? { raw: stdoutText } : {};
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            hook: name,
+            output,
+            stderr: stderrText || undefined,
+            exitCode: ran.exitCode,
+            timeout_ms: effectiveTimeout
+          })
+        }]
+      };
+    } catch (err) {
+      const { HookTimeoutError: HookTimeoutError2 } = await Promise.resolve().then(() => (init_run(), exports_run));
+      if (err instanceof HookTimeoutError2) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ hook: name, timedOut: true, timeout_ms: effectiveTimeout, error: err.message })
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ hook: name, error: err instanceof Error ? err.message : String(err), trust_failed: true })
+        }]
+      };
+    }
+  });
+  defineTool("hooks_update", "Re-register installed hooks to pick up new package version (reinstalls with overwrite)", {
+    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;
+    if (toUpdate.length === 0) {
+      return { content: [{ type: "text", text: JSON.stringify({ updated: [], error: "No hooks installed" }) }] };
+    }
+    const results = toUpdate.map((name) => {
+      if (!installed.includes(name)) {
+        return { hook: name, success: false, error: "Not installed" };
+      }
+      return installHook(name, { scope, overwrite: true });
+    });
+    const updated = 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({ 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: 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);
+    const hooks = registered.map((name) => {
+      const meta = getHook(name);
+      return { name, event: meta?.event, matcher: meta?.matcher ?? "", version: meta?.version };
+    });
+    const issues = [];
+    for (const name of registered) {
+      if (!hookExists(name)) {
+        issues.push({ hook: name, issue: "Hook not found in package", severity: "error" });
+      }
+    }
+    const healthy = issues.length === 0;
+    const ctx = {
+      scope,
+      settings_path: settingsPath,
+      settings_exists: existsSync10(settingsPath),
+      registered_hooks: hooks,
+      hook_count: hooks.length,
+      healthy,
+      issues,
+      version: pkg.version
+    };
+    if (profile) {
+      const p = getProfile(profile);
+      ctx.profile = p && !verbose ? { agent_id: p.agent_id, agent_type: p.agent_type, name: p.name } : p ?? null;
+      if (p && !verbose)
+        ctx.profile_hint = "Use verbose:true for profile preferences.";
+    }
+    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: 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().int().positive().max(600000).optional().describe("Per-hook timeout in milliseconds (default: the hook's manifest timeout_ms or 5000)")
+  }, async ({ tool_name, tool_input, scope, timeout_ms }) => {
+    const registered = getRegisteredHooks(scope);
+    const matchingHooks = registered.filter((name) => {
+      const meta = resolveHookMeta(name) ?? getHook(name);
+      if (!meta || meta.event !== "PreToolUse")
+        return false;
+      if (!meta.matcher)
+        return true;
+      try {
+        return new RegExp(meta.matcher).test(tool_name);
+      } catch {
+        return false;
+      }
+    });
+    if (matchingHooks.length === 0) {
+      return { content: [{ type: "text", text: JSON.stringify({ tool_name, matching_hooks: [], result: "no_hooks_match", decision: "approve" }) }] };
+    }
+    const input = { tool_name, tool_input };
+    const results = await Promise.all(matchingHooks.map(async (name) => {
+      const { resolveHook: resolveHook2 } = await Promise.resolve().then(() => (init_resolve(), exports_resolve));
+      const resolved = resolveHook2(name);
+      const effectiveTimeout = timeout_ms ?? resolved?.timeoutMs ?? 5000;
+      try {
+        const ran = await runVerifiedHook(name, JSON.stringify(input), effectiveTimeout);
+        let output = {};
+        try {
+          output = JSON.parse(ran.stdout);
+        } catch {}
+        return { name, decision: output.decision ?? "approve", reason: output.reason, raw: output };
+      } catch (err) {
+        const { HookTimeoutError: HookTimeoutError2 } = await Promise.resolve().then(() => (init_run(), exports_run));
+        if (err instanceof HookTimeoutError2) {
+          return {
+            name,
+            decision: "block",
+            timedOut: true,
+            timeout_ms: effectiveTimeout,
+            error: `hook timed out after ${effectiveTimeout}ms \u2014 preview blocked (never auto-approved)`
+          };
+        }
+        return { name, decision: "block", error: err instanceof Error ? err.message : String(err) };
+      }
+    }));
+    const blocked = results.find((r) => r.decision === "block");
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          tool_name,
+          matching_hooks: matchingHooks,
+          results,
+          decision: blocked ? "block" : "approve",
+          blocked_by: blocked?.name ?? null,
+          blocked_reason: blocked?.reason ?? null
+        })
+      }]
+    };
+  });
+  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: 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 }) => {
+    if (agent_type !== "claude" && agent_type !== "gemini" && agent_type !== "custom") {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: `unsupported agent_type '${String(agent_type)}' (supported: claude, gemini, custom)` })
+        }],
+        isError: true
+      };
+    }
+    const profile = createProfile({ agent_type, name });
+    const target = agent_type === "gemini" ? "gemini" : "claude";
+    const toInstall = hooks && hooks.length > 0 ? hooks : ["gitguard", "checkpoint", "checktests", "protectfiles"];
+    const results = toInstall.map((h) => installHook(h, { scope, overwrite: false, profile: profile.agent_id, target }));
+    const installed = results.filter((r) => r.success).map((r) => r.hook);
+    const failed = results.filter((r) => !r.success).map((r) => ({ hook: r.hook, error: r.error }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ profile, installed, failed, scope, target, run_with: `hooks run <name> --profile ${profile.agent_id}` })
+      }]
+    };
+  });
+  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: 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: z2.number().int().positive().max(600000).optional().describe("Per-hook timeout in milliseconds (default: the hook's manifest timeout_ms or 10000)")
+  }, async ({ hooks, timeout_ms }) => {
+    const results = await Promise.all(hooks.map(async ({ name, input }) => {
+      const { resolveHook: resolveHook2 } = await Promise.resolve().then(() => (init_resolve(), exports_resolve));
+      const resolved = resolveHook2(name);
+      if (!resolved)
+        return { name, error: `Hook '${name}' not found` };
+      const effectiveTimeout = timeout_ms ?? resolved.timeoutMs ?? 1e4;
+      try {
+        const ran = await runVerifiedHook(name, JSON.stringify(input), effectiveTimeout);
+        const stdoutText = ran.stdout;
+        let output = {};
+        try {
+          output = JSON.parse(stdoutText);
+        } catch {
+          output = stdoutText ? { raw: stdoutText } : {};
+        }
+        return { name, output, exitCode: ran.exitCode, timeout_ms: effectiveTimeout };
+      } catch (err) {
+        const { HookTimeoutError: HookTimeoutError2 } = await Promise.resolve().then(() => (init_run(), exports_run));
+        if (err instanceof HookTimeoutError2) {
+          return { name, error: err.message, timedOut: true, timeout_ms: effectiveTimeout };
+        }
+        return { name, error: err instanceof Error ? err.message : String(err) };
+      }
+    }));
+    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: 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 (existsSync10(settingsPath))
+        settings = JSON.parse(readFileSync7(settingsPath, "utf-8"));
+    } catch {}
+    if (!settings.hooks)
+      settings.hooks = {};
+    const disabled = settings.hooks.__disabled ?? [];
+    if (!disabled.includes(name))
+      disabled.push(name);
+    settings.hooks.__disabled = disabled;
+    const { writeFileSync: writeFileSync6, mkdirSync: mkdirSync6 } = await import("fs");
+    const { dirname: dirname7 } = await import("path");
+    mkdirSync6(dirname7(settingsPath), { recursive: true });
+    writeFileSync6(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: 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 (existsSync10(settingsPath))
+        settings = JSON.parse(readFileSync7(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: writeFileSync6 } = await import("fs");
+      writeFileSync6(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: 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: 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)
+      return { content: [{ type: "text", text: JSON.stringify(profiles) }] };
+    const maxRows = boundedLimit(limit, 25, 100);
+    const visible = profiles.slice(0, maxRows).map((profile) => ({
+      agent_id: profile.agent_id,
+      agent_type: profile.agent_type,
+      name: profile.name,
+      last_seen_at: profile.last_seen_at
+    }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          profiles: visible,
+          count: visible.length,
+          total: profiles.length,
+          omitted: Math.max(0, profiles.length - visible.length),
+          hint: "Use compact:false for full profile preferences."
+        })
+      }]
+    };
+  });
+  defineTool("hooks_log_list", "List hook events from SQLite. Compact summaries by default; set compact:false for full event 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();
+    const maxRows = boundedLimit(limit, compact ? 20 : 50, compact ? 100 : 500);
+    function parseDuration(s) {
+      const m = s.match(/^(\d+)(s|m|h|d)$/);
+      if (!m)
+        return null;
+      const n = parseInt(m[1]);
+      const ms = { s: 1000, m: 60000, h: 3600000, d: 86400000 }[m[2]];
+      return new Date(Date.now() - n * ms).toISOString();
+    }
+    let sql = "SELECT * FROM hook_events WHERE 1=1";
+    const params = [];
+    if (hook_name) {
+      sql += " AND hook_name = ?";
+      params.push(hook_name);
+    }
+    if (session_id) {
+      sql += " AND session_id LIKE ?";
+      params.push(`${session_id}%`);
+    }
+    if (since) {
+      const ts = since.match(/^\d{4}/) ? since : parseDuration(since);
+      if (ts) {
+        sql += " AND timestamp >= ?";
+        params.push(ts);
+      }
+    }
+    sql += " ORDER BY timestamp DESC LIMIT ?";
+    params.push(maxRows);
+    const rows = db.query(sql).all(...params);
+    const projected = projectLogRows(rows);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          events: compact ? projected.map(compactEvent) : projected,
+          count: projected.length,
+          compact,
+          hint: compact ? "Use compact:false for full tool_input/output fields." : undefined
+        })
+      }]
+    };
+  });
+  defineTool("hooks_log_tail", "Show recent hook events from SQLite. Compact summaries by default.", {
+    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();
+    const maxRows = boundedLimit(n, 20, compact ? 100 : 500);
+    const rows = db.query("SELECT * FROM hook_events ORDER BY timestamp DESC LIMIT ?").all(maxRows);
+    const projected = projectLogRows(rows);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          events: compact ? projected.map(compactEvent) : projected,
+          count: projected.length,
+          compact,
+          hint: compact ? "Use compact:false for full tool_input/output fields." : undefined
+        })
+      }]
+    };
+  });
+  defineTool("hooks_log_errors", "Show hook events that contain errors. Compact summaries by default.", {
+    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();
+    const maxRows = boundedLimit(limit, compact ? 20 : 50, compact ? 100 : 500);
+    function parseDuration(s) {
+      const m = s.match(/^(\d+)(s|m|h|d)$/);
+      if (!m)
+        return s;
+      const n = parseInt(m[1]);
+      const ms = { s: 1000, m: 60000, h: 3600000, d: 86400000 }[m[2]];
+      return new Date(Date.now() - n * ms).toISOString();
+    }
+    const ts = since.match(/^\d{4}/) ? since : parseDuration(since);
+    const rows = db.query("SELECT * FROM hook_events WHERE error IS NOT NULL AND timestamp >= ? ORDER BY timestamp DESC LIMIT ?").all(ts, maxRows);
+    const projected = projectLogRows(rows);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          events: compact ? projected.map(compactEvent) : projected,
+          count: projected.length,
+          compact,
+          hint: compact ? "Use compact:false for full tool_input/output fields." : undefined
+        })
+      }]
+    };
+  });
+  defineTool("hooks_log_summary", "Summarize hook execution: counts per hook, error rates, and recent activity.", {
+    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();
+    function parseDuration(s) {
+      const m = s.match(/^(\d+)(s|m|h|d)$/);
+      if (!m)
+        return s;
+      const n = parseInt(m[1]);
+      const ms = { s: 1000, m: 60000, h: 3600000, d: 86400000 }[m[2]];
+      return new Date(Date.now() - n * ms).toISOString();
+    }
+    const ts = since.match(/^\d{4}/) ? since : parseDuration(since);
+    const totals = db.query("SELECT hook_name, COUNT(*) as total, SUM(CASE WHEN error IS NOT NULL THEN 1 ELSE 0 END) as errors FROM hook_events WHERE timestamp >= ? GROUP BY hook_name ORDER BY total DESC").all(ts);
+    const summary = totals.map((r) => ({
+      hook_name: r.hook_name,
+      total: r.total,
+      errors: r.errors,
+      error_rate: r.total > 0 ? (r.errors / r.total * 100).toFixed(1) + "%" : "0%"
+    }));
+    const grandTotal = totals.reduce((s, r) => s + r.total, 0);
+    const grandErrors = totals.reduce((s, r) => s + r.errors, 0);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          since: ts,
+          hooks: summary,
+          totals: { events: grandTotal, errors: grandErrors, hooks_active: totals.length }
+        })
+      }]
+    };
+  });
+  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: 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: 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));
+      const db = getDb2();
+      db.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", [
+        params.message,
+        params.email || null,
+        params.category || "general",
+        pkg.version
+      ]);
+      return { content: [{ type: "text", text: "Feedback saved. Thank you!" }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: String(e) }], isError: true };
+    }
+  });
+  defineTool("register_agent", "Register an agent session. Returns agent_id. Auto-triggers a heartbeat.", {
+    name: z2.string(),
+    session_id: z2.string().optional()
+  }, async (params) => {
+    const existing = [..._hooksAgents.values()].find((a) => a.name === params.name);
+    if (existing) {
+      existing.last_seen_at = new Date().toISOString();
+      if (params.session_id)
+        existing.session_id = params.session_id;
+      return { content: [{ type: "text", text: JSON.stringify(existing) }] };
+    }
+    const id = Math.random().toString(36).slice(2, 10);
+    const ag = { id, name: params.name, session_id: params.session_id, last_seen_at: new Date().toISOString() };
+    _hooksAgents.set(id, ag);
+    return { content: [{ type: "text", text: JSON.stringify(ag) }] };
+  });
+  defineTool("heartbeat", "Update last_seen_at to signal agent is active.", {
+    agent_id: z2.string()
+  }, async (params) => {
+    const ag = _hooksAgents.get(params.agent_id);
+    if (!ag)
+      return { content: [{ type: "text", text: `Agent not found: ${params.agent_id}` }], isError: true };
+    ag.last_seen_at = new Date().toISOString();
+    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: z2.string(),
+    project_id: z2.string().optional()
+  }, async (params) => {
+    const ag = _hooksAgents.get(params.agent_id);
+    if (!ag)
+      return { content: [{ type: "text", text: `Agent not found: ${params.agent_id}` }], isError: true };
+    ag.project_id = params.project_id;
+    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: 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)
+      return { content: [{ type: "text", text: JSON.stringify(agents) }] };
+    const maxRows = boundedLimit(limit, 25, 100);
+    const visible = agents.slice(0, maxRows).map((agent) => ({
+      id: agent.id,
+      name: agent.name,
+      project_id: agent.project_id,
+      last_seen_at: agent.last_seen_at
+    }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          agents: visible,
+          count: visible.length,
+          total: agents.length,
+          omitted: Math.max(0, agents.length - visible.length),
+          hint: "Use compact:false for session_id and full records."
+        })
+      }]
+    };
+  });
+  return server;
+}
+async function startStdioServer() {
+  try {
+    decideHooksMcpAuthority();
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  }
+  try {
+    const server = createHooksServer();
+    const transport = new StdioServerTransport;
+    await server.connect(transport);
+  } catch (err) {
+    process.stderr.write(`[hooks-mcp] Failed to start: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  }
+}
+
+// src/mcp/hooks-mcp.ts
+await startStdioServer();