@hasna/hooks 0.2.5 → 0.2.7

package/bin/index.js

@@ -2147,7 +2147,7 @@ var init_registry = __esm(() => {
     {
       name: "sessionlog",
       displayName: "Session Log",
-      description: "Logs every tool call to .claude/session-log-<date>.jsonl",
+      description: "Logs every tool call to SQLite (~/.hooks/hooks.db)",
       version: "0.1.0",
       category: "Observability",
       event: "PostToolUse",
@@ -2157,7 +2157,7 @@ var init_registry = __esm(() => {
     {
       name: "commandlog",
       displayName: "Command Log",
-      description: "Logs every bash command Claude runs to .claude/commands.log",
+      description: "Logs every Bash command to SQLite (~/.hooks/hooks.db)",
       version: "0.1.0",
       category: "Observability",
       event: "PostToolUse",
@@ -2167,7 +2167,7 @@ var init_registry = __esm(() => {
     {
       name: "costwatch",
       displayName: "Cost Watch",
-      description: "Estimates session token usage and warns when budget threshold is exceeded",
+      description: "Estimates session token usage, persists cost history to SQLite, and warns on budget overrun",
       version: "0.1.0",
       category: "Observability",
       event: "Stop",
@@ -2177,7 +2177,7 @@ var init_registry = __esm(() => {
     {
       name: "errornotify",
       displayName: "Error Notify",
-      description: "Detects tool failures and logs errors to .claude/errors.log",
+      description: "Detects tool failures and logs errors to SQLite (~/.hooks/hooks.db)",
       version: "0.1.0",
       category: "Observability",
       event: "PostToolUse",
@@ -4152,6 +4152,264 @@ var init_profiles = __esm(() => {
   PROFILES_DIR = join2(homedir2(), ".hooks", "profiles");
 });
 
+// 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')),
+    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/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();
+  MIGRATIONS = [{ version: "001_initial", up }];
+});
+
+// src/db/legacy-import.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } 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 = readFileSync3(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 = readFileSync3(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) {
+  try {
+    if (isAlreadyDone(db))
+      return;
+    let total = 0;
+    const claudeProjectsDir = join3(homedir3(), ".claude", "projects");
+    if (existsSync3(claudeProjectsDir)) {
+      try {
+        const projectDirs = readdirSync2(claudeProjectsDir);
+        for (const dir of projectDirs) {
+          const projectDir = join3(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, join3(projectDir, file));
+              }
+              if (file === "errors.log") {
+                total += importErrorsLog(db, join3(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, {
+  getDbPath: () => getDbPath,
+  getDb: () => getDb,
+  createTestDb: () => createTestDb,
+  closeDb: () => closeDb
+});
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+function getDbPath() {
+  if (process.env.HOOKS_DB_PATH) {
+    return process.env.HOOKS_DB_PATH;
+  }
+  const dataDir = process.env.HOOKS_DATA_DIR ?? join4(homedir4(), ".hooks");
+  return join4(dataDir, "hooks.db");
+}
+function ensureDir(dbPath) {
+  const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+  if (dir && !existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+}
+function getDb() {
+  if (instance)
+    return instance;
+  const dbPath = getDbPath();
+  const isNew = dbPath === ":memory:" || !existsSync4(dbPath);
+  ensureDir(dbPath);
+  instance = new Database(dbPath);
+  instance.exec("PRAGMA journal_mode=WAL");
+  instance.exec("PRAGMA foreign_keys=ON");
+  runMigrations(instance);
+  runRetention(instance);
+  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;
+var init_db = __esm(() => {
+  init_migrations();
+  init_legacy_import();
+});
+
 // src/mcp/server.ts
 var exports_server = {};
 __export(exports_server, {
@@ -4165,8 +4423,8 @@ import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { createServer } from "http";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function formatInstallResults(results, extra) {
   const installed = results.filter((r) => r.success).map((r) => r.hook);
@@ -4183,13 +4441,20 @@ function createHooksServer() {
     name: "@hasna/hooks",
     version: pkg.version
   });
-  server.tool("hooks_list", "List all available hooks, optionally filtered by category", { category: z.string().optional().describe("Filter by category name (e.g. 'Git Safety', 'Code Quality', 'Security', 'Notifications', 'Context Management')") }, async ({ category }) => {
+  server.tool("hooks_list", "List all available hooks, optionally filtered by category. Use compact:true to get minimal output (name+event+matcher only) \u2014 saves tokens.", {
+    category: z.string().optional().describe("Filter by category name (e.g. 'Git Safety', 'Code Quality', 'Security')"),
+    compact: z.boolean().default(false).describe("Return minimal fields only: name, event, matcher. Reduces token usage.")
+  }, async ({ category, compact }) => {
+    const slim = (hooks) => compact ? hooks.map((h) => ({ name: h.name, event: h.event, matcher: h.matcher })) : hooks;
     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] }) }] };
       }
-      return { content: [{ type: "text", text: JSON.stringify(getHooksByCategory(cat)) }] };
+      return { content: [{ type: "text", text: JSON.stringify(slim(getHooksByCategory(cat))) }] };
+    }
+    if (compact) {
+      return { content: [{ type: "text", text: JSON.stringify(slim(HOOKS)) }] };
     }
     const result = {};
     for (const cat of CATEGORIES) {
@@ -4197,9 +4462,13 @@ function createHooksServer() {
     }
     return { content: [{ type: "text", text: JSON.stringify(result) }] };
   });
-  server.tool("hooks_search", "Search for hooks by name, description, or tags", { query: z.string().describe("Search query") }, async ({ query }) => {
+  server.tool("hooks_search", "Search for hooks by name, description, or tags. Use compact:true for minimal output to save tokens.", {
+    query: z.string().describe("Search query"),
+    compact: z.boolean().default(false).describe("Return minimal fields only: name, event, matcher.")
+  }, async ({ query, compact }) => {
     const results = searchHooks(query);
-    return { content: [{ type: "text", text: JSON.stringify(results) }] };
+    const out = compact ? results.map((h) => ({ name: h.name, event: h.event, matcher: h.matcher })) : results;
+    return { content: [{ type: "text", text: JSON.stringify(out) }] };
   });
   server.tool("hooks_info", "Get detailed information about a specific hook including install status", { name: z.string().describe("Hook name (e.g. 'gitguard', 'checkpoint')") }, async ({ name }) => {
     const meta = getHook(name);
@@ -4252,7 +4521,7 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     const issues = [];
     const healthy = [];
-    const settingsExist = existsSync3(settingsPath);
+    const settingsExist = existsSync5(settingsPath);
     if (!settingsExist) {
       issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
     }
@@ -4265,13 +4534,13 @@ function createHooksServer() {
         continue;
       }
       const hookDir = getHookPath(name);
-      if (!existsSync3(join3(hookDir, "src", "hook.ts"))) {
+      if (!existsSync5(join5(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(readFileSync3(settingsPath, "utf-8"));
+          const settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
           const eventHooks = settings.hooks?.[meta.event] || [];
           const found = eventHooks.some((entry) => entry.hooks?.some((h) => {
             const match = h.command?.match(/^hooks run (\w+)/);
@@ -4286,7 +4555,7 @@ function createHooksServer() {
       if (hookHealthy)
         healthy.push(name);
     }
-    return { content: [{ type: "text", text: JSON.stringify({ healthy, issues, registered, scope }) }] };
+    return { content: [{ type: "text", text: JSON.stringify({ healthy: issues.length === 0, healthy_hooks: healthy, issues, registered, scope }) }] };
   });
   server.tool("hooks_categories", "List all hook categories with counts", {}, async () => {
     const result = CATEGORIES.map((cat) => ({
@@ -4302,10 +4571,10 @@ function createHooksServer() {
         return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
       }
       const hookPath = getHookPath(name);
-      const readmePath = join3(hookPath, "README.md");
+      const readmePath = join5(hookPath, "README.md");
       let readme = "";
-      if (existsSync3(readmePath)) {
-        readme = readFileSync3(readmePath, "utf-8");
+      if (existsSync5(readmePath)) {
+        readme = readFileSync4(readmePath, "utf-8");
       }
       return { content: [{ type: "text", text: JSON.stringify({ ...meta, readme }) }] };
     }
@@ -4339,7 +4608,7 @@ function createHooksServer() {
     const registered = getRegisteredHooks(scope);
     const result = registered.map((name) => {
       const meta = getHook(name);
-      return { name, event: meta?.event, version: meta?.version, description: meta?.description };
+      return { name, event: meta?.event, matcher: meta?.matcher ?? "", version: meta?.version, description: meta?.description };
     });
     return { content: [{ type: "text", text: JSON.stringify(result) }] };
   });
@@ -4354,8 +4623,8 @@ function createHooksServer() {
       return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
     }
     const hookDir = getHookPath(name);
-    const hookScript = join3(hookDir, "src", "hook.ts");
-    if (!existsSync3(hookScript)) {
+    const hookScript = join5(hookDir, "src", "hook.ts");
+    if (!existsSync5(hookScript)) {
       return { content: [{ type: "text", text: JSON.stringify({ error: `Hook script not found: ${hookScript}` }) }] };
     }
     let hookInput = { ...input };
@@ -4426,6 +4695,203 @@ function createHooksServer() {
     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 }) }] };
   });
+  server.tool("hooks_context", "Get full agent context in one call: installed hooks (with event+matcher), active profile, settings path, and doctor status. Call this once at session start instead of making 4 separate calls.", {
+    scope: z.enum(["global", "project"]).default("global").describe("Scope to inspect"),
+    profile: z.string().optional().describe("Agent profile ID to include in context")
+  }, async ({ scope, profile }) => {
+    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: existsSync5(settingsPath),
+      registered_hooks: hooks,
+      hook_count: hooks.length,
+      healthy,
+      issues,
+      version: pkg.version
+    };
+    if (profile) {
+      const p = getProfile(profile);
+      ctx.profile = p ?? null;
+    }
+    return { content: [{ type: "text", text: JSON.stringify(ctx) }] };
+  });
+  server.tool("hooks_preview", "Simulate which installed PreToolUse hooks would fire for a given tool call and what decision each returns. Use this to understand your hook environment before taking an action.", {
+    tool_name: z.string().describe("Tool name to simulate (e.g. 'Bash', 'Write', 'Edit')"),
+    tool_input: z.record(z.string(), z.unknown()).default(() => ({})).describe("Tool input to pass to matching hooks"),
+    scope: z.enum(["global", "project"]).default("global").describe("Scope to check"),
+    timeout_ms: z.number().default(5000).describe("Per-hook timeout in milliseconds")
+  }, async ({ tool_name, tool_input, scope, timeout_ms }) => {
+    const registered = getRegisteredHooks(scope);
+    const matchingHooks = registered.filter((name) => {
+      const meta = 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 hookDir = getHookPath(name);
+      const hookScript = join5(hookDir, "src", "hook.ts");
+      if (!existsSync5(hookScript))
+        return { name, decision: "approve", error: "script not found" };
+      const proc = Bun.spawn(["bun", "run", hookScript], {
+        stdin: new Response(JSON.stringify(input)),
+        stdout: "pipe",
+        stderr: "pipe",
+        env: process.env
+      });
+      const timeout = new Promise((r) => setTimeout(() => r(null), timeout_ms));
+      const res = await Promise.race([
+        Promise.all([new Response(proc.stdout).text(), proc.exited]).then(([stdout]) => ({ stdout, timedOut: false })),
+        timeout.then(() => {
+          proc.kill();
+          return { stdout: "", timedOut: true };
+        })
+      ]);
+      if (res.timedOut)
+        return { name, decision: "approve", timedOut: true };
+      let output = {};
+      try {
+        output = JSON.parse(res.stdout);
+      } catch {}
+      return { name, decision: output.decision ?? "approve", reason: output.reason, raw: output };
+    }));
+    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
+        })
+      }]
+    };
+  });
+  server.tool("hooks_setup", "Single-shot agent onboarding: create an agent profile + install recommended hooks in one call. Ideal for agents setting up hooks at session start.", {
+    agent_type: z.enum(["claude", "gemini", "custom"]).default("claude").describe("Type of AI agent"),
+    name: z.string().optional().describe("Optional display name for the agent"),
+    hooks: z.array(z.string()).optional().describe("Hook names to install (omit for sensible defaults: gitguard, checkpoint, checktests, protectfiles)"),
+    scope: z.enum(["global", "project"]).default("global").describe("Install scope")
+  }, async ({ agent_type, name, hooks, scope }) => {
+    const profile = createProfile({ agent_type, name });
+    const toInstall = hooks && hooks.length > 0 ? hooks : ["gitguard", "checkpoint", "checktests", "protectfiles"];
+    const results = toInstall.map((h) => installHook(h, { scope, overwrite: false, profile: profile.agent_id }));
+    const installed = results.filter((r) => r.success).map((r) => r.hook);
+    const failed = results.filter((r) => !r.success).map((r) => ({ hook: r.hook, error: r.error }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ profile, installed, failed, scope, run_with: `hooks run <name> --profile ${profile.agent_id}` })
+      }]
+    };
+  });
+  server.tool("hooks_batch_run", "Run multiple hooks in parallel in a single call. Returns all results at once \u2014 more efficient than N separate hooks_run calls.", {
+    hooks: z.array(z.object({
+      name: z.string().describe("Hook name"),
+      input: z.record(z.string(), z.unknown()).default(() => ({})).describe("Hook input JSON")
+    })).describe("List of hooks to run with their inputs"),
+    timeout_ms: z.number().default(1e4).describe("Per-hook timeout in milliseconds")
+  }, async ({ hooks, timeout_ms }) => {
+    const results = await Promise.all(hooks.map(async ({ name, input }) => {
+      const meta = getHook(name);
+      if (!meta)
+        return { name, error: `Hook '${name}' not found` };
+      const hookScript = join5(getHookPath(name), "src", "hook.ts");
+      if (!existsSync5(hookScript))
+        return { name, error: "script not found" };
+      const proc = Bun.spawn(["bun", "run", hookScript], {
+        stdin: new Response(JSON.stringify(input)),
+        stdout: "pipe",
+        stderr: "pipe",
+        env: process.env
+      });
+      const timeout = new Promise((r) => setTimeout(() => r(null), timeout_ms));
+      const res = await Promise.race([
+        Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]).then(([stdout, stderr, exitCode]) => ({ stdout, stderr, exitCode, timedOut: false })),
+        timeout.then(() => {
+          proc.kill();
+          return { stdout: "", stderr: "", exitCode: -1, timedOut: true };
+        })
+      ]);
+      let output = {};
+      try {
+        output = JSON.parse(res.stdout);
+      } catch {
+        output = res.stdout ? { raw: res.stdout } : {};
+      }
+      return { name, output, exitCode: res.exitCode, ...res.timedOut ? { timedOut: true } : {} };
+    }));
+    return { content: [{ type: "text", text: JSON.stringify({ results, count: results.length }) }] };
+  });
+  server.tool("hooks_disable", "Temporarily disable a registered hook without removing it. Stores disabled list in settings under hooks.__disabled.", {
+    name: z.string().describe("Hook name to disable"),
+    scope: z.enum(["global", "project"]).default("global").describe("Scope")
+  }, async ({ name, scope }) => {
+    const settingsPath = getSettingsPath(scope);
+    let settings = {};
+    try {
+      if (existsSync5(settingsPath))
+        settings = JSON.parse(readFileSync4(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: writeFileSync3, mkdirSync: mkdirSync4 } = await import("fs");
+    const { dirname: dirname3 } = await import("path");
+    mkdirSync4(dirname3(settingsPath), { recursive: true });
+    writeFileSync3(settingsPath, JSON.stringify(settings, null, 2) + `
+`);
+    return { content: [{ type: "text", text: JSON.stringify({ hook: name, disabled: true, scope }) }] };
+  });
+  server.tool("hooks_enable", "Re-enable a previously disabled hook.", {
+    name: z.string().describe("Hook name to enable"),
+    scope: z.enum(["global", "project"]).default("global").describe("Scope")
+  }, async ({ name, scope }) => {
+    const settingsPath = getSettingsPath(scope);
+    let settings = {};
+    try {
+      if (existsSync5(settingsPath))
+        settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    } catch {}
+    if (settings.hooks?.__disabled) {
+      settings.hooks.__disabled = settings.hooks.__disabled.filter((n) => n !== name);
+      if (settings.hooks.__disabled.length === 0)
+        delete settings.hooks.__disabled;
+      const { writeFileSync: writeFileSync3 } = await import("fs");
+      writeFileSync3(settingsPath, JSON.stringify(settings, null, 2) + `
+`);
+    }
+    return { content: [{ type: "text", text: JSON.stringify({ hook: name, disabled: false, scope }) }] };
+  });
   server.tool("hooks_init", "Register a new agent profile \u2014 returns a unique agent_id for use with hook installation and execution", {
     agent_type: z.enum(["claude", "gemini", "custom"]).default("claude").describe("Type of AI agent"),
     name: z.string().optional().describe("Optional display name for the agent")
@@ -4437,6 +4903,104 @@ function createHooksServer() {
     const profiles = listProfiles();
     return { content: [{ type: "text", text: JSON.stringify(profiles) }] };
   });
+  server.tool("hooks_log_list", "List hook events from SQLite (~/.hooks/hooks.db). Filter by hook name, session ID, or time range.", {
+    hook_name: z.string().optional().describe("Filter by hook name (e.g. 'sessionlog', 'costwatch')"),
+    session_id: z.string().optional().describe("Filter by session ID prefix"),
+    limit: z.number().default(50).describe("Max number of events to return"),
+    since: z.string().optional().describe("ISO timestamp or duration string (e.g. '1h', '30m', '7d') to filter from")
+  }, async ({ hook_name, session_id, limit, 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 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(limit);
+    const rows = db.query(sql).all(...params);
+    return { content: [{ type: "text", text: JSON.stringify({ events: rows, count: rows.length }) }] };
+  });
+  server.tool("hooks_log_tail", "Show the most recent hook events from SQLite.", {
+    n: z.number().default(20).describe("Number of most recent events to return")
+  }, async ({ n }) => {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+    const db = getDb2();
+    const rows = db.query("SELECT * FROM hook_events ORDER BY timestamp DESC LIMIT ?").all(n);
+    return { content: [{ type: "text", text: JSON.stringify({ events: rows, count: rows.length }) }] };
+  });
+  server.tool("hooks_log_errors", "Show hook events that contain errors, optionally filtered by time range.", {
+    since: z.string().default("24h").describe("Duration string (e.g. '1h', '30m', '7d') or ISO timestamp"),
+    limit: z.number().default(50).describe("Max number of error events to return")
+  }, async ({ since, limit }) => {
+    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 rows = db.query("SELECT * FROM hook_events WHERE error IS NOT NULL AND timestamp >= ? ORDER BY timestamp DESC LIMIT ?").all(ts, limit);
+    return { content: [{ type: "text", text: JSON.stringify({ events: rows, count: rows.length }) }] };
+  });
+  server.tool("hooks_log_summary", "Summarize hook execution: counts per hook, error rates, and recent activity.", {
+    since: z.string().default("24h").describe("Duration string (e.g. '1h', '24h', '7d') or ISO timestamp")
+  }, 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 }
+        })
+      }]
+    };
+  });
   return server;
 }
 async function startSSEServer(port = MCP_PORT) {
@@ -4482,7 +5046,7 @@ var init_server = __esm(() => {
   init_installer();
   init_profiles();
   __dirname3 = dirname2(fileURLToPath2(import.meta.url));
-  pkg = JSON.parse(readFileSync3(join3(__dirname3, "..", "..", "package.json"), "utf-8"));
+  pkg = JSON.parse(readFileSync4(join5(__dirname3, "..", "..", "package.json"), "utf-8"));
 });
 
 // src/cli/index.tsx
@@ -4506,8 +5070,8 @@ var {
 
 // src/cli/index.tsx
 import chalk2 from "chalk";
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join4, dirname as dirname3 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cli/components/App.tsx
@@ -5685,8 +6249,8 @@ init_installer();
 init_profiles();
 import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
 var __dirname4 = dirname3(fileURLToPath3(import.meta.url));
-var pkgPath = existsSync4(join4(__dirname4, "..", "package.json")) ? join4(__dirname4, "..", "package.json") : join4(__dirname4, "..", "..", "package.json");
-var pkg2 = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+var pkgPath = existsSync6(join6(__dirname4, "..", "package.json")) ? join6(__dirname4, "..", "package.json") : join6(__dirname4, "..", "..", "package.json");
+var pkg2 = JSON.parse(readFileSync5(pkgPath, "utf-8"));
 var program2 = new Command;
 function resolveScope(options) {
   if (options.project)
@@ -5756,8 +6320,8 @@ program2.command("run").argument("<hook>", "Hook to run").option("--profile <id>
     process.exit(1);
   }
   const hookDir = getHookPath(hook);
-  const hookScript = join4(hookDir, "src", "hook.ts");
-  if (!existsSync4(hookScript)) {
+  const hookScript = join6(hookDir, "src", "hook.ts");
+  if (!existsSync6(hookScript)) {
     console.error(JSON.stringify({ error: `Hook script not found: ${hookScript}` }));
     process.exit(1);
   }
@@ -6057,7 +6621,7 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
   const settingsPath = getSettingsPath(scope);
   const issues = [];
   const healthy = [];
-  const settingsExist = existsSync4(settingsPath);
+  const settingsExist = existsSync6(settingsPath);
   if (!settingsExist) {
     issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
   }
@@ -6071,14 +6635,14 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
       continue;
     }
     const hookDir = getHookPath(name);
-    const hookScript = join4(hookDir, "src", "hook.ts");
-    if (!existsSync4(hookScript)) {
+    const hookScript = join6(hookDir, "src", "hook.ts");
+    if (!existsSync6(hookScript)) {
       issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
       hookHealthy = false;
     }
     if (meta && settingsExist) {
       try {
-        const settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+        const settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
         const eventHooks = settings.hooks?.[meta.event] || [];
         const found = eventHooks.some((entry) => entry.hooks?.some((h) => {
           const match = h.command?.match(/^hooks run (\w+)/);
@@ -6095,7 +6659,7 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
     }
   }
   if (options.json) {
-    console.log(JSON.stringify({ healthy, issues, registered, scope }));
+    console.log(JSON.stringify({ healthy: issues.length === 0, healthy_hooks: healthy, issues, registered, scope }));
     return;
   }
   console.log(chalk2.bold(`
@@ -6176,10 +6740,10 @@ program2.command("docs").argument("[hook]", "Hook name (shows general docs if om
       return;
     }
     const hookPath = getHookPath(hook);
-    const readmePath = join4(hookPath, "README.md");
+    const readmePath = join6(hookPath, "README.md");
     let readme = "";
-    if (existsSync4(readmePath)) {
-      readme = readFileSync4(readmePath, "utf-8");
+    if (existsSync6(readmePath)) {
+      readme = readFileSync5(readmePath, "utf-8");
     }
     if (options.json) {
       console.log(JSON.stringify({ ...meta, readme }));
@@ -6361,9 +6925,9 @@ program2.command("profile-import").argument("<file>", "JSON file to import profi
   if (file === "-") {
     raw = await new Response(Bun.stdin.stream()).text();
   } else {
-    const { readFileSync: readFileSync5 } = await import("fs");
+    const { readFileSync: readFileSync6 } = await import("fs");
     try {
-      raw = readFileSync5(file, "utf-8");
+      raw = readFileSync6(file, "utf-8");
     } catch {
       if (options.json) {
         console.log(JSON.stringify({ error: `Cannot read file: ${file}` }));
@@ -6394,6 +6958,154 @@ program2.command("profile-import").argument("<file>", "JSON file to import profi
       console.log(chalk2.dim(`  Skipped ${result.skipped} (already exist or invalid)`));
   }
 });
+var logCmd = program2.command("log").description("Query hook event logs from SQLite (~/.hooks/hooks.db)");
+logCmd.command("list").description("List hook events").option("--hook <name>", "Filter by hook name").option("--session <id>", "Filter by session ID").option("-n, --limit <n>", "Number of rows to show", "50").option("-j, --json", "Output as JSON", false).action(async (options) => {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDb2();
+  const limit = parseInt(options.limit) || 50;
+  let sql = "SELECT * FROM hook_events WHERE 1=1";
+  const params = [];
+  if (options.hook) {
+    sql += " AND hook_name = ?";
+    params.push(options.hook);
+  }
+  if (options.session) {
+    sql += " AND session_id LIKE ?";
+    params.push(`${options.session}%`);
+  }
+  sql += " ORDER BY timestamp DESC LIMIT ?";
+  params.push(String(limit));
+  const rows = db.query(sql).all(...params);
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(chalk2.dim("No events found."));
+    return;
+  }
+  console.log(chalk2.bold(`
+  Hook Events (${rows.length})
+`));
+  for (const row of rows) {
+    const ts = row.timestamp.slice(0, 19).replace("T", " ");
+    const err = row.error ? chalk2.red(` ERR: ${row.error.slice(0, 60)}`) : "";
+    const tool = row.tool_name ? chalk2.dim(` [${row.tool_name}]`) : "";
+    console.log(`  ${chalk2.dim(ts)}  ${chalk2.cyan(row.hook_name.padEnd(14))}${tool}${err}`);
+  }
+  console.log();
+});
+logCmd.command("search <text>").description("Search hook events by tool_input or error text").option("-n, --limit <n>", "Number of rows to show", "50").option("-j, --json", "Output as JSON", false).action(async (text, options) => {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDb2();
+  const limit = parseInt(options.limit) || 50;
+  const q = `%${text}%`;
+  const rows = db.query("SELECT * FROM hook_events WHERE tool_input LIKE ? OR error LIKE ? ORDER BY timestamp DESC LIMIT ?").all(q, q, limit);
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(chalk2.dim(`No events matching "${text}".`));
+    return;
+  }
+  console.log(chalk2.bold(`
+  Search results for "${text}" (${rows.length})
+`));
+  for (const row of rows) {
+    const ts = row.timestamp.slice(0, 19).replace("T", " ");
+    const snippet = (row.tool_input || row.error || "").slice(0, 80);
+    console.log(`  ${chalk2.dim(ts)}  ${chalk2.cyan(row.hook_name.padEnd(14))}  ${chalk2.dim(snippet)}`);
+  }
+  console.log();
+});
+logCmd.command("tail").description("Show most recent hook events").option("-n <n>", "Number of rows", "20").option("-j, --json", "Output as JSON", false).action(async (options) => {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDb2();
+  const limit = parseInt(options.n) || 20;
+  const rows = db.query("SELECT * FROM hook_events ORDER BY timestamp DESC LIMIT ?").all(limit);
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(chalk2.dim("No events yet."));
+    return;
+  }
+  console.log(chalk2.bold(`
+  Last ${rows.length} events
+`));
+  for (const row of rows) {
+    const ts = row.timestamp.slice(0, 19).replace("T", " ");
+    const err = row.error ? chalk2.red(` \u2717 ${row.error.slice(0, 60)}`) : "";
+    const tool = row.tool_name ? chalk2.dim(` [${row.tool_name}]`) : "";
+    console.log(`  ${chalk2.dim(ts)}  ${chalk2.cyan(row.hook_name.padEnd(14))}${tool}${err}`);
+  }
+  console.log();
+});
+logCmd.command("errors").description("Show hook events that contain errors").option("--since <duration>", "Only show errors since this duration (e.g. 1h, 30m, 7d)", "24h").option("-n, --limit <n>", "Number of rows to show", "50").option("-j, --json", "Output as JSON", false).action(async (options) => {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDb2();
+  const limit = parseInt(options.limit) || 50;
+  function parseDuration(s) {
+    const m = s.match(/^(\d+)(s|m|h|d)$/);
+    if (!m)
+      return 86400000;
+    const n = parseInt(m[1]);
+    switch (m[2]) {
+      case "s":
+        return n * 1000;
+      case "m":
+        return n * 60 * 1000;
+      case "h":
+        return n * 60 * 60 * 1000;
+      case "d":
+        return n * 24 * 60 * 60 * 1000;
+      default:
+        return 86400000;
+    }
+  }
+  const since = new Date(Date.now() - parseDuration(options.since)).toISOString();
+  const rows = db.query("SELECT * FROM hook_events WHERE error IS NOT NULL AND timestamp >= ? ORDER BY timestamp DESC LIMIT ?").all(since, limit);
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(chalk2.dim(`No errors in the last ${options.since}.`));
+    return;
+  }
+  console.log(chalk2.bold(`
+  Errors (last ${options.since}, ${rows.length} found)
+`));
+  for (const row of rows) {
+    const ts = row.timestamp.slice(0, 19).replace("T", " ");
+    console.log(`  ${chalk2.dim(ts)}  ${chalk2.cyan(row.hook_name.padEnd(14))}  ${chalk2.red(row.error.slice(0, 100))}`);
+  }
+  console.log();
+});
+logCmd.command("clear").description("Delete hook event logs").option("--hook <name>", "Only delete events for this hook").option("-y, --yes", "Skip confirmation prompt", false).action(async (options) => {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDb2();
+  const countRow = options.hook ? db.query("SELECT COUNT(*) as n FROM hook_events WHERE hook_name = ?").get(options.hook) : db.query("SELECT COUNT(*) as n FROM hook_events").get();
+  const count = countRow?.n ?? 0;
+  if (count === 0) {
+    console.log(chalk2.dim("Nothing to clear."));
+    return;
+  }
+  if (!options.yes) {
+    const scope = options.hook ? `hook "${options.hook}"` : "all hooks";
+    console.log(chalk2.yellow(`About to delete ${count} event(s) for ${scope}.`));
+    console.log(chalk2.dim("Re-run with --yes to confirm."));
+    return;
+  }
+  if (options.hook) {
+    db.run("DELETE FROM hook_events WHERE hook_name = ?", [options.hook]);
+  } else {
+    db.run("DELETE FROM hook_events");
+  }
+  console.log(chalk2.green(`\u2713 Cleared ${count} event(s).`));
+});
 program2.command("mcp").option("-s, --stdio", "Use stdio transport (for agent MCP integration)", false).option("-p, --port <port>", "Port for SSE transport", "39427").description("Start MCP server for AI agent integration").action(async (options) => {
   if (options.stdio) {
     const { startStdioServer: startStdioServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));