context-mode 1.0.106 → 1.0.108

package/hooks/core/platform-detect.mjs

@@ -0,0 +1,49 @@
+/**
+ * Platform detection from process env vars.
+ *
+ * Each supported platform sets a distinctive env var when invoking
+ * hook scripts; we use those to pick the correct tool-namer prefix
+ * and routing block. Falls back to "claude-code" when nothing matches
+ * so existing CC behavior is preserved.
+ *
+ * SINGLE SOURCE OF TRUTH: this table mirrors `PLATFORM_ENV_VARS` in
+ * `src/adapters/detect.ts:33-77`. Every entry has been verified against
+ * the platform's own runtime source code (full audit May 2026, see
+ * git blame). DO NOT add platform env vars here that aren't also in
+ * detect.ts — the two MUST stay in lock-step or detection will diverge
+ * between MCP-server-side and hook-script-side.
+ *
+ * Order matters — same as detect.ts. Forks listed BEFORE the fork's
+ * parent so collision detection works (e.g. cursor BEFORE vscode-copilot
+ * because Cursor inherits VSCODE_PID as a fork; antigravity BEFORE
+ * vscode-copilot for the same reason).
+ */
+
+// Mirror of `PLATFORM_ENV_VARS` in src/adapters/detect.ts:33-77.
+// Keep in lock-step. If you change one, change the other.
+const PLATFORM_ENV_VARS_MIRROR = [
+  ["claude-code",        ["CLAUDE_PROJECT_DIR", "CLAUDE_SESSION_ID"]],
+  ["antigravity",        ["ANTIGRAVITY_CLI_ALIAS"]],
+  ["cursor",             ["CURSOR_TRACE_ID", "CURSOR_CLI"]],
+  ["kilo",               ["KILO_PID"]],
+  ["opencode",           ["OPENCODE", "OPENCODE_PID"]],
+  ["zed",                ["ZED_SESSION_ID", "ZED_TERM"]],
+  ["codex",              ["CODEX_THREAD_ID", "CODEX_CI"]],
+  ["gemini-cli",         ["GEMINI_PROJECT_DIR", "GEMINI_CLI"]],
+  ["vscode-copilot",     ["VSCODE_PID", "VSCODE_CWD"]],
+  ["jetbrains-copilot",  ["IDEA_INITIAL_DIRECTORY"]],
+  ["qwen-code",          ["QWEN_PROJECT_DIR"]],
+  ["pi",                 ["PI_PROJECT_DIR"]],
+  // openclaw — no auto-set process env vars; falls through to default
+  // kiro — no auto-set process env vars; falls through to default
+];
+
+export function detectPlatformFromEnv(env = process.env) {
+  for (const [platform, vars] of PLATFORM_ENV_VARS_MIRROR) {
+    if (vars.some((v) => env[v])) return platform;
+  }
+  return "claude-code";
+}
+
+// Re-exported for tests so they can assert against the same canonical table.
+export { PLATFORM_ENV_VARS_MIRROR };

package/hooks/core/routing.mjs

@@ -133,13 +133,25 @@ export async function initSecurity(buildDir) {
  * - VS Code Copilot: run_in_terminal (command field), read_file, run_vs_code_task
  */
 const TOOL_ALIASES = {
-  // Gemini CLI
+  // Gemini CLI / Qwen Code (share native tool names — Qwen is Gemini fork:
+  // refs/platforms/qwen-code/packages/core/src/tools/tool-names.ts)
   "run_shell_command": "Bash",
   "read_file": "Read",
   "read_many_files": "Read",
   "grep_search": "Grep",
   "search_file_content": "Grep",
   "web_fetch": "WebFetch",
+  // Qwen Code additional tool names (no routing branch yet but normalized
+  // so future routing logic works without per-platform fallback):
+  "write_file": "Write",
+  "edit": "Edit",
+  "glob": "Glob",
+  "todo_write": "TodoWrite",
+  "ask_user_question": "AskUserQuestion",
+  "list_directory": "LS",
+  "save_memory": "Memory",
+  "skill": "Skill",
+  "exit_plan_mode": "ExitPlanMode",
   // OpenCode
   "bash": "Bash",
   "view": "Read",

package/hooks/cursor/afteragentresponse.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Cursor afterAgentResponse hook — fires once Cursor finishes streaming
+ * the assistant turn back to the user (per Cursor v1 hook docs:
+ * https://cursor.com/docs/agent/hooks#afteragentresponse).
+ *
+ * Input:  { "conversation_id": "...", "generation_id": "...", "text": "<final assistant message>" }
+ * Output: { "additional_context": "" }  (Cursor rejects empty stdout, so emit a no-op payload)
+ *
+ * The hook records the agent_response event so session analytics + the
+ * resume directive can reconstruct the last assistant turn. Mirrors
+ * stop.mjs (turn lifecycle telemetry) — afterAgentResponse fires
+ * BEFORE stop, so we capture the produced text here while stop captures
+ * loop_count + final status.
+ */
+
+import {
+  readStdin,
+  parseStdin,
+  getSessionId,
+  getSessionDBPath,
+  getInputProjectDir,
+  CURSOR_OPTS,
+} from "../session-helpers.mjs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createSessionLoaders } from "../session-loaders.mjs";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB } = createSessionLoaders(HOOK_DIR);
+const OPTS = CURSOR_OPTS;
+
+// Truncate large assistant responses before persisting — keeps the
+// session_events table from ballooning when an agent emits long output.
+const MAX_TEXT_BYTES = 8 * 1024;
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, CURSOR_OPTS);
+
+  if (projectDir && !process.env.CURSOR_CWD) {
+    process.env.CURSOR_CWD = projectDir;
+  }
+
+  const text = typeof input.text === "string" ? input.text : "";
+  const truncated = text.length > MAX_TEXT_BYTES
+    ? text.slice(0, MAX_TEXT_BYTES)
+    : text;
+
+  const { SessionDB } = await loadSessionDB();
+  const dbPath = getSessionDBPath(OPTS);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  db.ensureSession(sessionId, projectDir);
+  db.insertEvent(sessionId, {
+    type: "agent_response",
+    generation_id: input.generation_id ?? null,
+    text_bytes: text.length,
+    truncated: text.length > MAX_TEXT_BYTES,
+    text: truncated,
+  }, "AfterAgentResponse");
+
+  db.close();
+} catch {
+  // Cursor treats stderr as hook failure; swallow and continue.
+}
+
+// Cursor rejects empty stdout as "no valid response", so emit a no-op
+// additional_context payload (same convention as sessionstart.mjs).
+process.stdout.write(JSON.stringify({ additional_context: "" }) + "\n");

package/hooks/ensure-deps.mjs

@@ -22,11 +22,28 @@
 import { existsSync, copyFileSync } from "node:fs";
 import { execSync } from "node:child_process";
 import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 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"],
@@ -46,7 +63,7 @@ function hasModernSqlite() {
   return major > 22 || (major === 22 && minor >= 5);
 }
 
-export function ensureDeps() {
+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) {
@@ -62,14 +79,11 @@ export function ensureDeps() {
         });
       } 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)
-      try {
-        execSync(`${process.platform === "win32" ? "npm.cmd" : "npm"} rebuild ${pkg} --ignore-scripts=false`, {
-          cwd: root,
-          stdio: "pipe",
-          timeout: 120000,
-        });
-      } catch { /* best effort — hook degrades gracefully without DB */ }
+      // 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 */ }
     }
   }
 }
@@ -188,6 +202,8 @@ export function codesignBinary(binaryPath) {
   }
 }
 
-// Auto-run on import (like suppress-stderr.mjs)
-ensureDeps();
+// 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/gemini-cli/beforeagent.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Gemini CLI BeforeAgent hook — UserPromptSubmit equivalent.
+ *
+ * Captures every user prompt so the LLM can resume from the exact point
+ * the user left off after compact / resume. Mirrors hooks/userpromptsubmit.mjs
+ * but reads `input.prompt` (Gemini wire shape, types.ts:547-549) and emits
+ * `hookSpecificOutput.hookEventName: "BeforeAgent"` (types.ts:554-559) so
+ * Gemini's hookRunner appends additionalContext to the prompt
+ * (hookRunner.ts:183-197).
+ *
+ * Must be fast (<10ms). Single SQLite write.
+ */
+
+import {
+  readStdin,
+  parseStdin,
+  getSessionId,
+  getSessionDBPath,
+  getInputProjectDir,
+  GEMINI_OPTS,
+} from "../session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+const OPTS = GEMINI_OPTS;
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const prompt = input.prompt ?? input.message ?? "";
+  const trimmed = (prompt || "").trim();
+
+  // Skip system-generated messages — only capture genuine user prompts.
+  const isSystemMessage = trimmed.startsWith("<task-notification>")
+    || trimmed.startsWith("<system-reminder>")
+    || trimmed.startsWith("<context_guidance>")
+    || trimmed.startsWith("<tool-result>");
+
+  if (trimmed.length > 0 && !isSystemMessage) {
+    const { SessionDB } = await loadSessionDB();
+    const { extractUserEvents } = await loadExtract();
+    const { resolveProjectAttributions } = await loadProjectAttribution();
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+
+    db.ensureSession(sessionId, projectDir);
+
+    // 1. Always save the raw prompt.
+    const promptEvent = {
+      type: "user_prompt",
+      category: "user-prompt",
+      data: prompt,
+      priority: 1,
+    };
+    const promptAttributions = attributeAndInsertEvents(
+      db, sessionId, [promptEvent], input, projectDir, "BeforeAgent", resolveProjectAttributions,
+    );
+
+    // 2. Extract decision/role/intent/data from user message.
+    const userEvents = extractUserEvents(trimmed);
+    const savedLastKnown = promptAttributions[0]?.projectDir || null;
+    const sessionStats = db.getSessionStats(sessionId);
+    const lastKnownProjectDir = typeof db.getLatestAttributedProjectDir === "function"
+      ? db.getLatestAttributedProjectDir(sessionId)
+      : null;
+    const userAttributions = resolveProjectAttributions(userEvents, {
+      sessionOriginDir: sessionStats?.project_dir || projectDir,
+      inputProjectDir: projectDir,
+      workspaceRoots: Array.isArray(input.workspace_roots) ? input.workspace_roots : [],
+      lastKnownProjectDir: savedLastKnown || lastKnownProjectDir,
+    });
+    for (let i = 0; i < userEvents.length; i++) {
+      db.insertEvent(sessionId, userEvents[i], "BeforeAgent", userAttributions[i]);
+    }
+
+    db.close();
+  }
+} catch {
+  // BeforeAgent must never block the session — silent fallback.
+}
+
+// Emit empty additionalContext so Gemini's hookRunner treats the response as
+// metadata (no prompt mutation). Matches the SessionStart hook's structured-
+// output convention (sessionstart.mjs:130-135).
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: "BeforeAgent",
+    additionalContext: "",
+  },
+}));

package/hooks/kiro/agentspawn.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Kiro CLI agentSpawn hook for context-mode.
+ *
+ * agentSpawn is the Kiro semantic equivalent of Claude Code's SessionStart:
+ * fires once when an agent loads. We use it to inject the routing block and
+ * (on resume/compact) the session-resume directive.
+ *
+ * Source: https://kiro.dev/docs/cli/hooks
+ */
+
+import { createRoutingBlock } from "../routing-block.mjs";
+import { createToolNamer } from "../core/tool-naming.mjs";
+
+const toolNamer = createToolNamer("kiro");
+const ROUTING_BLOCK = createRoutingBlock(toolNamer);
+import {
+  writeSessionEventsFile,
+  buildSessionDirective,
+  getSessionEvents,
+} from "../session-directive.mjs";
+import {
+  readStdin,
+  parseStdin,
+  getSessionId,
+  getSessionDBPath,
+  getSessionEventsPath,
+  getCleanupFlagPath,
+  getInputProjectDir,
+  KIRO_OPTS,
+} from "../session-helpers.mjs";
+import { createSessionLoaders } from "../session-loaders.mjs";
+import { unlinkSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = fileURLToPath(new URL(".", import.meta.url));
+const { loadSessionDB } = createSessionLoaders(HOOK_DIR);
+const OPTS = KIRO_OPTS;
+
+let additionalContext = ROUTING_BLOCK;
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  // Kiro stdin shape mirrors codex/CC: { source, cwd, ... }. Default startup
+  // when no source provided (single-shot agent spawn).
+  const source = input.source ?? "startup";
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  if (source === "compact" || source === "resume") {
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+
+    if (source === "compact") {
+      const sessionId = getSessionId(input, OPTS);
+      const resume = db.getResume(sessionId);
+      if (resume && !resume.consumed) {
+        db.markResumeConsumed(sessionId);
+      }
+    } else {
+      try { unlinkSync(getCleanupFlagPath(OPTS)); } catch { /* no flag */ }
+    }
+
+    const sessionId = getSessionId(input, OPTS);
+    const events = sessionId ? getSessionEvents(db, sessionId) : [];
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS));
+      additionalContext += buildSessionDirective(source, eventMeta, toolNamer);
+    }
+
+    db.close();
+  } else if (source === "startup") {
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+    try { unlinkSync(getSessionEventsPath(OPTS)); } catch { /* no stale file */ }
+
+    db.cleanupOldSessions(7);
+    db.db.exec(`DELETE FROM session_events WHERE session_id NOT IN (SELECT session_id FROM session_meta)`);
+
+    const sessionId = getSessionId(input, OPTS);
+    db.ensureSession(sessionId, projectDir);
+
+    db.close();
+  }
+  // clear => routing block only
+} catch {
+  // Swallow errors — hook must not fail
+}
+
+// Kiro CLI agentSpawn JSON output shape mirrors CC SessionStart.
+process.stdout.write(JSON.stringify({
+  hookSpecificOutput: { hookEventName: "agentSpawn", additionalContext },
+}) + "\n");

package/hooks/kiro/userpromptsubmit.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Kiro CLI UserPromptSubmit hook — capture user prompts for continuity.
+ *
+ * Mirrors hooks/codex/userpromptsubmit.mjs (same json-stdio paradigm).
+ * Kiro stdin: { hook_event_name: "userPromptSubmit", cwd, prompt }
+ *
+ * Source: https://kiro.dev/docs/cli/hooks
+ */
+
+import {
+  readStdin,
+  parseStdin,
+  getSessionId,
+  getSessionDBPath,
+  getInputProjectDir,
+  KIRO_OPTS,
+} from "../session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+const OPTS = KIRO_OPTS;
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const prompt = input.prompt ?? input.message ?? "";
+  const trimmed = (prompt || "").trim();
+
+  const isSystemMessage = trimmed.startsWith("<task-notification>")
+    || trimmed.startsWith("<system-reminder>")
+    || trimmed.startsWith("<context_guidance>")
+    || trimmed.startsWith("<tool-result>");
+
+  if (trimmed.length > 0 && !isSystemMessage) {
+    const { SessionDB } = await loadSessionDB();
+    const { extractUserEvents } = await loadExtract();
+    const { resolveProjectAttributions } = await loadProjectAttribution();
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+
+    db.ensureSession(sessionId, projectDir);
+
+    const promptEvent = {
+      type: "user_prompt",
+      category: "user-prompt",
+      data: prompt,
+      priority: 1,
+    };
+    const promptAttributions = attributeAndInsertEvents(
+      db, sessionId, [promptEvent], input, projectDir, "UserPromptSubmit", resolveProjectAttributions,
+    );
+
+    const userEvents = extractUserEvents(trimmed);
+    const savedLastKnown = promptAttributions[0]?.projectDir || null;
+    const sessionStats = db.getSessionStats(sessionId);
+    const lastKnownProjectDir = typeof db.getLatestAttributedProjectDir === "function"
+      ? db.getLatestAttributedProjectDir(sessionId)
+      : null;
+    const userAttributions = resolveProjectAttributions(userEvents, {
+      sessionOriginDir: sessionStats?.project_dir || projectDir,
+      inputProjectDir: projectDir,
+      workspaceRoots: Array.isArray(input.workspace_roots) ? input.workspace_roots : [],
+      lastKnownProjectDir: savedLastKnown || lastKnownProjectDir,
+    });
+    for (let i = 0; i < userEvents.length; i++) {
+      db.insertEvent(sessionId, userEvents[i], "UserPromptSubmit", userAttributions[i]);
+    }
+
+    db.close();
+  }
+} catch {
+  // Kiro hooks must not block the session.
+}
+
+// Kiro CLI userPromptSubmit accepts JSON output for additionalContext (see docs).
+// We don't inject context here — that's the agentSpawn hook's job.
+process.stdout.write(JSON.stringify({
+  hookSpecificOutput: { hookEventName: "userPromptSubmit", additionalContext: "" },
+}) + "\n");