@mxalbert/context-mode 2.0.0

package/hooks/hooks.json

@@ -0,0 +1,143 @@
+{
+  "description": "Context-mode hooks — PreToolUse routing, PostToolUse session capture, UserPromptSubmit decisions, PreCompact snapshot, SessionStart context injection, Stop turn-end capture",
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Bash|Read|Write|Edit|NotebookEdit|Glob|Grep|TodoWrite|TaskCreate|TaskUpdate|EnterPlanMode|ExitPlanMode|Skill|Agent|AskUserQuestion|EnterWorktree|mcp__",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/posttooluse.mjs\""
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/precompact.mjs\""
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "WebFetch",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "Read",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "Grep",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "Agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "mcp__plugin_context-mode_context-mode__ctx_execute",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "mcp__plugin_context-mode_context-mode__ctx_execute_file",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "mcp__plugin_context-mode_context-mode__ctx_batch_execute",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse.mjs\""
+          }
+        ]
+      },
+      {
+        "matcher": "mcp__",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse.mjs\""
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/userpromptsubmit.mjs\""
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/sessionstart.mjs\""
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/stop.mjs\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/jetbrains-copilot/posttooluse.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * JetBrains Copilot PostToolUse 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 { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, JETBRAINS_OPTS } from "../session-helpers.mjs";
+import { appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+const OPTS = JETBRAINS_OPTS;
+const DEBUG_LOG = join(homedir(), ".config", "JetBrains", "context-mode", "posttooluse-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, "PostToolUse", 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 */ }
+}
+
+// PostToolUse — no stdout output

package/hooks/jetbrains-copilot/precompact.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * JetBrains Copilot PreCompact hook — snapshot generation.
+ *
+ * Triggered when JetBrains Copilot is about to compact the conversation.
+ * Reads all captured session events, builds a priority-sorted resume
+ * snapshot (<2KB XML), and stores it for injection after compact.
+ */
+
+import { createSessionLoaders } from "../session-loaders.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, JETBRAINS_OPTS } from "../session-helpers.mjs";
+import { appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadSnapshot } = createSessionLoaders(HOOK_DIR);
+const OPTS = JETBRAINS_OPTS;
+const DEBUG_LOG = join(homedir(), ".config", "JetBrains", "context-mode", "precompact-debug.log");
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const { buildResumeSnapshot } = await loadSnapshot();
+  const { SessionDB } = await loadSessionDB();
+
+  const dbPath = getSessionDBPath(OPTS, projectDir);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  const events = db.getEvents(sessionId);
+
+  if (events.length > 0) {
+    const stats = db.getSessionStats(sessionId);
+    const snapshot = buildResumeSnapshot(events, {
+      compactCount: (stats?.compact_count ?? 0) + 1,
+    });
+
+    db.upsertResume(sessionId, snapshot, events.length);
+    db.incrementCompactCount(sessionId);
+  }
+
+  db.close();
+} catch (err) {
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ${err?.message || err}\n`);
+  } catch { /* silent */ }
+}
+
+// PreCompact — no stdout output needed

package/hooks/jetbrains-copilot/pretooluse.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+/**
+ * JetBrains Copilot PreToolUse hook for context-mode
+ * Thin wrapper — uses shared routing core, no self-heal, no Claude Code-specific logic.
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readStdin } from "../core/stdin.mjs";
+import { routePreToolUse, initSecurity } from "../core/routing.mjs";
+import { formatDecision } from "../core/formatters.mjs";
+import { parseStdin, getSessionId, JETBRAINS_OPTS } from "../session-helpers.mjs";
+
+const __hookDir = dirname(fileURLToPath(import.meta.url));
+await initSecurity(resolve(__hookDir, "..", "..", "build"));
+
+const raw = await readStdin();
+const input = parseStdin(raw);
+const tool = input.tool_name ?? "";
+const toolInput = input.tool_input ?? {};
+
+const decision = routePreToolUse(tool, toolInput, process.env.IDEA_INITIAL_DIRECTORY || process.env.CLAUDE_PROJECT_DIR, "jetbrains-copilot", getSessionId(input, JETBRAINS_OPTS));
+const response = formatDecision("jetbrains-copilot", decision);
+if (response !== null) {
+  process.stdout.write(JSON.stringify(response) + "\n");
+}

package/hooks/jetbrains-copilot/sessionstart.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * JetBrains Copilot SessionStart hook for context-mode
+ *
+ * Session lifecycle management:
+ * - "startup"  → Cleanup old sessions, capture instruction file rules
+ * - "compact"  → Write events file, inject session knowledge directive
+ * - "resume"   → Load previous session events, inject directive
+ * - "clear"    → No action needed
+ */
+
+import { createSessionLoaders } from "../session-loaders.mjs";
+import { createRoutingBlock } from "../routing-block.mjs";
+import { createToolNamer } from "../core/tool-naming.mjs";
+
+const toolNamer = createToolNamer("jetbrains-copilot");
+const ROUTING_BLOCK = createRoutingBlock(toolNamer);
+import { writeSessionEventsFile, buildSessionDirective, getSessionEvents } from "../session-directive.mjs";
+import {
+  readStdin, parseStdin, getSessionId, getSessionDBPath, getSessionEventsPath, getCleanupFlagPath,
+  getInputProjectDir, JETBRAINS_OPTS,
+} from "../session-helpers.mjs";
+import { join } from "node:path";
+import { readFileSync, unlinkSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { homedir } from "node:os";
+
+const HOOK_DIR = fileURLToPath(new URL(".", import.meta.url));
+const { loadSessionDB } = createSessionLoaders(HOOK_DIR);
+const OPTS = JETBRAINS_OPTS;
+
+let additionalContext = ROUTING_BLOCK;
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const source = input.source ?? "startup";
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  if (source === "compact") {
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS, projectDir);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+    const resume = db.getResume(sessionId);
+
+    if (resume && !resume.consumed) {
+      db.markResumeConsumed(sessionId);
+    }
+
+    const events = getSessionEvents(db, sessionId);
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS, projectDir));
+      additionalContext += buildSessionDirective("compact", eventMeta, toolNamer);
+    }
+
+    db.close();
+  } else if (source === "resume") {
+    try { unlinkSync(getCleanupFlagPath(OPTS, projectDir)); } catch { /* no flag */ }
+
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS, projectDir);
+    const db = new SessionDB({ dbPath });
+
+    // Filter events to the session being resumed. Falling back to
+    // getLatestSessionEvents(db) leaks events from any other session whose
+    // session_meta.started_at is more recent — observed cross-session bleed
+    // when a different session started after this one and before the resume.
+    const sessionId = getSessionId(input, OPTS);
+    const events = sessionId ? getSessionEvents(db, sessionId) : [];
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS, projectDir));
+      additionalContext += buildSessionDirective("resume", eventMeta, toolNamer);
+    }
+
+    db.close();
+  } else if (source === "startup") {
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS, projectDir);
+    const db = new SessionDB({ dbPath });
+    try { unlinkSync(getSessionEventsPath(OPTS, projectDir)); } 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);
+
+    const ruleFilePaths = [
+      join(projectDir, ".github", "copilot-instructions.md"),
+    ];
+    for (const p of ruleFilePaths) {
+      try {
+        const content = readFileSync(p, "utf-8");
+        if (content.trim()) {
+          db.insertEvent(sessionId, { type: "rule", category: "rule", data: p, priority: 1 });
+          db.insertEvent(sessionId, { type: "rule_content", category: "rule", data: content, priority: 1 });
+        }
+      } catch { /* file doesn't exist — skip */ }
+    }
+
+    db.close();
+  }
+  // "clear" — no action needed
+} catch (err) {
+  try {
+    const { appendFileSync } = await import("node:fs");
+    const { join: pjoin } = await import("node:path");
+    const { homedir: hd } = await import("node:os");
+    appendFileSync(
+      pjoin(hd(), ".config", "JetBrains", "context-mode", "sessionstart-debug.log"),
+      `[${new Date().toISOString()}] ${err?.message || err}\n${err?.stack || ""}\n`,
+    );
+  } catch { /* ignore logging failure */ }
+}
+
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: "SessionStart",
+    additionalContext,
+  },
+}));

package/hooks/kimi/platform.mjs

@@ -0,0 +1 @@
+process.env.CONTEXT_MODE_PLATFORM = "kimi";

package/hooks/kimi/posttooluse.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import "./platform.mjs";
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Kimi Code CLI postToolUse hook — session event capture.
+ */
+
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, KIMI_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 = KIMI_OPTS;
+
+function normalizeToolName(toolName) {
+  if (toolName === "Shell") return "Bash";
+  return toolName;
+}
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  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);
+
+  // Kimi Code sends tool_output on success (no tool_response field).
+  // Normalize tool_response to a clean string — when the host omits it,
+  // surface the empty string rather than `JSON.stringify(undefined ?? "")`
+  // which yields `'""'` and tricks downstream extractEvents into treating
+  // an empty response as a non-empty payload.
+  let toolResponse = "";
+  if (typeof input.tool_response === "string") {
+    toolResponse = input.tool_response;
+  } else if (input.tool_response !== undefined && input.tool_response !== null) {
+    toolResponse = JSON.stringify(input.tool_response);
+  }
+  const normalizedInput = {
+    tool_name: normalizeToolName(input.tool_name ?? ""),
+    tool_input: input.tool_input ?? {},
+    tool_response: toolResponse,
+    tool_output: input.tool_output
+      ? {
+        ...input.tool_output,
+        isError: input.tool_output.isError === true || input.tool_output.is_error === true,
+      }
+      : undefined,
+  };
+
+  const events = extractEvents(normalizedInput);
+
+  attributeAndInsertEvents(db, sessionId, events, input, projectDir, "PostToolUse", resolveProjectAttributions);
+
+  db.close();
+} catch {
+  // Swallow errors — hook must not fail
+}
+
+process.stdout.write(JSON.stringify({
+  hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: "" },
+}) + "\n");

package/hooks/kimi/precompact.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import "./platform.mjs";
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Kimi Code CLI PreCompact hook - snapshot generation.
+ */
+
+import {
+  readStdin,
+  parseStdin,
+  getSessionId,
+  getSessionDBPath,
+  getInputProjectDir,
+  resolveConfigDir,
+  KIMI_OPTS,
+} from "../session-helpers.mjs";
+import { createSessionLoaders } from "../session-loaders.mjs";
+import { appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadSnapshot } = createSessionLoaders(HOOK_DIR);
+const OPTS = KIMI_OPTS;
+// Diagnostic log is opt-in via CONTEXT_MODE_DEBUG. Long-running installs hit
+// compaction repeatedly; an unbounded append-only file under the user's data
+// root accrues on every transient error. Gating the write behind an env flag
+// preserves the diagnostic for contributors who want it without burdening
+// everyone else's disk. Match the pattern used by other hooks for error
+// telemetry — most stay silent unless explicitly enabled.
+const DEBUG_LOG = process.env.CONTEXT_MODE_DEBUG
+  ? join(resolveConfigDir(OPTS), "context-mode", "precompact-debug.log")
+  : null;
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const { buildResumeSnapshot } = await loadSnapshot();
+  const { SessionDB } = await loadSessionDB();
+
+  const dbPath = getSessionDBPath(OPTS, projectDir);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  const events = db.getEvents(sessionId);
+
+  if (events.length > 0) {
+    const stats = db.getSessionStats(sessionId);
+    const snapshot = buildResumeSnapshot(events, {
+      compactCount: (stats?.compact_count ?? 0) + 1,
+    });
+
+    db.upsertResume(sessionId, snapshot, events.length);
+    db.incrementCompactCount(sessionId);
+
+    const fileEvents = events.filter((event) => event.category === "file");
+    db.insertEvent(sessionId, {
+      type: "compaction_summary",
+      category: "compaction",
+      data: `Session compacted. ${events.length} events, ${fileEvents.length} files touched.`,
+      priority: 1,
+    }, "PreCompact");
+  }
+
+  db.close();
+} catch (err) {
+  if (DEBUG_LOG) {
+    try {
+      appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ${err?.message || err}\n`);
+    } catch {
+      // Hook errors must not break Kimi Code compaction.
+    }
+  }
+  // Without CONTEXT_MODE_DEBUG, swallow silently — same shape as other hooks.
+}
+
+process.stdout.write(JSON.stringify({}) + "\n");

package/hooks/kimi/pretooluse.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import "./platform.mjs";
+import "../suppress-stderr.mjs";
+/**
+ * Kimi Code CLI preToolUse hook for context-mode.
+ *
+ * Kimi Code PreToolUse supports:
+ *   - Exit code 0 with JSON:
+ *     { hookSpecificOutput: { permissionDecision: "deny", permissionDecisionReason: "..." } }
+ *     → block the tool call
+ *   - Exit code 2 → block (stderr used as reason)
+ *
+ * Like Codex, Kimi Code only acts on `permissionDecision === "deny"` —
+ * `ask` / `allow + updatedInput` / `additionalContext` are explicitly stripped
+ * by the host's runner (refs/platforms/kimi-code/.../session/hooks/runner.ts:
+ * 36-39,162-178) and its HookResult type has no additionalContext field
+ * (types.ts:28-37). The central formatter at hooks/core/formatters.mjs
+ * therefore returns null for those branches; see the codex precedent at #225
+ * (commit 607dc70).
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readStdin, parseStdin, getInputProjectDir, getSessionId, KIMI_OPTS } from "../session-helpers.mjs";
+import { routePreToolUse, initSecurity } from "../core/routing.mjs";
+import { formatDecision } from "../core/formatters.mjs";
+
+const __hookDir = dirname(fileURLToPath(import.meta.url));
+await initSecurity(resolve(__hookDir, "..", "..", "build"));
+
+const raw = await readStdin();
+const input = parseStdin(raw);
+const tool = input.tool_name ?? "";
+const toolInput = input.tool_input ?? {};
+const projectDir = getInputProjectDir(input, KIMI_OPTS);
+
+const decision = routePreToolUse(tool, toolInput, projectDir, "kimi", getSessionId(input, KIMI_OPTS));
+const response = formatDecision("kimi", decision);
+const output = response ?? {
+  hookSpecificOutput: { hookEventName: "PreToolUse" },
+};
+process.stdout.write(JSON.stringify(output) + "\n");

package/hooks/kimi/sessionend.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import "./platform.mjs";
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Kimi Code CLI SessionEnd hook — record genuine session close.
+ *
+ * Wired to the upstream `SessionEnd` event, distinct from `Stop`:
+ *   refs/platforms/kimi-code/packages/agent-core/src/session/index.ts:
+ *     192  — `await this.triggerSessionEnd('exit')` inside `close()`
+ *     502  — `triggerSessionEnd(reason: 'exit')` signature
+ *     11   — `'SessionEnd'` in `HOOK_EVENT_TYPES` (types.ts)
+ *   refs/platforms/kimi-cli/src/kimi_cli/hooks/events.py:108-114 — Python
+ *     runtime emits `session_end(session_id, cwd, reason)` independently
+ *     of `Stop`.
+ *
+ * Stop fires at the end of every assistant turn — writing a `session_end`
+ * SessionDB row from Stop produced one such row per turn. SessionEnd
+ * fires once when the host's session closes, which is what consumers of
+ * `type === "session_end"` (analytics, resume) actually mean.
+ */
+
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, KIMI_OPTS } from "../session-helpers.mjs";
+import { createSessionLoaders } from "../session-loaders.mjs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB } = createSessionLoaders(HOOK_DIR);
+const OPTS = KIMI_OPTS;
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const { SessionDB } = await loadSessionDB();
+  const dbPath = getSessionDBPath(OPTS, projectDir);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  db.ensureSession(sessionId, projectDir);
+  // SessionEvent contract (src/types.ts:33-47) requires `type`, `category`,
+  // `data`, `priority`. Encode the payload — including `reason`, which
+  // upstream currently only emits as `'exit'` but is typed as a free string
+  // for forward compatibility — into `data` so dedup-hashing succeeds and
+  // the row lands.
+  const reason = typeof input.reason === "string" ? input.reason : "exit";
+  db.insertEvent(sessionId, {
+    type: "session_end",
+    category: "session",
+    data: JSON.stringify({ status: "completed", reason }),
+    priority: 1,
+  }, "SessionEnd");
+
+  db.close();
+} catch {
+  // Kimi Code hooks must not block session shutdown.
+}
+
+process.stdout.write("{}\n");