@mxalbert/context-mode 2.0.0

package/hooks/kimi/sessionstart.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import "./platform.mjs";
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Kimi Code CLI sessionStart hook for context-mode.
+ */
+
+import { createRoutingBlock } from "../routing-block.mjs";
+import { createToolNamer } from "../core/tool-naming.mjs";
+
+const toolNamer = createToolNamer("kimi");
+const ROUTING_BLOCK = createRoutingBlock(toolNamer);
+import {
+  writeSessionEventsFile,
+  buildSessionDirective,
+  getSessionEvents,
+} from "../session-directive.mjs";
+import {
+  readStdin,
+  parseStdin,
+  getSessionId,
+  getSessionDBPath,
+  getSessionEventsPath,
+  getCleanupFlagPath,
+  getInputProjectDir,
+  resolveConfigDir,
+  KIMI_OPTS,
+} from "../session-helpers.mjs";
+import { createSessionLoaders } from "../session-loaders.mjs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = fileURLToPath(new URL(".", import.meta.url));
+const { loadSessionDB } = createSessionLoaders(HOOK_DIR);
+const OPTS = KIMI_OPTS;
+
+let additionalContext = ROUTING_BLOCK;
+
+function captureKimiInstructionRules(db, sessionId, projectDir) {
+  const paths = [];
+  for (const baseDir of [resolveConfigDir(OPTS), projectDir]) {
+    paths.push(join(baseDir, "AGENTS.md"));
+    paths.push(join(baseDir, "AGENTS.override.md"));
+  }
+
+  for (const p of [...new Set(paths)]) {
+    try {
+      if (!existsSync(p)) continue;
+      const content = readFileSync(p, "utf8");
+      db.insertEvent(sessionId, { type: "rule", category: "rule", data: p, priority: 1 });
+      db.insertEvent(sessionId, { type: "rule_content", category: "rule", data: content, priority: 1 });
+    } catch {
+      // Missing or unreadable rule files should never break SessionStart.
+    }
+  }
+}
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  // Kimi Code emits ONLY 'startup' | 'resume' for SessionStart.source:
+  //   refs/platforms/kimi-code/.../session/index.ts:153,181,495
+  //     (triggerSessionStart signature is `source: 'startup' | 'resume'`)
+  //   refs/platforms/kimi-cli/src/kimi_cli/cli/__init__.py:642
+  //     (`_session_source = "resume" if resumed else "startup"`)
+  // Default unknown values to 'startup' rather than branching on a
+  // 'compact' path that the host never reaches.
+  const source = input.source === "resume" ? "resume" : "startup";
+  const projectDir = getInputProjectDir(input, KIMI_OPTS);
+
+  if (source === "resume") {
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS, projectDir);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+
+    try { unlinkSync(getCleanupFlagPath(OPTS, projectDir)); } catch { /* no flag */ }
+
+    const events = sessionId ? getSessionEvents(db, sessionId) : [];
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS, projectDir));
+      additionalContext += buildSessionDirective(source, eventMeta, toolNamer);
+    }
+
+    db.close();
+  } else {
+    // 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);
+    // Single source of truth lives in SessionDB. Reaching through `db.db.exec`
+    // duplicated schema knowledge in the hook and would silently drift if
+    // `session_events` ever renamed its FK column.
+    db.pruneOrphanedEvents();
+
+    const sessionId = getSessionId(input, OPTS);
+    db.ensureSession(sessionId, projectDir);
+    captureKimiInstructionRules(db, sessionId, projectDir);
+
+    db.close();
+  }
+} catch {
+  // Swallow errors — hook must not fail
+}
+
+process.stdout.write(JSON.stringify({
+  hookSpecificOutput: { hookEventName: "SessionStart", additionalContext },
+}) + "\n");

package/hooks/kimi/stop.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import "./platform.mjs";
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Kimi Code CLI Stop hook — record turn-end state for continuity.
+ *
+ * Stop fires at the END OF EACH ASSISTANT TURN, not at session close.
+ * Kimi Code emits a distinct `SessionEnd` event for genuine session
+ * shutdown (refs/platforms/kimi-code/.../session/index.ts:192,502 —
+ * `triggerSessionEnd('exit')`); the matching `hooks/kimi/sessionend.mjs`
+ * owns the `session_end` SessionDB row. Writing `session_end` here would
+ * have produced one such row per turn.
+ *   Cross-reference: refs/platforms/kimi-cli/src/kimi_cli/hooks/events.py:
+ *     99-114 — `session_start` and `session_end` are distinct emitters.
+ */
+
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, KIMI_OPTS } from "../session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+import { existsSync, readFileSync } from "node:fs";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+const OPTS = KIMI_OPTS;
+
+/**
+ * Resolve <kimiConfigDir> (mirrors src/adapters/kimi/paths.ts:resolveKimiConfigDir
+ * — hooks cannot import the TS module, so the logic is duplicated here).
+ */
+function resolveKimiConfigDir() {
+  const envVal = process.env.KIMI_CODE_HOME;
+  if (envVal) {
+    if (envVal.startsWith("~")) return resolve(homedir(), envVal.replace(/^~[/\\]?/, ""));
+    return resolve(envVal);
+  }
+  return resolve(homedir(), ".kimi-code");
+}
+
+/**
+ * Best-effort <sessionDir>/wire.jsonl resolution keyed by session id.
+ *
+ * NOTE / WIRE GAP: adapter-matrix/kimi.md confirms usage lands at
+ * <sessionDir>/wire.jsonl (agent/index.ts:142), but the exact session_id ->
+ * sessionDir directory layout is not carried in the hook stdin payload and the
+ * kimi-code refs are not checked out in this worktree to pin it. We probe the
+ * documented candidate layouts and return the first whose wire.jsonl exists,
+ * else null -> the cost block degrades to a no-op rather than guessing wrong.
+ */
+function resolveKimiWireJsonlPath(sessionId) {
+  if (typeof sessionId !== "string" || sessionId.length === 0) return null;
+  const configDir = resolveKimiConfigDir();
+  const candidates = [
+    join(configDir, "sessions", sessionId, "wire.jsonl"),
+    join(configDir, "agents", sessionId, "wire.jsonl"),
+    join(configDir, sessionId, "wire.jsonl"),
+  ];
+  for (const candidate of candidates) {
+    try { if (existsSync(candidate)) return candidate; } catch { /* try next */ }
+  }
+  return null;
+}
+
+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`. SessionDB.insertEvent hashes `event.data` for the
+  // dedup key — passing `undefined` throws inside the wrapping try and the
+  // row silently never lands. Encode the turn snapshot into `data` so the
+  // hash is stable and the row actually persists.
+  const payload = {
+    stop_hook_active: input.stop_hook_active ?? false,
+    last_assistant_message: typeof input.last_assistant_message === "string"
+      ? input.last_assistant_message.slice(0, 2000)
+      : null,
+  };
+  db.insertEvent(sessionId, {
+    type: "turn_end",
+    category: "session",
+    data: JSON.stringify(payload),
+    priority: 1,
+  }, "Stop");
+
+  // ─── kimi-code per-turn cost capture (cursor-gated, no double-count) ───
+  // Usage lives ONLY on <sessionDir>/wire.jsonl `usage.record` lines, never in
+  // hook stdin (adapter-matrix/kimi.md). Tail the file, sum NEW delta lines
+  // since a per-session high-water cursor, and forward. Best-effort — a missing
+  // wire file or read/extract failure must never block the turn_end write or
+  // the session, so the whole block is wrapped and swallowed.
+  try {
+    const wirePath = resolveKimiWireJsonlPath(sessionId);
+    if (wirePath) {
+      let wireText = null;
+      try {
+        wireText = readFileSync(wirePath, "utf-8");
+      } catch {
+        // unreadable/missing wire.jsonl — skip capture this turn.
+      }
+      if (wireText) {
+        const { extractKimiUsageSince } = await loadExtract();
+        const { resolveProjectAttributions } = await loadProjectAttribution();
+        const cursor = db.getUsageCursor(sessionId);
+        const { events, cursor: next } = extractKimiUsageSince(wireText, cursor);
+        if (events.length > 0) {
+          // attributeAndInsertEvents both INSERTS locally and FORWARDS to the
+          // platform (gated on ~/.context-mode/platform.json).
+          attributeAndInsertEvents(db, sessionId, events, input, projectDir, "Stop", resolveProjectAttributions);
+        }
+        if (next) db.setUsageCursor(sessionId, next);
+      }
+    }
+  } catch {
+    // Best-effort cost capture — never block the session on failure.
+  }
+
+  db.close();
+} catch {
+  // Kimi Code hooks must not block the session.
+}
+
+process.stdout.write("{}\n");

package/hooks/kimi/userpromptsubmit.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import "./platform.mjs";
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Kimi Code CLI UserPromptSubmit hook — capture user prompts for continuity.
+ *
+ * Kimi Code sends `prompt` as a ContentPart[] array. We normalize it to
+ * a single string so downstream extractors work correctly.
+ */
+
+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 extractPromptText(input) {
+  const raw = input.prompt ?? input.message ?? "";
+  if (Array.isArray(raw)) {
+    // ContentPart[] — Kimi Code sends { type: "text", text: "..." } objects
+    return raw
+      .filter((p) => p && (p.type === "text" || typeof p.text === "string"))
+      .map((p) => p.text)
+      .join("\n");
+  }
+  return String(raw);
+}
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const prompt = extractPromptText(input);
+  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, projectDir);
+    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 {
+  // Kimi Code hooks must not block the session.
+}
+
+process.stdout.write(JSON.stringify({
+  hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: "" },
+}) + "\n");

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, projectDir);
+    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, projectDir)); } catch { /* no flag */ }
+    }
+
+    const sessionId = getSessionId(input, OPTS);
+    const events = sessionId ? getSessionEvents(db, sessionId) : [];
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS, projectDir));
+      additionalContext += buildSessionDirective(source, 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);
+
+    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/posttooluse.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Kiro CLI PostToolUse hook — session event capture.
+ * Must be fast (<20ms). No network, no LLM, just SQLite writes.
+ *
+ * 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 { extractEvents } = await loadExtract();
+  const { resolveProjectAttributions } = await loadProjectAttribution();
+  const { SessionDB } = await loadSessionDB();
+
+  const sessionId = getSessionId(input, OPTS);
+  const projectDir = getInputProjectDir(input, OPTS);
+  const dbPath = getSessionDBPath(OPTS, projectDir);
+  const db = new SessionDB({ dbPath });
+
+  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);
+
+  db.close();
+} catch {
+  // Non-blocking — swallow errors silently
+}
+
+// PostToolUse is non-blocking — no stdout output

package/hooks/kiro/pretooluse.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+/**
+ * Kiro CLI PreToolUse hook for context-mode.
+ * Uses exit codes instead of JSON stdout:
+ *   - Exit 0: allow (stdout → agent context)
+ *   - Exit 2: block (stderr → agent error)
+ *
+ * Source: https://kiro.dev/docs/cli/hooks/
+ */
+
+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 { parseStdin, getSessionId, KIRO_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);
+// Kiro stdin: { hook_event_name, cwd, tool_name, tool_input }
+const tool = input.tool_name ?? "";
+const toolInput = input.tool_input ?? {};
+const projectDir = input.cwd ?? process.cwd();
+
+const decision = routePreToolUse(tool, toolInput, projectDir, "kiro", getSessionId(input, KIRO_OPTS));
+
+if (!decision) process.exit(0);
+
+switch (decision.action) {
+  case "deny":
+    process.stderr.write(decision.reason ?? "Blocked by context-mode");
+    process.exit(2);
+    break;
+
+  case "modify":
+    // Kiro CLI cannot modify tool input — deny with redirect message
+    // The updatedInput.command contains an echo "..." wrapper — extract inner message
+    if (typeof decision.updatedInput?.command === "string") {
+      const msg = decision.updatedInput.command
+        .replace(/^echo\s+"?/, "")
+        .replace(/"?\s*$/, "");
+      process.stderr.write(msg);
+    } else {
+      process.stderr.write(decision.reason ?? "Blocked by context-mode routing");
+    }
+    process.exit(2);
+    break;
+
+  case "context":
+    process.stdout.write(decision.additionalContext ?? "");
+    process.exit(0);
+    break;
+
+  case "ask":
+    // Kiro CLI has no "ask" concept — passthrough
+    process.exit(0);
+    break;
+
+  default:
+    process.exit(0);
+}

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, projectDir);
+    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");