@mxalbert/context-mode 2.0.0

package/hooks/ensure-deps.mjs

@@ -0,0 +1,254 @@
+/**
+ * Shared dependency bootstrap for hooks and start.mjs.
+ *
+ * Single source of truth — ensures native deps (better-sqlite3) are
+ * installed in the plugin cache before any hook or server code runs.
+ *
+ * Pattern: same as suppress-stderr.mjs — imported at the top of every
+ * hook that needs native modules. Fast path: existsSync check (~0.1ms).
+ * Slow path: npm install (first run only, ~5-30s).
+ *
+ * Also handles ABI compatibility (#148, #203): when the current Node.js
+ * version differs from the one better-sqlite3 was compiled against,
+ * automatically swaps in a cached binary or rebuilds. This protects
+ * both the MCP server AND hooks from ABI mismatch crashes when users
+ * have multiple Node versions via mise/volta/fnm/nvm.
+ *
+ * @see https://github.com/mxalbert1996/context-mode/issues/148
+ * @see https://github.com/mxalbert1996/context-mode/issues/172
+ * @see https://github.com/mxalbert1996/context-mode/issues/203
+ */
+
+import { existsSync, copyFileSync, renameSync, unlinkSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = resolve(__dirname, "..");
+
+// Shared 3-layer heal helper (also used by scripts/postinstall.mjs).
+// Lazy-loaded via dynamic import so older installs and synthetic test
+// harnesses (e.g. tests/session-hooks-smoke) — which don't ship
+// `scripts/heal-better-sqlite3.mjs` — degrade to a no-op instead of
+// crashing the hook with ERR_MODULE_NOT_FOUND. Best-effort posture
+// matches the rest of this module.
+async function healBetterSqlite3Binding(pkgRoot) {
+  try {
+    const helperPath = resolve(__dirname, "..", "scripts", "heal-better-sqlite3.mjs");
+    if (!existsSync(helperPath)) return { healed: false, reason: "helper-missing" };
+    const mod = await import(pathToFileURL(helperPath).href);
+    return mod.healBetterSqlite3Binding(pkgRoot);
+  } catch {
+    return { healed: false, reason: "helper-error" };
+  }
+}
+
+const NATIVE_DEPS = ["better-sqlite3"];
+const NATIVE_BINARIES = {
+  "better-sqlite3": ["build", "Release", "better_sqlite3.node"],
+};
+
+/**
+ * Check if the current runtime has built-in SQLite support.
+ * Bun has bun:sqlite, Node >= 22.5 has node:sqlite.
+ *
+ * Used to skip the SIGSEGV-prone child-process probe on modern Node (#331),
+ * but NOT to skip installing better-sqlite3 — the bundle unconditionally
+ * requires it as a fallback on non-Linux platforms (#371).
+ */
+function hasModernSqlite() {
+  if (typeof globalThis.Bun !== "undefined") return true;
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  return major > 22 || (major === 22 && minor >= 5);
+}
+
+export async function ensureDeps() {
+  // Bun ships bun:sqlite and never needs better-sqlite3
+  if (typeof globalThis.Bun !== "undefined") return;
+  for (const pkg of NATIVE_DEPS) {
+    const pkgDir = resolve(root, "node_modules", pkg);
+    if (!existsSync(pkgDir)) {
+      // Package not installed at all
+      try {
+        execSync(`${process.platform === "win32" ? "npm.cmd" : "npm"} install ${pkg} --no-package-lock --no-save --silent`, {
+          cwd: root,
+          stdio: "pipe",
+          timeout: 120000,
+          shell: true,
+        });
+      } catch { /* best effort — hook degrades gracefully without DB */ }
+    } else if (!existsSync(resolve(pkgDir, ...NATIVE_BINARIES[pkg]))) {
+      // Package installed but native binary missing (e.g., npm ignore-scripts=true,
+      // or Windows where `npm rebuild` falls through to node-gyp without MSVC — #408).
+      // Delegate to the shared 3-layer heal (single source of truth, also used by
+      // scripts/postinstall.mjs).
+      try { await healBetterSqlite3Binding(root); } catch { /* helper already best-effort */ }
+    }
+  }
+}
+
+/**
+ * Probe-load better-sqlite3 in a child process to verify the binary on disk
+ * is compatible with the current Node ABI. In-process require() caches native
+ * modules at the dlopen level, so it can't detect on-disk binary changes.
+ * A child process gets a fresh dlopen cache.
+ *
+ * Note: require('better-sqlite3') only loads the JS wrapper — the native
+ * binary is lazy-loaded when instantiating a Database. We must create an
+ * in-memory DB to actually trigger dlopen.
+ */
+function probeNativeInChildProcess(pluginRoot) {
+  try {
+    execSync(`node -e "new (require('better-sqlite3'))(':memory:').close()"`, {
+      cwd: pluginRoot,
+      stdio: "pipe",
+      timeout: 10000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * In-process probe — cheap, safe on modern Node (no child spawn, no SIGSEGV path).
+ * Returns true if better-sqlite3 loads against the current ABI.
+ */
+function probeNativeInProcess(pluginRoot) {
+  try {
+    const req = createRequire(resolve(pluginRoot, "package.json"));
+    const Database = req("better-sqlite3");
+    new Database(":memory:").close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function replaceActiveNativeBinaryFromCache(abiCachePath, binaryPath) {
+  const tmpPath = `${binaryPath}.staging-${process.pid}-${Date.now()}`;
+  try {
+    copyFileSync(abiCachePath, tmpPath);
+    codesignBinary(tmpPath);
+    renameSync(tmpPath, binaryPath);
+  } catch (err) {
+    try { unlinkSync(tmpPath); } catch { /* best effort cleanup */ }
+    throw err;
+  }
+}
+
+export function ensureNativeCompat(pluginRoot) {
+  // Pre-compute paths regardless of runtime — the Bun branch below uses
+  // them to seed the ABI cache (#543) so the next /ctx-upgrade boot (under
+  // Node) finds the success marker file. Bun spoofs
+  // process.versions.modules to match the Node ABI level (e.g. 137 on
+  // Darwin matching Node 24), so a plain file-copy produces the correct
+  // filename for any subsequent Node boot at the same ABI.
+  const abi = process.versions.modules;
+  const nativeDir = resolve(pluginRoot, "node_modules", "better-sqlite3", "build", "Release");
+  const binaryPath = resolve(nativeDir, "better_sqlite3.node");
+  const abiCachePath = resolve(nativeDir, `better_sqlite3.abi${abi}.node`);
+
+  // Bun ships bun:sqlite — no native addon needed at RUNTIME. But
+  // /ctx-upgrade still verifies the ABI cache file as the success marker,
+  // so we seed it from the active binary if it exists. Best-effort:
+  // any failure here is silent because Bun never loads better-sqlite3.
+  if (typeof globalThis.Bun !== "undefined") {
+    try {
+      if (existsSync(nativeDir) && existsSync(binaryPath) && !existsSync(abiCachePath)) {
+        copyFileSync(binaryPath, abiCachePath);
+      }
+    } catch { /* best effort — Bun never dlopens this file */ }
+    return;
+  }
+
+  // On Node >= 22.5, skip the child-process probe that can cause SIGSEGV (#331).
+  // The binary install/rebuild still runs — only the dlopen probe is skipped.
+  const skipProbe = hasModernSqlite();
+
+  try {
+    if (!existsSync(nativeDir)) return;
+
+    // Fast path: cached binary for this ABI already exists — swap in
+    if (existsSync(abiCachePath)) {
+      replaceActiveNativeBinaryFromCache(abiCachePath, binaryPath);
+      if (skipProbe) return; // Trust the cached binary — skip SIGSEGV-prone probe
+      // Validate via child process — dlopen cache is per-process, so in-process
+      // require() can't detect a swapped binary on disk (#148)
+      if (probeNativeInChildProcess(pluginRoot)) {
+        return; // Cache hit validated
+      }
+      // Cached binary is stale/corrupt — fall through to rebuild
+    }
+
+    if (skipProbe) {
+      // Seed the ABI cache from a working binary before falling back to rebuild;
+      // otherwise a missing cache forces npm rebuild on every hook invocation.
+      if (existsSync(binaryPath) && probeNativeInProcess(pluginRoot)) {
+        copyFileSync(binaryPath, abiCachePath);
+        return;
+      }
+      execSync(`${process.platform === "win32" ? "npm.cmd" : "npm"} rebuild better-sqlite3 --ignore-scripts=false`, {
+        cwd: pluginRoot,
+        stdio: "pipe",
+        timeout: 60000,
+        shell: true,
+      });
+      codesignBinary(binaryPath);
+      if (existsSync(binaryPath)) {
+        copyFileSync(binaryPath, abiCachePath);
+      }
+      return;
+    }
+
+    // Probe: try loading better-sqlite3 with current Node
+    if (existsSync(binaryPath) && probeNativeInChildProcess(pluginRoot)) {
+      // Load succeeded — cache the working binary for this ABI
+      copyFileSync(binaryPath, abiCachePath);
+    } else {
+      // ABI mismatch or missing native binary — rebuild for current Node version
+      execSync(`${process.platform === "win32" ? "npm.cmd" : "npm"} rebuild better-sqlite3 --ignore-scripts=false`, {
+        cwd: pluginRoot,
+        stdio: "pipe",
+        timeout: 60000,
+        shell: true,
+      });
+      codesignBinary(binaryPath);
+      if (existsSync(binaryPath) && probeNativeInChildProcess(pluginRoot)) {
+        copyFileSync(binaryPath, abiCachePath);
+      }
+    }
+  } catch {
+    /* best effort — caller will report the error on first DB access */
+  }
+}
+
+/**
+ * Ad-hoc codesign a native binary on macOS.
+ *
+ * When a cached .node binary is copied over the active one, macOS hardened
+ * runtime (e.g. Zed, VS Code with runtime hardening) will SIGKILL the
+ * process on the next dlopen because the code signature is invalidated.
+ * SIGKILL is uncatchable — the only fix is to re-sign after the copy.
+ *
+ * No-op on non-macOS. Swallows errors (codesign may not be available in
+ * all environments, e.g. Docker containers).
+ */
+export function codesignBinary(binaryPath) {
+  if (process.platform === "darwin") {
+    try {
+      execSync(`codesign --sign - --force "${binaryPath}"`, {
+        stdio: "pipe",
+        timeout: 10000,
+      });
+    } catch { /* codesign unavailable — continue without signing */ }
+  }
+}
+
+// Auto-run on import (like suppress-stderr.mjs).
+// Top-level await ensures the heal completes before the importer's next
+// statement runs (which is typically `new Database(...)`).
+await ensureDeps();
+ensureNativeCompat(root);

package/hooks/formatters/claude-code.mjs

@@ -0,0 +1,113 @@
+/**
+ * Claude Code formatter — converts routing decisions into Claude Code hook output format.
+ *
+ * Claude Code expects:
+ *   { hookSpecificOutput: { hookEventName, permissionDecision?, reason?, updatedInput?, additionalContext? } }
+ *
+ * Decision shape from routing.mjs:
+ *   - { action: "deny", reason: string }
+ *   - { action: "ask" }
+ *   - { action: "modify", updatedInput: object }
+ *   - { action: "context", additionalContext: string }
+ *   - null (passthrough)
+ *
+ * @param {object | null} decision - Normalized decision from routePreToolUse
+ * @returns {object | null} Claude Code hook response, or null for passthrough
+ */
+
+// In `claude --print` (headless) the CLI has no TTY to surface an "ask" prompt,
+// so the agent stalls forever. Launchers running headless set CLAUDE_CODE_HEADLESS=1;
+// when set, we mirror gemini-cli.mjs and passthrough on ask instead of blocking.
+//
+// We also passthrough on `deny` and `modify` in headless mode — context-mode's
+// purpose is to nudge the agent toward `ctx_*` tools to save context. In a TTY
+// session that nudge is useful: the agent reconsiders or asks the user. In
+// headless `--print` mode the agent has no UI to reconsider; a `deny` aborts
+// the run with no path forward, and `modify` silently swaps a curl for an
+// `echo "use ctx_execute"` line that produces zero stdout — which is exactly
+// what blocked the homelab daily explorer agent (Loki/Prom curl turned into
+// empty echoes, all data-fetch steps reported BLOCKED). In headless launchers,
+// the operator has already accepted the context-budget tradeoff by running
+// raw tools; let those tools through.
+const isHeadless = () => process.env.CLAUDE_CODE_HEADLESS === "1";
+
+export function formatDecision(decision) {
+  if (!decision) return null;
+
+  switch (decision.action) {
+    case "deny":
+      if (isHeadless()) return null;
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "deny",
+          reason: decision.reason ?? "Blocked by context-mode",
+        },
+      };
+
+    case "ask":
+      if (isHeadless()) return null;
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "ask",
+        },
+      };
+
+    case "modify": {
+      if (isHeadless()) return null;
+
+      // Tool-aware modify handling:
+      //
+      // - Bash redirect (updatedInput.command): CC v2.1.x ignores
+      //   `updatedInput.command` substitution under `permissionDecision: "allow"`
+      //   — original command runs unchanged. Verified via /diagnose Phase 4
+      //   forced-deny probe: only `permissionDecision: "deny"` is honored for
+      //   Bash blocking. Emit deny + extract echo payload into
+      //   `permissionDecisionReason`.
+      //
+      // - Agent prompt injection (updatedInput.prompt): CC honors allow+updatedInput
+      //   for the Agent tool — the modified prompt actually reaches the subagent.
+      //   Keep the original modify shape so subagent routing-block injection works.
+      //
+      // - Any other shape: pass through as modify (no command, no prompt — let
+      //   CC decide if the field is honored).
+      const ui = decision.updatedInput ?? {};
+      const isBashCommandRedirect = "command" in ui;
+      if (!isBashCommandRedirect) {
+        return {
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            updatedInput: ui,
+          },
+        };
+      }
+      // routing.mjs wraps the redirect guidance in `echo "..."` form.
+      // Extract the quoted payload as the deny reason. Fall back to a generic
+      // ADR-0003 CASE A message if the shape doesn't match.
+      const cmd = ui.command ?? "";
+      const m = cmd.match(/^echo\s+"(.+)"$/s);
+      const reason = m
+        ? m[1]
+        : "Redirected to ctx_execute / ctx_fetch_and_index. Call ctx_execute(language, code) to fetch and derive your answer in one round trip, or call ctx_fetch_and_index(url, source) when you want to query the response later via ctx_search. Both have full network access. Retry the same call on a transient DNS error (EAI_AGAIN, ETIMEDOUT, ENETUNREACH).";
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "deny",
+          permissionDecisionReason: reason,
+        },
+      };
+    }
+
+    case "context":
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          additionalContext: decision.additionalContext ?? "",
+        },
+      };
+
+    default:
+      return null;
+  }
+}

package/hooks/formatters/cursor.mjs

@@ -0,0 +1,37 @@
+/**
+ * Cursor formatter — converts routing decisions into native Cursor hook output.
+ *
+ * Cursor expects flat response objects:
+ *   { permission: "deny" | "ask", user_message?: string }
+ *   { updated_input: { ... } }
+ *   { agent_message: "..." }
+ */
+export function formatDecision(decision) {
+  if (!decision) return null;
+
+  switch (decision.action) {
+    case "deny":
+      return {
+        permission: "deny",
+        user_message: decision.reason ?? "Blocked by context-mode",
+      };
+
+    case "ask":
+      return {
+        permission: "ask",
+      };
+
+    case "modify":
+      return {
+        updated_input: decision.updatedInput,
+      };
+
+    case "context":
+      return {
+        agent_message: decision.additionalContext ?? "",
+      };
+
+    default:
+      return null;
+  }
+}

package/hooks/formatters/gemini-cli.mjs

@@ -0,0 +1,55 @@
+/**
+ * Gemini CLI formatter — converts routing decisions into Gemini CLI hook output format.
+ *
+ * Gemini CLI expects:
+ *   { hookSpecificOutput: { decision?, reason?, tool_input?, additionalContext? } }
+ *
+ * Key differences from Claude Code:
+ *   - Uses "decision" instead of "permissionDecision"
+ *   - Uses "tool_input" instead of "updatedInput"
+ *   - No "ask" concept — Gemini CLI only supports deny/allow
+ *
+ * Decision shape from routing.mjs:
+ *   - { action: "deny", reason: string }
+ *   - { action: "ask" }
+ *   - { action: "modify", updatedInput: object }
+ *   - { action: "context", additionalContext: string }
+ *   - null (passthrough)
+ *
+ * @param {object | null} decision - Normalized decision from routePreToolUse
+ * @returns {object | null} Gemini CLI hook response, or null for passthrough
+ */
+export function formatDecision(decision) {
+  if (!decision) return null;
+
+  switch (decision.action) {
+    case "deny":
+      return {
+        hookSpecificOutput: {
+          decision: "deny",
+          reason: decision.reason ?? "Blocked by context-mode",
+        },
+      };
+
+    case "ask":
+      // Gemini CLI has no "ask" concept — return null (passthrough)
+      return null;
+
+    case "modify":
+      return {
+        hookSpecificOutput: {
+          tool_input: decision.updatedInput,
+        },
+      };
+
+    case "context":
+      return {
+        hookSpecificOutput: {
+          additionalContext: decision.additionalContext ?? "",
+        },
+      };
+
+    default:
+      return null;
+  }
+}

package/hooks/formatters/vscode-copilot.mjs

@@ -0,0 +1,55 @@
+/**
+ * VS Code Copilot formatter — converts routing decisions into VS Code Copilot hook output format.
+ *
+ * VS Code Copilot expects a flat structure for deny/ask, nested for modify/context:
+ *   { permissionDecision: "deny", reason: "..." }               — deny
+ *   { permissionDecision: "ask" }                                 — ask
+ *   { hookSpecificOutput: { ... }, hookEventName: "PreToolUse" }  — modify/context
+ *
+ * Key differences from Claude Code:
+ *   - deny/ask are flat (not wrapped in hookSpecificOutput)
+ *   - modify/context include hookEventName at top level alongside hookSpecificOutput
+ *
+ * Decision shape from routing.mjs:
+ *   - { action: "deny", reason: string }
+ *   - { action: "ask" }
+ *   - { action: "modify", updatedInput: object }
+ *   - { action: "context", additionalContext: string }
+ *   - null (passthrough)
+ *
+ * @param {object | null} decision - Normalized decision from routePreToolUse
+ * @returns {object | null} VS Code Copilot hook response, or null for passthrough
+ */
+export function formatDecision(decision) {
+  if (!decision) return null;
+
+  switch (decision.action) {
+    case "deny":
+      return {
+        permissionDecision: "deny",
+        reason: decision.reason ?? "Blocked by context-mode",
+      };
+
+    case "ask":
+      return {
+        permissionDecision: "ask",
+      };
+
+    case "modify":
+      return {
+        hookSpecificOutput: decision.updatedInput,
+        hookEventName: "PreToolUse",
+      };
+
+    case "context":
+      return {
+        hookSpecificOutput: {
+          additionalContext: decision.additionalContext ?? "",
+        },
+        hookEventName: "PreToolUse",
+      };
+
+    default:
+      return null;
+  }
+}

package/hooks/gemini-cli/aftermodel.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Gemini CLI AfterModel hook — per-turn token / cost capture.
+ *
+ * AfterModel fires per model call inside gemini-cli's stream loop
+ * (packages/core/src/core/geminiChat.ts:1213). The hook payload carries
+ * `llm_request` + `llm_response` (hooks/types.ts:692-695); the real Gemini
+ * `usageMetadata` (promptTokenCount, candidatesTokenCount, +cachedContent/
+ * thoughts when present) and resolved model live on `llm_response`
+ * (hookTranslator.ts:60-64, loggingContentGenerator.ts:405,553).
+ *
+ * parseGeminiUsage maps that into a builder `agent_usage` event; cost_usd is
+ * derived from the pricing catalog (gemini exposes no native cost). The event
+ * is forwarded via attributeAndInsertEvents — same path as hooks/stop.mjs.
+ *
+ * One AfterModel call = one billed model round-trip = one priced event.
+ * Per-userPromptId summation into a single per-turn total is deferred; emitting
+ * per-call never double-counts (each call's usageMetadata is authoritative).
+ *
+ * Must be fast (<20ms). No network, no LLM, just a parse + SQLite write.
+ * AfterModel is non-blocking — no stdout output.
+ */
+
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, GEMINI_OPTS } from "../session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import { appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+const OPTS = GEMINI_OPTS;
+const DEBUG_LOG = join(homedir(), ".gemini", "context-mode", "aftermodel-debug.log");
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const { parseGeminiUsage } = await loadExtract();
+  const event = parseGeminiUsage(input);
+
+  if (event) {
+    const { resolveProjectAttributions } = await loadProjectAttribution();
+    const { SessionDB } = await loadSessionDB();
+
+    const dbPath = getSessionDBPath(OPTS, projectDir);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+    db.ensureSession(sessionId, projectDir);
+
+    // attributeAndInsertEvents both INSERTS locally and FORWARDS to the
+    // platform (gated on ~/.context-mode/platform.json) — same as stop.mjs.
+    attributeAndInsertEvents(db, sessionId, [event], input, projectDir, "AfterModel", resolveProjectAttributions);
+    db.close();
+
+    try {
+      appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] OK: ${event.model_id ?? "?"} in:${event.input_tokens ?? 0} out:${event.output_tokens ?? 0}\n`);
+    } catch { /* silent */ }
+  }
+} catch (err) {
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ERR: ${err?.message || err}\n`);
+  } catch { /* silent */ }
+}
+
+// AfterModel is non-blocking — no stdout output

package/hooks/gemini-cli/aftertool.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Gemini CLI AfterTool hook — session event capture.
+ *
+ * Captures session events from tool calls (13 categories) and stores
+ * them in the per-project SessionDB for later resume snapshot building.
+ *
+ * Must be fast (<20ms). No network, no LLM, just SQLite writes.
+ */
+
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, GEMINI_OPTS } from "../session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import { appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+const OPTS = GEMINI_OPTS;
+const DEBUG_LOG = join(homedir(), ".gemini", "context-mode", "aftertool-debug.log");
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] CALL: ${input.tool_name}\n`);
+
+  const { extractEvents } = await loadExtract();
+  const { resolveProjectAttributions } = await loadProjectAttribution();
+  const { SessionDB } = await loadSessionDB();
+
+  const dbPath = getSessionDBPath(OPTS, projectDir);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  db.ensureSession(sessionId, projectDir);
+
+  const events = extractEvents({
+    tool_name: input.tool_name,
+    tool_input: input.tool_input ?? {},
+    tool_response: typeof input.tool_response === "string"
+      ? input.tool_response
+      : JSON.stringify(input.tool_response ?? ""),
+    tool_output: input.tool_output,
+  });
+
+  attributeAndInsertEvents(db, sessionId, events, input, projectDir, "AfterTool", resolveProjectAttributions);
+
+  appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] OK: ${input.tool_name} → ${events.length} events\n`);
+  db.close();
+} catch (err) {
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ERR: ${err?.message || err}\n`);
+  } catch { /* silent */ }
+}
+
+// AfterTool is non-blocking — no stdout output