context-mode 1.0.106 → 1.0.108

package/build/opencode-plugin.d.ts

@@ -1,10 +1,12 @@
 /**
  * OpenCode / KiloCode TypeScript plugin entry point for context-mode.
  *
- * Provides three hooks:
+ * Provides five hooks (v1.0.107 — Mickey OC-1..OC-4 follow-up):
  *   - tool.execute.before  — Routing enforcement (deny/modify/passthrough)
- *   - tool.execute.after   — Session event capture
- *   - experimental.session.compacting — Compaction snapshot generation
+ *   - tool.execute.after   — Session event capture + first-fire AGENTS.md scan (OC-4)
+ *   - experimental.session.compacting — Compaction snapshot + budget-capped auto-injection (OC-3)
+ *   - experimental.chat.system.transform — ROUTING_BLOCK + resume snapshot injection (OC-1)
+ *   - chat.message         — User-prompt capture w/ CCv2 inline filter (OC-2)
  *
  * KiloCode loads this via: import("context-mode") → expects default export
  * with shape { server: (input) => Promise<Hooks> } (PluginModule).
@@ -14,7 +16,7 @@
  *
  * Constraints:
  *   - No SessionStart hook (OpenCode doesn't support it — #14808, #5409)
- *   - No context injection (canInjectSessionContext: false)
+ *   - context injection now via chat.system.transform surrogate (OC-1)
  *   - No routing file auto-write (avoid dirtying project trees)
  *   - Session cleanup happens at plugin init (no SessionStart)
  */
@@ -77,6 +79,28 @@ interface SystemTransformHookInput {
 interface SystemTransformHookOutput {
     system: string[];
 }
+/**
+ * OpenCode chat.message hook — verified against
+ * refs/platforms/opencode/packages/plugin/src/index.ts:233.
+ *   input:  { sessionID; agent?; model?; messageID?; variant? }
+ *   output: { message: UserMessage; parts: Part[] }
+ * We read text from `parts[*].text` (the orchestrator reference at
+ * refs/plugin-examples/opencode/opencode-orchestrator/src/plugin-handlers/
+ * chat-message-handler.ts:41-65 uses the same pattern).
+ */
+interface ChatMessageHookInput {
+    sessionID: string;
+    agent?: string;
+    messageID?: string;
+}
+interface ChatMessagePart {
+    type: string;
+    text?: string;
+}
+interface ChatMessageHookOutput {
+    message: unknown;
+    parts: ChatMessagePart[];
+}
 /**
  * Plugin factory. Called once when KiloCode/OpenCode loads the plugin.
  * Returns an object mapping hook event names to async handler functions.
@@ -87,6 +111,7 @@ interface SystemTransformHookOutput {
 declare function createContextModePlugin(ctx: PluginContext): Promise<{
     "tool.execute.before": (input: BeforeHookInput, output: BeforeHookOutput) => Promise<void>;
     "tool.execute.after": (input: AfterHookInput, output: AfterHookOutput) => Promise<void>;
+    "chat.message": (input: ChatMessageHookInput, output: ChatMessageHookOutput) => Promise<void>;
     "experimental.session.compacting": (input: CompactingHookInput, output: CompactingHookOutput) => Promise<string>;
     "experimental.chat.system.transform": (input: SystemTransformHookInput, output: SystemTransformHookOutput) => Promise<void>;
 }>;

package/build/opencode-plugin.js

@@ -1,10 +1,12 @@
 /**
  * OpenCode / KiloCode TypeScript plugin entry point for context-mode.
  *
- * Provides three hooks:
+ * Provides five hooks (v1.0.107 — Mickey OC-1..OC-4 follow-up):
  *   - tool.execute.before  — Routing enforcement (deny/modify/passthrough)
- *   - tool.execute.after   — Session event capture
- *   - experimental.session.compacting — Compaction snapshot generation
+ *   - tool.execute.after   — Session event capture + first-fire AGENTS.md scan (OC-4)
+ *   - experimental.session.compacting — Compaction snapshot + budget-capped auto-injection (OC-3)
+ *   - experimental.chat.system.transform — ROUTING_BLOCK + resume snapshot injection (OC-1)
+ *   - chat.message         — User-prompt capture w/ CCv2 inline filter (OC-2)
  *
  * KiloCode loads this via: import("context-mode") → expects default export
  * with shape { server: (input) => Promise<Hooks> } (PluginModule).
@@ -14,15 +16,15 @@
  *
  * Constraints:
  *   - No SessionStart hook (OpenCode doesn't support it — #14808, #5409)
- *   - No context injection (canInjectSessionContext: false)
+ *   - context injection now via chat.system.transform surrogate (OC-1)
  *   - No routing file auto-write (avoid dirtying project trees)
  *   - Session cleanup happens at plugin init (no SessionStart)
  */
-import { dirname, resolve } from "node:path";
+import { dirname, resolve, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { existsSync, readFileSync } from "node:fs";
 import { SessionDB } from "./session/db.js";
-import { extractEvents } from "./session/extract.js";
+import { extractEvents, extractUserEvents } from "./session/extract.js";
 import { buildResumeSnapshot } from "./session/snapshot.js";
 import { OpenCodeAdapter } from "./adapters/opencode/index.js";
 import { PLATFORM_ENV_VARS } from "./adapters/detect.js";
@@ -41,6 +43,19 @@ const VERSION = (() => {
     catch { /* fall through */ }
     return "unknown";
 })();
+// Synthetic message tags emitted by harnesses (CCv2 inline filter). When the
+// user "message" is actually a system-generated nudge (e.g. tool-result, system
+// reminder), capturing it as user_prompt would flood the DB with noise.
+const SYNTHETIC_MESSAGE_PREFIXES = [
+    "<task-notification>",
+    "<system-reminder>",
+    "<context_guidance>",
+    "<tool-result>",
+];
+function isSyntheticMessage(text) {
+    const trimmed = text.trim();
+    return SYNTHETIC_MESSAGE_PREFIXES.some((p) => trimmed.startsWith(p));
+}
 // ── Helpers ───────────────────────────────────────────────
 /**
  * Detect whether the plugin is running under KiloCode or OpenCode.
@@ -79,12 +94,27 @@ function getPlatform() {
  */
 async function createContextModePlugin(ctx) {
     // Resolve build dir from compiled JS location
-    const adapter = new OpenCodeAdapter(getPlatform());
+    const platform = getPlatform();
+    const adapter = new OpenCodeAdapter(platform);
     const buildDir = dirname(fileURLToPath(import.meta.url));
     // Load routing module (ESM .mjs, lives outside build/ in hooks/)
     const routingPath = resolve(buildDir, "..", "hooks", "core", "routing.mjs");
     const routing = await import(pathToFileURL(routingPath).href);
     await routing.initSecurity(buildDir);
+    // OC-1 / OC-3: Load hook helpers once at plugin init. Dynamic import keeps
+    // the .mjs ESM islands isolated from the .ts compile graph.
+    const routingBlockPath = resolve(buildDir, "..", "hooks", "routing-block.mjs");
+    const routingBlockMod = await import(pathToFileURL(routingBlockPath).href);
+    const toolNamingPath = resolve(buildDir, "..", "hooks", "core", "tool-naming.mjs");
+    const toolNamingMod = await import(pathToFileURL(toolNamingPath).href);
+    const autoInjectionPath = resolve(buildDir, "..", "hooks", "auto-injection.mjs");
+    const autoInjectionMod = await import(pathToFileURL(autoInjectionPath).href);
+    // Pre-build the routing block once per process — it is platform-specific
+    // (tool naming differs between opencode and kilo) but does NOT depend on
+    // sessionID, so we cache it. createToolNamer accepts both "opencode" and
+    // "kilo" per hooks/core/tool-naming.mjs:25-26.
+    const toolNamer = toolNamingMod.createToolNamer(platform);
+    const routingBlock = routingBlockMod.createRoutingBlock(toolNamer);
     // Initialize per-process state. We do NOT fabricate a sessionId here —
     // OpenCode/Kilo provide the real `input.sessionID` on every hook, and a
     // process-global UUID would (a) never match prior-session resume rows and
@@ -97,6 +127,51 @@ async function createContextModePlugin(ctx) {
     // many sessions, so the gate must be keyed by sessionID — NOT a single
     // boolean closure flag (Mickey #2 root cause).
     const resumeInjected = new Set();
+    // OC-1: Routing block first-fire gate per session. Distinct from
+    // resumeInjected because routing block must always inject (regardless of
+    // whether a resume row exists), but resume only on rows present.
+    const routingInjected = new Set();
+    // OC-4: AGENTS.md/CLAUDE.md captured-once-per-projectDir gate. Idempotent
+    // across many sessions reusing the same plugin process + project tree.
+    const agentsCaptured = new Set();
+    /**
+     * OC-4: Read AGENTS.md (and CLAUDE.md fallback if both exist) from the
+     * project directory and persist as `rule` + `rule_content` events. Mirrors
+     * the CC SessionStart pattern at hooks/sessionstart.mjs:121-132. Idempotent
+     * via `agentsCaptured` Set keyed by projectDir.
+     */
+    function captureAgentsMd(sessionId) {
+        if (agentsCaptured.has(projectDir))
+            return;
+        agentsCaptured.add(projectDir);
+        // Mirror OpenCode's instruction.ts FILES order: AGENTS.md, CLAUDE.md, CONTEXT.md.
+        const candidates = ["AGENTS.md", "CLAUDE.md", "CONTEXT.md"];
+        for (const name of candidates) {
+            try {
+                const p = join(projectDir, name);
+                if (!existsSync(p))
+                    continue;
+                const content = readFileSync(p, "utf-8");
+                if (!content.trim())
+                    continue;
+                db.insertEvent(sessionId, {
+                    type: "rule",
+                    category: "rule",
+                    data: p,
+                    priority: 1,
+                }, "PluginInit");
+                db.insertEvent(sessionId, {
+                    type: "rule_content",
+                    category: "rule",
+                    data: content,
+                    priority: 1,
+                }, "PluginInit");
+            }
+            catch {
+                // file missing or unreadable — skip silently
+            }
+        }
+    }
     return {
         // ── PreToolUse: Routing enforcement ─────────────────
         "tool.execute.before": async (input, output) => {
@@ -128,6 +203,9 @@ async function createContextModePlugin(ctx) {
                 return;
             try {
                 db.ensureSession(sessionId, projectDir);
+                // OC-4: Capture AGENTS.md/CLAUDE.md as rule events on first hook
+                // fire per projectDir. Idempotent via `agentsCaptured` Set.
+                captureAgentsMd(sessionId);
                 const hookInput = {
                     tool_name: input.tool ?? "",
                     tool_input: input.args ?? {},
@@ -144,6 +222,43 @@ async function createContextModePlugin(ctx) {
                 // Silent — session capture must never break the tool call
             }
         },
+        // ── chat.message: User-prompt capture (OC-2 / Z2) ───
+        // SDK signature verified at refs/platforms/opencode/packages/plugin/src/
+        // index.ts:233. Orchestrator reference at refs/plugin-examples/opencode/
+        // opencode-orchestrator/src/plugin-handlers/chat-message-handler.ts:41-65.
+        // CCv2 inline filter: skip synthetic harness messages (system reminders,
+        // tool results, etc.) so we don't pollute the user-prompt event stream.
+        "chat.message": async (input, output) => {
+            const sessionId = input?.sessionID;
+            if (!sessionId)
+                return;
+            try {
+                const parts = Array.isArray(output?.parts) ? output.parts : [];
+                const textPart = parts.find((p) => p && p.type === "text" && typeof p.text === "string" && p.text.length > 0);
+                if (!textPart || !textPart.text)
+                    return;
+                const message = textPart.text;
+                if (isSyntheticMessage(message))
+                    return;
+                db.ensureSession(sessionId, projectDir);
+                captureAgentsMd(sessionId);
+                // 1. Always save the raw prompt
+                db.insertEvent(sessionId, {
+                    type: "user_prompt",
+                    category: "user-prompt",
+                    data: message,
+                    priority: 1,
+                }, "UserPromptSubmit");
+                // 2. Extract role/decision/intent/skill events from the prompt body
+                const userEvents = extractUserEvents(message);
+                for (const ev of userEvents) {
+                    db.insertEvent(sessionId, ev, "UserPromptSubmit");
+                }
+            }
+            catch {
+                // Silent — chat.message must never break the turn
+            }
+        },
         // ── PreCompact: Snapshot generation ─────────────────
         "experimental.session.compacting": async (input, output) => {
             const sessionId = input.sessionID;
@@ -162,6 +277,19 @@ async function createContextModePlugin(ctx) {
                 db.incrementCompactCount(sessionId);
                 // Mutate output.context to inject the snapshot
                 output.context.push(snapshot);
+                // OC-3 / Z3: Add budget-capped auto-injection (P1 role / P2 rules /
+                // P3 skills / P4 intent — ≤500 tokens / ~2000 chars per
+                // hooks/auto-injection.mjs). Pushed as a separate context entry so
+                // OpenCode can fold it independently from the verbose snapshot.
+                try {
+                    const autoBlock = autoInjectionMod.buildAutoInjection(events);
+                    if (autoBlock && autoBlock.length > 0) {
+                        output.context.push(autoBlock);
+                    }
+                }
+                catch {
+                    // Auto-injection failure must NOT break the snapshot path.
+                }
                 return snapshot;
             }
             catch {
@@ -180,6 +308,25 @@ async function createContextModePlugin(ctx) {
             const sessionId = input?.sessionID;
             if (!sessionId)
                 return;
+            // ── OC-1 / CCv1: ROUTING_BLOCK injection ──────────────
+            // Inject the <context_window_protection> XML block on the first
+            // chat.system.transform per session. This is INDEPENDENT of the
+            // resume snapshot path below — routing block must fire even when
+            // no prior session row exists. Splice at index 1 (NOT unshift) for
+            // the same OpenCode llm.ts:117-128 cache-fold reason as resume.
+            if (!routingInjected.has(sessionId) && Array.isArray(output?.system)) {
+                try {
+                    // Visible marker — mirror the resume-snapshot pattern below so
+                    // users can grep OPENCODE_DEBUG logs to confirm the routing block
+                    // reached the model (Mickey-class verification path).
+                    const marker = `<!-- context-mode v${VERSION}: routing block injected (sessionID=${sessionId.slice(0, 8)}) -->\n`;
+                    output.system.splice(1, 0, marker + routingBlock);
+                    routingInjected.add(sessionId);
+                }
+                catch {
+                    // Never break the chat turn on routing-block injection failure.
+                }
+            }
             if (resumeInjected.has(sessionId))
                 return;
             try {

package/build/pi-extension.js

@@ -14,7 +14,7 @@ import { createHash } from "node:crypto";
 import { existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { SessionDB } from "./session/db.js";
 import { extractEvents, extractUserEvents } from "./session/extract.js";
 import { buildResumeSnapshot } from "./session/snapshot.js";
@@ -45,6 +45,38 @@ const BLOCKED_BASH_PATTERNS = [
 // ── Module-level DB singleton ────────────────────────────
 let _db = null;
 let _sessionId = "";
+// Per-session gate: routing block injected at most once per session_id.
+const _routingInjected = new Set();
+// Cached routing-block string (built once per process from hooks/routing-block.mjs).
+let _routingBlock = null;
+async function getRoutingBlock(pluginRoot) {
+    if (_routingBlock !== null)
+        return _routingBlock;
+    try {
+        const routingMod = await import(pathToFileURL(join(pluginRoot, "hooks", "routing-block.mjs")).href);
+        const namingMod = await import(pathToFileURL(join(pluginRoot, "hooks", "core", "tool-naming.mjs")).href);
+        const t = namingMod.createToolNamer("pi");
+        _routingBlock = String(routingMod.createRoutingBlock(t));
+    }
+    catch {
+        _routingBlock = "";
+    }
+    return _routingBlock;
+}
+// Cached buildAutoInjection (500-token cap, prioritized).
+let _buildAutoInjection = undefined;
+async function getAutoInjection(pluginRoot) {
+    if (_buildAutoInjection !== undefined)
+        return _buildAutoInjection;
+    try {
+        const mod = await import(pathToFileURL(join(pluginRoot, "hooks", "auto-injection.mjs")).href);
+        _buildAutoInjection = mod.buildAutoInjection;
+    }
+    catch {
+        _buildAutoInjection = null;
+    }
+    return _buildAutoInjection ?? null;
+}
 // ── Helpers ──────────────────────────────────────────────
 function getSessionDir() {
     const dir = join(homedir(), ".pi", "context-mode", "sessions");
@@ -218,8 +250,8 @@ export default function piExtension(pi) {
             // Silent — session capture must never break the tool call
         }
     });
-    // ── 4. before_agent_start — Resume injection + user events ─
-    pi.on("before_agent_start", (event) => {
+    // ── 4. before_agent_start — Routing + active_memory + resume injection ─
+    pi.on("before_agent_start", async (event) => {
         try {
             if (!_sessionId)
                 return;
@@ -231,37 +263,64 @@ export default function piExtension(pi) {
                     db.insertEvent(_sessionId, ev, "UserPromptSubmit");
                 }
             }
-            // Check for unconsumed resume snapshot
-            const resume = db.getResume(_sessionId);
-            if (!resume || resume.consumed)
-                return;
-            // Build FTS5 active memory from the current prompt
-            const stats = db.getSessionStats(_sessionId);
-            if ((stats?.compact_count ?? 0) === 0)
-                return;
-            // Mark resume as consumed so it is not re-injected
-            db.markResumeConsumed(_sessionId);
-            // Build memory context from recent high-priority events
-            const allEvents = db.getEvents(_sessionId, { minPriority: 3, limit: 50 });
-            let memoryContext = "";
-            if (allEvents.length > 0) {
-                const memoryLines = ["<active_memory>"];
-                for (const ev of allEvents) {
-                    memoryLines.push(`  <event type="${ev.type}" category="${ev.category}">${ev.data}</event>`);
-                }
-                memoryLines.push("</active_memory>");
-                memoryContext = memoryLines.join("\n");
-            }
-            // Compose the augmented system prompt
             const existingPrompt = String(event?.systemPrompt ?? "");
             const parts = [];
             if (existingPrompt)
                 parts.push(existingPrompt);
-            if (resume.snapshot)
+            // Pi-1: Inject routing block once per session (gated by _routingInjected).
+            // v1.0.107 — visible marker so Pi users can verify the routing block
+            // reached the model (Mickey-class verification path; mirrors OpenCode).
+            if (!_routingInjected.has(_sessionId)) {
+                const routingBlock = await getRoutingBlock(pluginRoot);
+                if (routingBlock) {
+                    const marker = `<!-- context-mode: routing block injected (sessionID=${String(_sessionId).slice(0, 8)}) -->`;
+                    parts.push(marker + "\n" + routingBlock);
+                    _routingInjected.add(_sessionId);
+                }
+            }
+            // Pi-3 + Pi-4: Always build active_memory (not just post-compact),
+            // capped at 500 tokens via buildAutoInjection. Falls back to inline
+            // budget loop if the helper is unavailable.
+            const activeEvents = db.getEvents(_sessionId, {
+                minPriority: 3,
+                limit: 50,
+            });
+            if (activeEvents.length > 0) {
+                const buildAuto = await getAutoInjection(pluginRoot);
+                let memoryContext = "";
+                if (buildAuto) {
+                    memoryContext = buildAuto(activeEvents.map((e) => ({
+                        category: String(e.category ?? ""),
+                        data: String(e.data ?? ""),
+                    })));
+                }
+                // Fallback (or if helper produced empty output): inline 500-token cap.
+                if (!memoryContext) {
+                    const memoryLines = ["<active_memory>"];
+                    let budget = 2000; // ~500 tokens at 4 chars/token
+                    for (const ev of activeEvents) {
+                        const line = `  <event type="${ev.type}" category="${ev.category}">${ev.data}</event>`;
+                        if (line.length > budget)
+                            break;
+                        memoryLines.push(line);
+                        budget -= line.length;
+                    }
+                    memoryLines.push("</active_memory>");
+                    if (memoryLines.length > 2)
+                        memoryContext = memoryLines.join("\n");
+                }
+                if (memoryContext)
+                    parts.push(memoryContext);
+            }
+            // Resume snapshot (only when present and unconsumed).
+            const resume = db.getResume(_sessionId);
+            if (resume && !resume.consumed && resume.snapshot) {
                 parts.push(resume.snapshot);
-            if (memoryContext)
-                parts.push(memoryContext);
-            if (parts.length > (existingPrompt ? 1 : 0)) {
+                db.markResumeConsumed(_sessionId);
+            }
+            // Return modified systemPrompt only if we added something beyond existing.
+            const baseLen = existingPrompt ? 1 : 0;
+            if (parts.length > baseLen) {
                 return { systemPrompt: parts.join("\n\n") };
             }
         }
@@ -269,6 +328,40 @@ export default function piExtension(pi) {
             // best effort — never break agent start
         }
     });
+    // ── 4b. before_provider_response — capture response metadata ───
+    // Pi-2: Register the missing event so providers can record latency,
+    // model, and token usage when Pi exposes them. Best-effort only;
+    // the handler must never throw or modify the response.
+    pi.on("before_provider_response", (event) => {
+        try {
+            if (!_sessionId)
+                return;
+            const meta = {
+                model: event?.model ?? event?.providerModel,
+                provider: event?.provider,
+                latencyMs: event?.latencyMs ?? event?.latency,
+                tokens: event?.usage ?? event?.tokens,
+            };
+            // Skip when Pi gives us nothing useful — avoids noise in the DB.
+            if (meta.model == null &&
+                meta.provider == null &&
+                meta.latencyMs == null &&
+                meta.tokens == null) {
+                return;
+            }
+            const data = JSON.stringify(meta);
+            db.insertEvent(_sessionId, {
+                type: "provider_response",
+                category: "pi",
+                data,
+                priority: 1,
+                data_hash: createHash("sha256").update(data).digest("hex").slice(0, 16),
+            }, "PostToolUse");
+        }
+        catch {
+            // best effort — never break provider response
+        }
+    });
     // ── 5. session_before_compact — Build resume snapshot ──
     pi.on("session_before_compact", () => {
         try {
@@ -305,6 +398,7 @@ export default function piExtension(pi) {
                 _db.cleanupOldSessions(7);
             }
             _db = null;
+            _routingInjected.clear();
             _sessionId = "";
         }
         catch {

package/build/server.d.ts

@@ -37,6 +37,7 @@ interface BatchExecutor {
         timedOut?: boolean;
     }>;
 }
+export declare function buildBatchNodeOptionsPrefix(shellPath: string, preloadPath: string): string;
 /**
  * Execute batch commands. concurrency=1 preserves the legacy serial path
  * (shared timeout budget + cascading skip-on-timeout). concurrency>1 runs

package/build/server.js

@@ -675,6 +675,24 @@ export function formatBatchQueryResults(store, queries, source, maxOutput = 80 *
     sections.push(`\n> **Tip:** Results are scoped to this batch only. To search across all indexed sources, use \`ctx_search(queries: [...])\`.`);
     return sections;
 }
+function quotePosixSingle(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function quotePowerShellSingle(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+export function buildBatchNodeOptionsPrefix(shellPath, preloadPath) {
+    const option = `--require ${preloadPath}`;
+    const shell = shellPath.toLowerCase();
+    const base = shell.split(/[\\/]/).pop() ?? shell;
+    if (shell.includes("powershell") || shell.includes("pwsh")) {
+        return `$env:NODE_OPTIONS=${quotePowerShellSingle(option)}; `;
+    }
+    if (base === "cmd" || base === "cmd.exe") {
+        return `set "NODE_OPTIONS=${option.replace(/"/g, '""')}" && `;
+    }
+    return `NODE_OPTIONS=${quotePosixSingle(option)} `;
+}
 function formatCommandOutput(label, raw, onFsBytes) {
     let output = raw || "(no output)";
     const fsMatches = output.matchAll(/__CM_FS__:(\d+)/g);
@@ -2070,7 +2088,7 @@ server.registerTool("ctx_batch_execute", {
         // Inject NODE_OPTIONS for FS read tracking in spawned Node processes.
         // The executor denies NODE_OPTIONS in its env (security), so we set it
         // as an inline shell prefix. This only affects child `node` invocations.
-        const nodeOptsPrefix = `NODE_OPTIONS="--require ${CM_FS_PRELOAD}" `;
+        const nodeOptsPrefix = buildBatchNodeOptionsPrefix(runtimes.shell, CM_FS_PRELOAD);
         // Full stdout is preserved per-command and indexed into FTS5 (Issue #61, #197).
         // Concurrency>1 switches to a worker pool with per-command timeouts.
         const { outputs: perCommandOutputs, timedOut } = await runBatchCommands(commands, {
@@ -2816,6 +2834,13 @@ async function main() {
         fetchLatestVersion().then(v => { if (v !== "unknown")
             _latestVersion = v; });
     }, 60 * 60 * 1000).unref();
+    // Stats heartbeat — keep the statusline truthful while the user works in
+    // tools other than MCP (Bash/Read/Edit during long sessions or post-/compact
+    // pauses). Without this, stats.updated_at only advances on MCP tool calls,
+    // so bin/statusline.mjs falsely flips to "stale — restart to resume saving"
+    // even though the server is alive. Heartbeat refreshes updated_at every 60s;
+    // statusline staleness threshold is 30min (cliff is 30 missed ticks away).
+    setInterval(() => persistStats(), 60_000).unref();
     console.error(`Context Mode MCP server v${VERSION} running on stdio`);
     console.error(`Detected runtimes:\n${getRuntimeSummary(runtimes)}`);
     if (!hasBunRuntime()) {

package/build/session/analytics.js

@@ -477,18 +477,30 @@ function dataBar(bytes, maxBytes, width = 40) {
  * actual remaining count (Bug #5 — was hardcoded "9 more").
  */
 function renderProjectMemory(pm, opts) {
-    if (pm.total_events === 0 && (opts?.lifetime?.totalEvents ?? 0) === 0)
+    const sessionTokensSaved = opts?.sessionTokensSaved ?? 0;
+    // Render when EITHER disk has data OR current session has earnings.
+    if (pm.total_events === 0 &&
+        (opts?.lifetime?.totalEvents ?? 0) === 0 &&
+        sessionTokensSaved === 0) {
         return [];
+    }
     const topN = opts?.topN ?? 2;
     const out = [];
     out.push("");
     out.push("Persistent memory  ✓ preserved across compact, restart & upgrade");
-    // Lifetime line (Bug #3) — collapses to project-only when lifetime missing.
+    // Lifetime line — disk-aggregated lifetime PLUS current session's in-memory
+    // savings. Two separate accounting pipelines (server bytes vs hook events)
+    // get unified at the render edge so the user always sees a monotonic total
+    // (lifetime ≥ session). Without this, fresh users / pre-b8e11bf sidecars /
+    // not-yet-flushed events show $0 lifetime even when the session earned $X.
     const lifeEvents = opts?.lifetime?.totalEvents ?? pm.total_events;
     const lifeSessions = opts?.lifetime?.totalSessions ?? pm.session_count;
-    const sessionLabel = lifeSessions === 1 ? "1 session" : `${fmtNum(lifeSessions)} sessions`;
-    // Estimate lifetime savings: ~1KB per event → ~256 tokens/event at Opus rates.
-    const lifetimeTokens = lifeEvents * 256;
+    // Current session counts as 1 when no prior session has been recorded yet.
+    const effectiveSessions = lifeSessions === 0 && sessionTokensSaved > 0 ? 1 : lifeSessions;
+    const sessionLabel = effectiveSessions === 1 ? "1 session" : `${fmtNum(effectiveSessions)} sessions`;
+    // Estimate lifetime savings: ~1KB per event → ~256 tokens/event at Opus rates,
+    // plus current session's already-tracked token savings (in-memory).
+    const lifetimeTokens = lifeEvents * 256 + sessionTokensSaved;
     out.push(`  ${fmtNum(lifeEvents)} events · ${sessionLabel} · ~${tokensToUsd(lifetimeTokens)} saved lifetime`);
     out.push("");
     const cats = pm.by_category;
@@ -526,8 +538,11 @@ function renderAutoMemory(lifetime) {
 function renderBottomLine(sessionTokensSaved, lifetime) {
     const out = [];
     const sessionUsd = tokensToUsd(sessionTokensSaved);
-    // Lifetime estimate: ~1KB/event ÷ 4 bytes/token = 256 tokens/event.
-    const lifetimeTokens = (lifetime?.totalEvents ?? 0) * 256;
+    // Lifetime = disk-aggregated events × 256 tokens + current session's
+    // in-memory token savings. Two pipelines unified at the render edge so
+    // lifetime ≥ session always (never the surprising "$X session · $0 lifetime"
+    // a fresh user sees pre-flush).
+    const lifetimeTokens = (lifetime?.totalEvents ?? 0) * 256 + sessionTokensSaved;
     const lifetimeUsd = tokensToUsd(lifetimeTokens);
     out.push("");
     out.push("─".repeat(65));
@@ -572,7 +587,7 @@ export function formatReport(report, version, latestVersion, opts) {
             lines.push(`${kb(totalReturned)} entered context  |  0 tokens saved`);
         }
         // Project memory + auto-memory + bottom line
-        lines.push(...renderProjectMemory(report.projectMemory, { lifetime }));
+        lines.push(...renderProjectMemory(report.projectMemory, { lifetime, sessionTokensSaved: 0 }));
         lines.push(...renderAutoMemory(lifetime));
         lines.push(...renderBottomLine(0, lifetime));
         // Footer
@@ -627,15 +642,23 @@ export function formatReport(report, version, latestVersion, opts) {
             lines.push(`  ${name.padEnd(22)}  ${String(t.calls).padStart(4)} calls  ${kb(t.estimatedSaved).padStart(8)} saved`);
         }
     }
-    // ── MCP concurrency usage (only when batch tools recorded a concurrency) ──
+    // ── Parallel I/O — value-forward framing for concurrent batch tools.
+    // Suppressed when no tool ran with max_concurrency > 1 (don't claim
+    // parallelism we didn't deliver). Internal mcp__*__ namespace stripped
+    // for user-facing readability.
     if (mcpUsage && mcpUsage.length > 0) {
-        const concurrent = mcpUsage.filter((u) => u.median_concurrency != null);
-        for (const u of concurrent) {
-            lines.push(`MCP concurrency usage: ${u.tool_name} median=${u.median_concurrency} max=${u.max_concurrency} (${u.calls} calls)`);
+        const concurrent = mcpUsage.filter((u) => u.median_concurrency != null && (u.max_concurrency ?? 1) > 1);
+        if (concurrent.length > 0) {
+            lines.push("");
+            lines.push("Parallel I/O  ✓ one call did the work of many — faster runs, lower bill, same answer.");
+            for (const u of concurrent) {
+                const name = u.tool_name.replace(/^mcp__.*?__/, "");
+                lines.push(`  ${name.padEnd(22)} ${u.calls} batches · ${u.median_concurrency} typical, ${u.max_concurrency} peak`);
+            }
         }
     }
     // ── Project memory — persistent across sessions (Bug #3 + #5) ──
-    lines.push(...renderProjectMemory(report.projectMemory, { lifetime }));
+    lines.push(...renderProjectMemory(report.projectMemory, { lifetime, sessionTokensSaved: tokensSaved }));
     // ── Auto-memory — Claude Code's preference learnings (Bug #4) ──
     lines.push(...renderAutoMemory(lifetime));
     // ── Bottom line — business value framing (Bug #8) ──

package/build/session/extract.d.ts

@@ -45,7 +45,7 @@ export declare function resetIterationLoopState(): void;
  * Accepts the raw hook JSON shape (snake_case keys) as received from stdin.
  * Returns an array of zero or more SessionEvents. Never throws.
  */
-export declare function extractEvents(input: HookInput): SessionEvent[];
+export declare function extractEvents(rawInput: HookInput): SessionEvent[];
 /**
  * Extract session events from a UserPromptSubmit hook input (user message text).
  *