context-mode 0.9.21 → 1.0.0

package/hooks/session-directive.mjs

@@ -0,0 +1,353 @@
+/**
+ * Shared session directive builder for all platform adaptors.
+ *
+ * Contains: groupEvents, writeSessionEventsFile, buildSessionDirective, getAllProjectEvents.
+ * Each adaptor imports these instead of duplicating the logic.
+ */
+
+import { writeFileSync } from "node:fs";
+
+// ── Group events by category and extract metadata ──
+export function groupEvents(events) {
+  const grouped = {};
+  let lastPrompt = "";
+  for (const ev of events) {
+    if (ev.category === "prompt") {
+      lastPrompt = ev.data;
+      continue;
+    }
+    if (!grouped[ev.category]) grouped[ev.category] = [];
+    grouped[ev.category].push(ev);
+  }
+  const fileNames = new Set();
+  for (const ev of (grouped.file || [])) {
+    const path = ev.data.includes(" in ") ? ev.data.split(" in ").pop() : ev.data;
+    const base = path?.split(/[/\\]/).pop()?.trim();
+    if (base && !base.includes("*")) fileNames.add(base);
+  }
+  return { grouped, lastPrompt, fileNames };
+}
+
+// ── Write session events as markdown for FTS5 auto-indexing ──
+// Structured with H2 headings per category — optimal for FTS5 chunking.
+export function writeSessionEventsFile(events, eventsPath) {
+  const { grouped, lastPrompt, fileNames } = groupEvents(events);
+
+  const lines = [];
+  lines.push("# Session Resume");
+  lines.push("");
+  lines.push(`Events: ${events.length} | Timestamp: ${new Date().toISOString()}`);
+  lines.push("");
+
+  if (fileNames.size > 0) {
+    lines.push("## Active Files");
+    lines.push("");
+    for (const name of fileNames) lines.push(`- ${name}`);
+    lines.push("");
+  }
+
+  if (grouped.rule?.length > 0) {
+    lines.push("## Project Rules");
+    lines.push("");
+    for (const ev of grouped.rule) {
+      if (ev.type === "rule_content") {
+        const downgraded = ev.data.replace(/^(#{1,3}) /gm, (_, hashes) => "#".repeat(hashes.length + 3) + " ");
+        lines.push(downgraded);
+        lines.push("");
+      } else {
+        lines.push(`- ${ev.data}`);
+      }
+    }
+    lines.push("");
+  }
+
+  if (grouped.task?.length > 0) {
+    lines.push("## Tasks In Progress");
+    lines.push("");
+    for (const ev of grouped.task) lines.push(`- ${ev.data}`);
+    lines.push("");
+  }
+
+  if (grouped.decision?.length > 0) {
+    lines.push("## User Decisions");
+    lines.push("");
+    for (const ev of grouped.decision) lines.push(`- ${ev.data}`);
+    lines.push("");
+  }
+
+  if (grouped.git?.length > 0) {
+    lines.push("## Git Operations");
+    lines.push("");
+    for (const ev of grouped.git) lines.push(`- ${ev.data}`);
+    lines.push("");
+  }
+
+  if (grouped.env?.length > 0 || grouped.cwd?.length > 0) {
+    lines.push("## Environment");
+    lines.push("");
+    if (grouped.cwd?.length > 0) {
+      lines.push(`- cwd: ${grouped.cwd[grouped.cwd.length - 1].data}`);
+    }
+    for (const ev of (grouped.env || [])) lines.push(`- ${ev.data}`);
+    lines.push("");
+  }
+
+  if (grouped.error?.length > 0) {
+    lines.push("## Errors Encountered");
+    lines.push("");
+    for (const ev of grouped.error) lines.push(`- ${ev.data}`);
+    lines.push("");
+  }
+
+  if (grouped.mcp?.length > 0) {
+    const toolCounts = {};
+    for (const ev of grouped.mcp) {
+      const tool = ev.data.split(":")[0].trim();
+      toolCounts[tool] = (toolCounts[tool] || 0) + 1;
+    }
+    lines.push("## MCP Tool Usage");
+    lines.push("");
+    for (const [tool, count] of Object.entries(toolCounts)) {
+      lines.push(`- ${tool}: ${count} calls`);
+    }
+    lines.push("");
+  }
+
+  if (grouped.subagent?.length > 0) {
+    lines.push("## Subagent Tasks");
+    lines.push("");
+    for (const ev of grouped.subagent) lines.push(`- ${ev.data}`);
+    lines.push("");
+  }
+
+  if (grouped.skill?.length > 0) {
+    const uniqueSkills = new Set(grouped.skill.map(e => e.data));
+    lines.push("## Active Skills");
+    lines.push("");
+    lines.push(`- ${[...uniqueSkills].join(", ")}`);
+    lines.push("");
+  }
+
+  if (grouped.intent?.length > 0) {
+    lines.push("## Session Intent");
+    lines.push("");
+    lines.push(`- ${grouped.intent[grouped.intent.length - 1].data}`);
+    lines.push("");
+  }
+
+  if (grouped.role?.length > 0) {
+    lines.push("## User Role");
+    lines.push("");
+    lines.push(`- ${grouped.role[grouped.role.length - 1].data}`);
+    lines.push("");
+  }
+
+  if (grouped.data?.length > 0) {
+    lines.push("## Data References");
+    lines.push("");
+    for (const ev of grouped.data) lines.push(`- ${ev.data}`);
+    lines.push("");
+  }
+
+  if (lastPrompt) {
+    lines.push("## Last User Prompt");
+    lines.push("");
+    lines.push(lastPrompt);
+    lines.push("");
+  }
+
+  writeFileSync(eventsPath, lines.join("\n"), "utf-8");
+  return { grouped, lastPrompt, fileNames };
+}
+
+// ── Build session guide — actionable narrative for LLM to continue from ──
+export function buildSessionDirective(source, eventMeta) {
+  const { grouped, lastPrompt, fileNames } = eventMeta;
+  const isCompact = source === "compact";
+
+  let block = `\n<session_knowledge source="${isCompact ? "compact" : "continue"}">`;
+  block += `\n<session_guide>`;
+
+  // 1. Last request — most critical for continuation
+  if (lastPrompt) {
+    // Truncate overly long prompts — keep first 300 chars as summary
+    const displayPrompt = lastPrompt.length > 300
+      ? lastPrompt.substring(0, 297) + "..."
+      : lastPrompt;
+    block += `\n## Last Request`;
+    block += `\n${displayPrompt}`;
+    block += `\n`;
+  }
+
+  // 2. Tasks — parsed into readable format with status
+  // TaskCreate events have {subject} but no taskId.
+  // TaskUpdate events have {taskId, status} but no subject.
+  // Match by chronological order: creates[0] → lowest taskId from updates.
+  if (grouped.task?.length > 0) {
+    const creates = [];
+    const updates = {};
+
+    for (const ev of grouped.task) {
+      try {
+        const parsed = JSON.parse(ev.data);
+        if (parsed.subject) {
+          creates.push(parsed.subject);
+        } else if (parsed.taskId && parsed.status) {
+          updates[parsed.taskId] = parsed.status;
+        }
+      } catch { /* not JSON */ }
+    }
+
+    if (creates.length > 0) {
+      const sortedIds = Object.keys(updates).sort((a, b) => Number(a) - Number(b));
+      block += `\n## Tasks`;
+      for (let i = 0; i < creates.length; i++) {
+        const matchedId = sortedIds[i];
+        const status = matchedId ? (updates[matchedId] || "pending") : "pending";
+        const mark = status === "completed" ? "x" : " ";
+        block += `\n- [${mark}] ${creates[i]}`;
+      }
+      block += `\n`;
+    }
+  }
+
+  // 3. Key decisions
+  if (grouped.decision?.length > 0) {
+    block += `\n## Key Decisions`;
+    for (const ev of grouped.decision) {
+      const text = ev.data.length > 150 ? ev.data.substring(0, 147) + "..." : ev.data;
+      block += `\n- ${text}`;
+    }
+    block += `\n`;
+  }
+
+  // 4. Files modified
+  if (fileNames.size > 0) {
+    block += `\n## Files Modified`;
+    block += `\n${[...fileNames].join(", ")}`;
+    block += `\n`;
+  }
+
+  // 5. Errors
+  if (grouped.error?.length > 0) {
+    block += `\n## Unresolved Errors`;
+    for (const ev of grouped.error) {
+      const text = ev.data.length > 150 ? ev.data.substring(0, 147) + "..." : ev.data;
+      block += `\n- ${text}`;
+    }
+    block += `\n`;
+  }
+
+  // 6. Git state
+  if (grouped.git?.length > 0) {
+    const uniqueOps = [...new Set(grouped.git.map(e => e.data))];
+    block += `\n## Git`;
+    block += `\n${uniqueOps.join(", ")}`;
+    block += `\n`;
+  }
+
+  // 7. Project rules (paths only)
+  if (grouped.rule?.length > 0) {
+    const rPaths = grouped.rule
+      .filter(e => e.type !== "rule_content")
+      .map(e => {
+        const parts = e.data.split(/[/\\]/);
+        return parts.slice(-2).join("/");
+      });
+    const uniquePaths = [...new Set(rPaths)];
+    if (uniquePaths.length > 0) {
+      block += `\n## Project Rules`;
+      block += `\n${uniquePaths.join(", ")}`;
+      block += `\n`;
+    }
+  }
+
+  // 8. MCP tools used
+  if (grouped.mcp?.length > 0) {
+    const toolCounts = {};
+    for (const ev of grouped.mcp) {
+      const tool = ev.data.split(":")[0].trim();
+      toolCounts[tool] = (toolCounts[tool] || 0) + 1;
+    }
+    block += `\n## MCP Tools Used`;
+    block += `\n${Object.entries(toolCounts).map(([t, c]) => `${t}(${c})`).join(", ")}`;
+    block += `\n`;
+  }
+
+  // 9. Subagent tasks
+  if (grouped.subagent?.length > 0) {
+    block += `\n## Subagent Tasks`;
+    for (const ev of grouped.subagent) {
+      const text = ev.data.length > 120 ? ev.data.substring(0, 117) + "..." : ev.data;
+      block += `\n- ${text}`;
+    }
+    block += `\n`;
+  }
+
+  // 10. Skills invoked
+  if (grouped.skill?.length > 0) {
+    const uniqueSkills = [...new Set(grouped.skill.map(e => e.data))];
+    block += `\n## Skills Used`;
+    block += `\n${uniqueSkills.join(", ")}`;
+    block += `\n`;
+  }
+
+  // 11. Environment
+  if (grouped.env?.length > 0 || grouped.cwd?.length > 0) {
+    block += `\n## Environment`;
+    if (grouped.cwd?.length > 0) {
+      block += `\ncwd: ${grouped.cwd[grouped.cwd.length - 1].data}`;
+    }
+    for (const ev of (grouped.env || [])) {
+      block += `\n${ev.data}`;
+    }
+    block += `\n`;
+  }
+
+  // 12. Data references
+  if (grouped.data?.length > 0) {
+    block += `\n## Data References`;
+    for (const ev of grouped.data) {
+      const text = ev.data.length > 150 ? ev.data.substring(0, 147) + "..." : ev.data;
+      block += `\n- ${text}`;
+    }
+    block += `\n`;
+  }
+
+  // 13. Intent / Role (if set)
+  if (grouped.intent?.length > 0) {
+    block += `\n## Session Intent`;
+    block += `\n${grouped.intent[grouped.intent.length - 1].data}`;
+    block += `\n`;
+  }
+  if (grouped.role?.length > 0) {
+    block += `\n## User Role`;
+    block += `\n${grouped.role[grouped.role.length - 1].data}`;
+    block += `\n`;
+  }
+
+  block += `\n</session_guide>`;
+
+  // Search on demand — detailed data lives in FTS5
+  block += `\n<session_search>`;
+  block += `\nDetailed session data is indexed in context-mode FTS5 (source: "session-events").`;
+  block += `\nUse mcp__plugin_context-mode_context-mode__ctx_search(queries: [...], source: "session-events") when you need specifics.`;
+  block += `\nDo NOT call ctx_index() — data is already indexed.`;
+  block += `\n</session_search>`;
+
+  // Continue instruction
+  if (lastPrompt && isCompact) {
+    block += `\n<continue_from>Continue working on the last request. Do NOT ask the user to repeat themselves.</continue_from>`;
+  }
+
+  block += `\n</session_knowledge>`;
+  return block;
+}
+
+// ── Get ALL events for this project (across all session_ids) ──
+export function getAllProjectEvents(db) {
+  return db.db.prepare(
+    `SELECT session_id, type, category, priority, data, source_hook, created_at
+     FROM session_events ORDER BY created_at ASC`
+  ).all();
+}

package/hooks/session-helpers.mjs

@@ -0,0 +1,112 @@
+/**
+ * Shared session helpers for context-mode hooks.
+ * Used by posttooluse.mjs, precompact.mjs, sessionstart.mjs,
+ * and platform-specific hooks (Gemini CLI, VS Code Copilot).
+ *
+ * All functions accept an optional `opts` parameter for platform-specific
+ * configuration. Defaults to Claude Code settings for backward compatibility.
+ */
+
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+
+/** Claude Code platform options (default). */
+const CLAUDE_OPTS = {
+  configDir: ".claude",
+  projectDirEnv: "CLAUDE_PROJECT_DIR",
+  sessionIdEnv: "CLAUDE_SESSION_ID",
+};
+
+/** Gemini CLI platform options. */
+export const GEMINI_OPTS = {
+  configDir: ".gemini",
+  projectDirEnv: "GEMINI_PROJECT_DIR",
+  sessionIdEnv: undefined,
+};
+
+/** VS Code Copilot platform options. */
+export const VSCODE_OPTS = {
+  configDir: ".vscode",
+  projectDirEnv: "VSCODE_CWD",
+  sessionIdEnv: undefined,
+};
+
+/**
+ * Read all of stdin as a string (event-based, cross-platform safe).
+ */
+export function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => { data += chunk; });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", reject);
+    process.stdin.resume();
+  });
+}
+
+/**
+ * Get the project directory for the current platform.
+ * Uses the platform-specific env var, falls back to cwd.
+ */
+export function getProjectDir(opts = CLAUDE_OPTS) {
+  return process.env[opts.projectDirEnv] || process.cwd();
+}
+
+/**
+ * Derive session ID from hook input.
+ * Priority: transcript_path UUID > sessionId (camelCase) > session_id > env var > ppid fallback.
+ */
+export function getSessionId(input, opts = CLAUDE_OPTS) {
+  if (input.transcript_path) {
+    const match = input.transcript_path.match(/([a-f0-9-]{36})\.jsonl$/);
+    if (match) return match[1];
+  }
+  if (input.sessionId) return input.sessionId;
+  if (input.session_id) return input.session_id;
+  if (opts.sessionIdEnv && process.env[opts.sessionIdEnv]) {
+    return process.env[opts.sessionIdEnv];
+  }
+  return `pid-${process.ppid}`;
+}
+
+/**
+ * Return the per-project session DB path.
+ * Creates the directory if it doesn't exist.
+ * Path: ~/<configDir>/context-mode/sessions/<SHA256(projectDir)[:16]>.db
+ */
+export function getSessionDBPath(opts = CLAUDE_OPTS) {
+  const projectDir = getProjectDir(opts);
+  const hash = createHash("sha256").update(projectDir).digest("hex").slice(0, 16);
+  const dir = join(homedir(), opts.configDir, "context-mode", "sessions");
+  mkdirSync(dir, { recursive: true });
+  return join(dir, `${hash}.db`);
+}
+
+/**
+ * Return the per-project session events file path.
+ * Used by sessionstart hook (write) and MCP server (read + auto-index).
+ * Path: ~/<configDir>/context-mode/sessions/<SHA256(projectDir)[:16]>-events.md
+ */
+export function getSessionEventsPath(opts = CLAUDE_OPTS) {
+  const projectDir = getProjectDir(opts);
+  const hash = createHash("sha256").update(projectDir).digest("hex").slice(0, 16);
+  const dir = join(homedir(), opts.configDir, "context-mode", "sessions");
+  mkdirSync(dir, { recursive: true });
+  return join(dir, `${hash}-events.md`);
+}
+
+/**
+ * Return the per-project cleanup flag path.
+ * Used to detect true fresh starts vs --continue (which fires startup+resume).
+ * Path: ~/<configDir>/context-mode/sessions/<SHA256(projectDir)[:16]>.cleanup
+ */
+export function getCleanupFlagPath(opts = CLAUDE_OPTS) {
+  const projectDir = getProjectDir(opts);
+  const hash = createHash("sha256").update(projectDir).digest("hex").slice(0, 16);
+  const dir = join(homedir(), opts.configDir, "context-mode", "sessions");
+  mkdirSync(dir, { recursive: true });
+  return join(dir, `${hash}.cleanup`);
+}

package/hooks/sessionstart.mjs

@@ -3,28 +3,135 @@
  * SessionStart hook for context-mode
  *
  * Provides the agent with XML-structured "Rules of Engagement"
- * at the beginning of each session, encouraging autonomous use
- * of context-mode MCP tools over raw Bash/Read/WebFetch.
+ * at the beginning of each session. Injects session knowledge on
+ * both startup and compact to maintain continuity.
+ *
+ * Session Lifecycle Rules:
+ * - "startup"  → Fresh session. Inject previous session knowledge. Cleanup old data.
+ * - "compact"  → Auto-compact triggered. Inject resume snapshot + stats.
+ * - "resume"   → User used --continue. Full history, no resume needed.
+ * - "clear"    → User cleared context. No resume.
  */
 
 import { ROUTING_BLOCK } from "./routing-block.mjs";
+import { readStdin, getSessionId, getSessionDBPath, getSessionEventsPath, getCleanupFlagPath } from "./session-helpers.mjs";
+import { writeSessionEventsFile, buildSessionDirective, getAllProjectEvents } from "./session-directive.mjs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+
+// Resolve absolute path for imports (fileURLToPath for Windows compat)
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const PKG_SESSION = join(HOOK_DIR, "..", "build", "session");
+
+let additionalContext = ROUTING_BLOCK;
+
+try {
+  const raw = await readStdin();
+  const input = JSON.parse(raw);
+  const source = input.source ?? "startup";
+
+  if (source === "compact") {
+    // Session was compacted — write events to file for auto-indexing, inject directive only
+    const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+    const dbPath = getSessionDBPath();
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input);
+    const resume = db.getResume(sessionId);
+
+    if (resume && !resume.consumed) {
+      db.markResumeConsumed(sessionId);
+    }
+
+    const events = getAllProjectEvents(db);
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath());
+      additionalContext += buildSessionDirective("compact", eventMeta);
+    }
+
+    db.close();
+  } else if (source === "resume") {
+    // User used --continue — clear cleanup flag so startup doesn't wipe data
+    try { unlinkSync(getCleanupFlagPath()); } catch { /* no flag */ }
+
+    const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+    const dbPath = getSessionDBPath();
+    const db = new SessionDB({ dbPath });
+
+    const events = getAllProjectEvents(db);
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath());
+      additionalContext += buildSessionDirective("resume", eventMeta);
+    }
+
+    db.close();
+  } else if (source === "startup") {
+    // Fresh session (no --continue) — clean slate, capture CLAUDE.md rules.
+    const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+    const dbPath = getSessionDBPath();
+    const db = new SessionDB({ dbPath });
+    try { unlinkSync(getSessionEventsPath()); } catch { /* no stale file */ }
+
+    // Detect true fresh start vs --continue (which fires startup→resume).
+    // If cleanup flag exists from a PREVIOUS startup that was never followed by
+    // resume, that was a true fresh start — aggressively wipe all data.
+    const cleanupFlag = getCleanupFlagPath();
+    let previousWasFresh = false;
+    try { readFileSync(cleanupFlag); previousWasFresh = true; } catch { /* no flag */ }
+
+    if (previousWasFresh) {
+      // Previous session was a true fresh start (no --continue) — clean slate
+      db.cleanupOldSessions(0);
+    } else {
+      // First startup or --continue will follow — only clean old sessions
+      db.cleanupOldSessions(7);
+    }
+    db.db.exec(`DELETE FROM session_events WHERE session_id NOT IN (SELECT session_id FROM session_meta)`);
+
+    // Write cleanup flag — resume will delete it if --continue follows
+    writeFileSync(cleanupFlag, new Date().toISOString(), "utf-8");
+
+    // Proactively capture CLAUDE.md files — Claude Code loads them as system
+    // context at startup, invisible to PostToolUse hooks. We read them from
+    // disk so they survive compact/resume via the session events pipeline.
+    const sessionId = getSessionId(input);
+    const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    db.ensureSession(sessionId, projectDir);
+    const claudeMdPaths = [
+      join(homedir(), ".claude", "CLAUDE.md"),
+      join(projectDir, "CLAUDE.md"),
+      join(projectDir, ".claude", "CLAUDE.md"),
+    ];
+    for (const p of claudeMdPaths) {
+      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) {
+  // Session continuity is best-effort — never block session start
+  try {
+    const { appendFileSync } = await import("node:fs");
+    const { join: pjoin } = await import("node:path");
+    const { homedir } = await import("node:os");
+    appendFileSync(
+      pjoin(homedir(), ".claude", "context-mode", "sessionstart-debug.log"),
+      `[${new Date().toISOString()}] ${err?.message || err}\n${err?.stack || ""}\n`,
+    );
+  } catch { /* ignore logging failure */ }
+}
 
-// Event-based flowing mode avoids two platform bugs:
-// - `for await (process.stdin)` hangs on macOS when piped via spawnSync
-// - `readFileSync(0)` throws EOF/EISDIR on Windows, EAGAIN on Linux
-const raw = await new Promise((resolve, reject) => {
-  let data = "";
-  process.stdin.setEncoding("utf-8");
-  process.stdin.on("data", (chunk) => { data += chunk; });
-  process.stdin.on("end", () => resolve(data));
-  process.stdin.on("error", reject);
-  process.stdin.resume();
-});
-
-// Output the routing block as additionalContext
 console.log(JSON.stringify({
   hookSpecificOutput: {
     hookEventName: "SessionStart",
-    additionalContext: ROUTING_BLOCK,
+    additionalContext,
   },
 }));

package/hooks/userpromptsubmit.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit hook for context-mode session continuity.
+ *
+ * Captures every user prompt so the LLM can continue from the exact
+ * point where the user left off after compact or session restart.
+ *
+ * Must be fast (<10ms). Just a single SQLite write.
+ */
+
+import { readStdin, getSessionId, getSessionDBPath } from "./session-helpers.mjs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const PKG_SESSION = join(HOOK_DIR, "..", "build", "session");
+
+try {
+  const raw = await readStdin();
+  const input = JSON.parse(raw);
+
+  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 import(join(PKG_SESSION, "db.js"));
+    const { extractUserEvents } = await import(join(PKG_SESSION, "extract.js"));
+    const dbPath = getSessionDBPath();
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input);
+
+    db.ensureSession(sessionId, process.env.CLAUDE_PROJECT_DIR || process.cwd());
+
+    // 1. Always save the raw prompt
+    db.insertEvent(sessionId, {
+      type: "user_prompt",
+      category: "prompt",
+      data: prompt,
+      priority: 1,
+    }, "UserPromptSubmit");
+
+    // 2. Extract decision/role/intent/data from user message
+    const userEvents = extractUserEvents(trimmed);
+    for (const ev of userEvents) {
+      db.insertEvent(sessionId, ev, "UserPromptSubmit");
+    }
+
+    db.close();
+  }
+} catch {
+  // UserPromptSubmit must never block the session — silent fallback
+}