context-mode 1.0.157 → 1.0.159

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.157"
+    "version": "1.0.159"
   },
   "plugins": [
     {
       "name": "context-mode",
       "source": "./",
       "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-      "version": "1.0.157",
+      "version": "1.0.159",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.157",
+  "version": "1.0.159",
   "description": "MCP server that saves 98% of your context window with session continuity. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and automatic state restore across compactions.",
   "author": {
     "name": "Mert Koseoğlu",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.157",
+  "version": "1.0.159",
   "description": "MCP server that saves 98% of your context window with session continuity. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and automatic state restore across compactions.",
   "author": {
     "name": "Mert Koseoğlu",

package/.openclaw-plugin/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Context Mode",
   "kind": "tool",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-  "version": "1.0.157",
+  "version": "1.0.159",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.157",
+  "version": "1.0.159",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
   "author": {
     "name": "Mert Koseoğlu",

package/build/adapters/codex/index.d.ts

@@ -42,7 +42,7 @@ export declare class CodexAdapter extends BaseAdapter implements HookAdapter {
     generateHookConfig(_pluginRoot: string): HookRegistration;
     readSettings(): Record<string, unknown> | null;
     writeSettings(_settings: Record<string, unknown>): void;
-    validateHooks(_pluginRoot: string): DiagnosticResult[];
+    validateHooks(pluginRoot: string): DiagnosticResult[];
     checkPluginRegistration(): DiagnosticResult;
     getInstalledVersion(): string;
     configureAllHooks(pluginRoot: string): string[];
@@ -63,6 +63,9 @@ export declare class CodexAdapter extends BaseAdapter implements HookAdapter {
     private readHooksConfig;
     private writeHooksConfig;
     private upsertManagedHookEntry;
+    private removeManagedHookEntries;
+    private hasCodexPluginHookManifest;
+    private pruneStaleUserHookTrustState;
     private isExpectedHookEntry;
     private isManagedContextModeEntry;
     private entryContainsManagedCommand;

package/build/adapters/codex/index.js

@@ -14,7 +14,7 @@
  * Track: https://github.com/openai/codex/issues/18491
  */
 import { execFileSync } from "node:child_process";
-import { readFileSync, writeFileSync, accessSync, copyFileSync, constants, mkdirSync, } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, accessSync, copyFileSync, constants, mkdirSync, } from "node:fs";
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { BaseAdapter, resolveContextModeDataRoot } from "../base.js";
@@ -100,6 +100,13 @@ function hasDeprecatedCodexHooksFeature(raw) {
     const features = getTomlSection(raw, "features");
     return features !== null && /^\s*codex_hooks\s*=\s*true\s*(?:#.*)?$/mi.test(features);
 }
+function hasCodexPluginEnabled(raw) {
+    const plugin = getTomlSection(raw, 'plugins."context-mode@context-mode"');
+    return plugin !== null && /^\s*enabled\s*=\s*true\s*(?:#.*)?$/mi.test(plugin);
+}
+function hasStandaloneContextModeMcp(raw) {
+    return getTomlSection(raw, "mcp_servers.context-mode") !== null;
+}
 function ensureCodexHooksFeature(raw) {
     if (hasCodexHooksFeature(raw))
         return { text: raw, changed: false };
@@ -129,6 +136,56 @@ function ensureCodexHooksFeature(raw) {
     lines.splice(featuresIndex + 1, 0, "hooks = true");
     return { text: lines.join(newline), changed: true };
 }
+function removeTomlSections(raw, shouldRemove) {
+    const newline = raw.includes("\r\n") ? "\r\n" : "\n";
+    const lines = raw.split(/\r?\n/);
+    const out = [];
+    const removed = [];
+    let skipping = false;
+    for (const line of lines) {
+        const section = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/);
+        if (section) {
+            const sectionName = section[1]?.trim() ?? "";
+            skipping = shouldRemove(sectionName);
+            if (skipping)
+                removed.push(sectionName);
+        }
+        if (!skipping)
+            out.push(line);
+    }
+    return { text: out.join(newline), removed };
+}
+function parseTomlQuotedString(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith('"') || !trimmed.endsWith('"'))
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        return typeof parsed === "string" ? parsed : null;
+    }
+    catch {
+        // Codex hook-state keys are TOML quoted keys, not guaranteed JSON strings.
+        // Preserve Windows backslashes such as C:\Users\... even when they are not
+        // valid JSON escapes, while still handling the common escaped quote/slash.
+        let out = "";
+        let escaping = false;
+        for (const ch of trimmed.slice(1, -1)) {
+            if (escaping) {
+                out += ch === '"' || ch === "\\" ? ch : `\\${ch}`;
+                escaping = false;
+            }
+            else if (ch === "\\") {
+                escaping = true;
+            }
+            else {
+                out += ch;
+            }
+        }
+        if (escaping)
+            out += "\\";
+        return out;
+    }
+}
 // ─────────────────────────────────────────────────────────
 // Adapter implementation
 // ─────────────────────────────────────────────────────────
@@ -384,9 +441,11 @@ export class CodexAdapter extends BaseAdapter {
         // manually or via the `codex` CLI tool.
     }
     // ── Diagnostics (doctor) ─────────────────────────────────
-    validateHooks(_pluginRoot) {
+    validateHooks(pluginRoot) {
         const results = [];
         const codexCliVersion = probeCodexCliVersion();
+        let settingsRaw = "";
+        let settingsReadable = false;
         results.push({
             check: "Codex CLI binary",
             status: codexCliVersion ? "pass" : "warn",
@@ -396,9 +455,10 @@ export class CodexAdapter extends BaseAdapter {
             ...(codexCliVersion ? {} : { fix: "Install Codex CLI or make codex available on PATH" }),
         });
         try {
-            const raw = readFileSync(this.getSettingsPath(), "utf-8");
-            const enabled = hasCodexHooksFeature(raw);
-            const deprecatedOnly = !enabled && hasDeprecatedCodexHooksFeature(raw);
+            settingsRaw = readFileSync(this.getSettingsPath(), "utf-8");
+            settingsReadable = true;
+            const enabled = hasCodexHooksFeature(settingsRaw);
+            const deprecatedOnly = !enabled && hasDeprecatedCodexHooksFeature(settingsRaw);
             results.push({
                 check: "Codex hooks feature flag",
                 status: enabled ? "pass" : "fail",
@@ -418,8 +478,35 @@ export class CodexAdapter extends BaseAdapter {
                 fix: "context-mode upgrade",
             });
         }
+        const expected = this.generateHookConfig("");
+        const codexPluginEnabled = settingsReadable && hasCodexPluginEnabled(settingsRaw);
+        const codexPluginHooksAvailable = codexPluginEnabled && this.hasCodexPluginHookManifest(pluginRoot);
+        if (codexPluginEnabled && !codexPluginHooksAvailable) {
+            results.push({
+                check: "Codex plugin hooks",
+                status: "fail",
+                message: `context-mode Codex plugin is enabled, but ${join(pluginRoot, ".codex-plugin", "hooks.json")} is missing`,
+                fix: "Reinstall or upgrade the context-mode Codex plugin",
+            });
+        }
+        if (codexPluginEnabled && hasStandaloneContextModeMcp(settingsRaw)) {
+            results.push({
+                check: "Standalone MCP duplicate",
+                status: "warn",
+                message: "[mcp_servers.context-mode] is still registered while context-mode@context-mode is enabled; Codex may start both plugin and standalone MCP surfaces",
+                fix: "context-mode upgrade (removes the standalone Codex MCP registration when the plugin owns context-mode)",
+            });
+        }
         const hookConfig = this.readHooksConfig();
         if (!hookConfig.ok) {
+            if (hookConfig.reason === "missing" && codexPluginHooksAvailable) {
+                const pluginHookChecks = Object.keys(expected).map((hookName) => ({
+                    check: `${hookName} hook`,
+                    status: "pass",
+                    message: `${hookName} hook provided by context-mode@context-mode plugin`,
+                }));
+                return results.concat(pluginHookChecks);
+            }
             if (hookConfig.reason === "missing") {
                 return results.concat([{
                         check: "Hooks config",
@@ -443,7 +530,7 @@ export class CodexAdapter extends BaseAdapter {
                     fix: "Check permissions and file accessibility for hooks.json, then rerun context-mode upgrade if needed",
                 }]);
         }
-        if (!hookConfig.config.hooks) {
+        if (!hookConfig.config.hooks && !codexPluginHooksAvailable) {
             return results.concat([{
                     check: "Hooks config",
                     status: "fail",
@@ -451,24 +538,29 @@ export class CodexAdapter extends BaseAdapter {
                     fix: `Update ${this.getHooksPath()} to match configs/codex/hooks.json`,
                 }]);
         }
-        const expected = this.generateHookConfig("");
-        const hookChecks = Object.entries(expected).map(([hookName, entries]) => {
-            const actualEntries = hookConfig.config.hooks?.[hookName];
-            const expectedEntry = entries[0];
-            const ok = Array.isArray(actualEntries)
-                && actualEntries.some((entry) => this.isExpectedHookEntry(hookName, entry, expectedEntry));
-            const missingStatus = hookName === "PreCompact" ? "warn" : "fail";
-            return {
+        const hookChecks = codexPluginHooksAvailable
+            ? Object.keys(expected).map((hookName) => ({
                 check: `${hookName} hook`,
-                status: (ok ? "pass" : missingStatus),
-                message: ok
-                    ? `${hookName} hook configured in ${this.getHooksPath()}`
-                    : hookName === "PreCompact"
-                        ? `${hookName} hook missing or not pointing to context-mode; compaction snapshots require a Codex build that emits PreCompact`
-                        : `${hookName} hook missing or not pointing to context-mode`,
-                fix: ok ? undefined : `Update ${this.getHooksPath()} to match configs/codex/hooks.json`,
-            };
-        });
+                status: "pass",
+                message: `${hookName} hook provided by context-mode@context-mode plugin`,
+            }))
+            : Object.entries(expected).map(([hookName, entries]) => {
+                const actualEntries = hookConfig.config.hooks?.[hookName];
+                const expectedEntry = entries[0];
+                const ok = Array.isArray(actualEntries)
+                    && actualEntries.some((entry) => this.isExpectedHookEntry(hookName, entry, expectedEntry));
+                const missingStatus = hookName === "PreCompact" ? "warn" : "fail";
+                return {
+                    check: `${hookName} hook`,
+                    status: (ok ? "pass" : missingStatus),
+                    message: ok
+                        ? `${hookName} hook configured in ${this.getHooksPath()}`
+                        : hookName === "PreCompact"
+                            ? `${hookName} hook missing or not pointing to context-mode; compaction snapshots require a Codex build that emits PreCompact`
+                            : `${hookName} hook missing or not pointing to context-mode`,
+                    fix: ok ? undefined : `Update ${this.getHooksPath()} to match configs/codex/hooks.json`,
+                };
+            });
         // #603: surface duplicate context-mode entries per hook event. Codex fires
         // every matching entry, so duplicates double the work, can saturate the
         // MCP transport (`Transport closed`), and have been observed to inflate
@@ -488,16 +580,39 @@ export class CodexAdapter extends BaseAdapter {
                     fix: "context-mode upgrade (collapses duplicate context-mode entries; preserves unrelated hooks)",
                 });
             }
+            else if (codexPluginHooksAvailable && managedCount === 1) {
+                duplicateChecks.push({
+                    check: `${hookName} plugin duplicate`,
+                    status: "warn",
+                    message: `${hookName} is configured in both ${this.getHooksPath()} and the context-mode Codex plugin; Codex will fire both hooks`,
+                    fix: "context-mode upgrade (removes user config context-mode hooks; preserves unrelated hooks)",
+                });
+            }
         }
         return results.concat(hookChecks, duplicateChecks);
     }
     checkPluginRegistration() {
-        // Check for context-mode in [mcp_servers] section of config.toml
         try {
             const raw = readFileSync(this.getSettingsPath(), "utf-8");
-            const hasContextMode = raw.includes("context-mode");
+            const pluginEnabled = hasCodexPluginEnabled(raw);
+            const standaloneMcp = hasStandaloneContextModeMcp(raw);
             const hasMcpSection = raw.includes("[mcp_servers]") || raw.includes("[mcp_servers.");
-            if (hasContextMode && hasMcpSection) {
+            if (pluginEnabled && standaloneMcp) {
+                return {
+                    check: "MCP registration",
+                    status: "warn",
+                    message: "context-mode@context-mode plugin is enabled, but standalone [mcp_servers.context-mode] is also configured",
+                    fix: "context-mode upgrade",
+                };
+            }
+            if (pluginEnabled) {
+                return {
+                    check: "MCP registration",
+                    status: "pass",
+                    message: "context-mode@context-mode plugin enabled",
+                };
+            }
+            if (standaloneMcp) {
                 return {
                     check: "MCP registration",
                     status: "pass",
@@ -536,6 +651,15 @@ export class CodexAdapter extends BaseAdapter {
     configureAllHooks(pluginRoot) {
         const hookConfig = this.readHooksConfig();
         const changes = [];
+        const settingsPath = this.getSettingsPath();
+        let settingsRaw = "";
+        try {
+            settingsRaw = readFileSync(settingsPath, "utf-8");
+        }
+        catch {
+            settingsRaw = "";
+        }
+        const codexPluginOwnsHooks = hasCodexPluginEnabled(settingsRaw) && this.hasCodexPluginHookManifest(pluginRoot);
         let hookFile;
         if (hookConfig.ok) {
             hookFile = hookConfig.config;
@@ -555,31 +679,48 @@ export class CodexAdapter extends BaseAdapter {
             ? hookFile.hooks
             : {};
         const desiredHooks = this.generateHookConfig(pluginRoot);
-        for (const [hookName, entries] of Object.entries(desiredHooks)) {
-            this.upsertManagedHookEntry(hooks, hookName, entries[0], changes);
+        const hookChangeStart = changes.length;
+        if (codexPluginOwnsHooks) {
+            for (const hookName of Object.keys(desiredHooks)) {
+                this.removeManagedHookEntries(hooks, hookName, changes);
+            }
         }
-        if (changes.length > 0) {
+        else {
+            for (const [hookName, entries] of Object.entries(desiredHooks)) {
+                this.upsertManagedHookEntry(hooks, hookName, entries[0], changes);
+            }
+        }
+        if (changes.length > hookChangeStart) {
             hookFile.hooks = hooks;
             this.writeHooksConfig(hookFile);
-            changes.push(`Wrote native Codex hooks to ${this.getHooksPath()}`);
-        }
-        const settingsPath = this.getSettingsPath();
-        let settingsRaw = "";
-        try {
-            settingsRaw = readFileSync(settingsPath, "utf-8");
-        }
-        catch {
-            settingsRaw = "";
+            changes.push(codexPluginOwnsHooks
+                ? `Removed duplicate context-mode user hooks from ${this.getHooksPath()}`
+                : `Wrote native Codex hooks to ${this.getHooksPath()}`);
+        }
+        let settingsText = ensureCodexHooksFeature(settingsRaw).text;
+        const enabledSettingsChanged = settingsText !== settingsRaw;
+        if (codexPluginOwnsHooks) {
+            const removedMcp = removeTomlSections(settingsText, (sectionName) => sectionName === "mcp_servers.context-mode"
+                || sectionName.startsWith("mcp_servers.context-mode.tools."));
+            if (removedMcp.removed.length > 0) {
+                settingsText = removedMcp.text;
+                changes.push("Removed standalone Codex context-mode MCP registration");
+            }
+            const prunedTrust = this.pruneStaleUserHookTrustState(settingsText, hooks);
+            if (prunedTrust.removed.length > 0) {
+                settingsText = prunedTrust.text;
+                changes.push(`Removed ${prunedTrust.removed.length} stale Codex hook trust entr${prunedTrust.removed.length === 1 ? "y" : "ies"}`);
+            }
         }
-        const enabledSettings = ensureCodexHooksFeature(settingsRaw);
-        if (enabledSettings.changed) {
-            const newline = enabledSettings.text.includes("\r\n") ? "\r\n" : "\n";
-            const text = enabledSettings.text.endsWith("\n")
-                ? enabledSettings.text
-                : `${enabledSettings.text}${newline}`;
+        if (settingsText !== settingsRaw) {
+            const newline = settingsText.includes("\r\n") ? "\r\n" : "\n";
+            const text = settingsText.endsWith("\n")
+                ? settingsText
+                : `${settingsText}${newline}`;
             mkdirSync(dirname(settingsPath), { recursive: true });
             writeFileSync(settingsPath, text, "utf-8");
-            changes.push("Enabled Codex hooks feature flag");
+            if (enabledSettingsChanged)
+                changes.push("Enabled Codex hooks feature flag");
         }
         return changes;
     }
@@ -681,6 +822,57 @@ export class CodexAdapter extends BaseAdapter {
         }
         hooks[hookName] = currentEntries;
     }
+    removeManagedHookEntries(hooks, hookName, changes) {
+        const currentEntries = Array.isArray(hooks[hookName]) ? [...hooks[hookName]] : [];
+        const filtered = currentEntries.filter((entry) => !this.isManagedContextModeEntry(hookName, entry));
+        const removed = currentEntries.length - filtered.length;
+        if (removed === 0)
+            return;
+        if (filtered.length > 0) {
+            hooks[hookName] = filtered;
+        }
+        else {
+            delete hooks[hookName];
+        }
+        changes.push(`Removed ${removed} ${hookName} context-mode user hook${removed === 1 ? "" : "s"}`);
+    }
+    hasCodexPluginHookManifest(pluginRoot) {
+        return existsSync(join(pluginRoot, ".codex-plugin", "hooks.json"));
+    }
+    pruneStaleUserHookTrustState(settingsRaw, hooks) {
+        const hooksPath = this.normalizeCommand(this.getHooksPath());
+        const eventNames = {
+            post_compact: "PostCompact",
+            post_tool_use: "PostToolUse",
+            pre_compact: "PreCompact",
+            pre_tool_use: "PreToolUse",
+            session_start: "SessionStart",
+            stop: "Stop",
+            user_prompt_submit: "UserPromptSubmit",
+        };
+        return removeTomlSections(settingsRaw, (sectionName) => {
+            const prefix = "hooks.state.";
+            if (!sectionName.startsWith(prefix))
+                return false;
+            const key = parseTomlQuotedString(sectionName.slice(prefix.length));
+            if (key === null)
+                return false;
+            const normalized = this.normalizeCommand(key);
+            const parts = normalized.split(":");
+            const hookIndex = Number(parts.pop());
+            const entryIndex = Number(parts.pop());
+            const eventName = eventNames[parts.pop() ?? ""];
+            const stateHooksPath = parts.join(":");
+            if (stateHooksPath !== hooksPath
+                || !eventName
+                || !Number.isInteger(entryIndex)
+                || !Number.isInteger(hookIndex)) {
+                return false;
+            }
+            const entry = hooks[eventName]?.[entryIndex];
+            return !entry || !Array.isArray(entry.hooks) || !entry.hooks[hookIndex];
+        });
+    }
     isExpectedHookEntry(hookName, entry, expectedEntry) {
         if (!entry || typeof entry !== "object")
             return false;

package/build/session/db.d.ts

@@ -164,6 +164,28 @@ export interface SessionMeta {
     event_count: number;
     compact_count: number;
 }
+/**
+ * Session rollup snapshot (seed-parity aggregate).
+ *
+ * 12 fields that mirror the platform's `session_summary` + `session_metadata`
+ * stamps from src/routes/seed.ts. Each outgoing canonical event carries
+ * this snapshot computed at the moment of forward so the analytics engine
+ * can run its SUM/AVG/MAX rollups across per-event rows.
+ */
+export interface SessionRollup {
+    tool_calls: number;
+    errors: number;
+    unique_tools: number;
+    unique_files: number;
+    max_file_edits: number;
+    has_commit: 0 | 1;
+    edit_test_cycles: number;
+    duration_min: number;
+    compact_count: number;
+    sources_indexed: number;
+    total_chunks: number;
+    search_queries: number;
+}
 /** Resume snapshot row from the session_resume table. */
 export interface ResumeRow {
     snapshot: string;
@@ -340,6 +362,19 @@ export declare class SessionDB extends SQLiteBase {
      * Get session statistics/metadata.
      */
     getSessionStats(sessionId: string): SessionMeta | null;
+    /**
+     * Session rollup snapshot — 12 aggregate fields the analytics platform
+     * stamps onto every outgoing event row (seed.ts shape parity).
+     *
+     * Called from session-loaders BEFORE `maybeForward`; the snapshot is
+     * computed against the LOCAL SessionDB and threaded into the canonical
+     * event so the platform-side Zod schema receives the rich shape without
+     * the bridge ever hand-mapping fields (PRD §5.4 ABI passthrough).
+     *
+     * Returns zeroed defaults for unknown sessions — callers MUST tolerate
+     * a snapshot from an empty session (first event into a fresh DB).
+     */
+    getSessionRollup(sessionId: string): SessionRollup;
     /**
      * Increment the compact_count for a session (tracks snapshot rebuilds).
      */

package/build/session/db.js

@@ -477,6 +477,8 @@ const S = {
     updateMetaLastEvent: "updateMetaLastEvent",
     ensureSession: "ensureSession",
     getSessionStats: "getSessionStats",
+    getSessionRollup: "getSessionRollup",
+    getMaxFileEdits: "getMaxFileEdits",
     incrementCompactCount: "incrementCompactCount",
     upsertResume: "upsertResume",
     getResume: "getResume",
@@ -716,6 +718,35 @@ export class SessionDB extends SQLiteBase {
         p(S.ensureSession, `INSERT OR IGNORE INTO session_meta (session_id, project_dir) VALUES (?, ?)`);
         p(S.getSessionStats, `SELECT session_id, project_dir, started_at, last_event_at, event_count, compact_count
        FROM session_meta WHERE session_id = ?`);
+        // ── Session rollup (seed-parity aggregator) ────────────────────────
+        // Single query producing 9 of the 12 platform-side session_summary +
+        // session_metadata fields. Computed against the local SessionDB
+        // session_events table at forward time so every outgoing canonical
+        // event carries a session-wide snapshot at that moment — matches the
+        // seed.ts shape where each event row has tool_calls/errors/etc. stamped.
+        // max_file_edits and edit_test_cycles need separate GROUP BY queries
+        // (below). compact_count is read from session_meta (already in getSessionStats).
+        p(S.getSessionRollup, `SELECT
+         COUNT(*) AS tool_calls,
+         COALESCE(SUM(CASE WHEN category = 'error' THEN 1 ELSE 0 END), 0) AS errors,
+         COUNT(DISTINCT type) AS unique_tools,
+         COUNT(DISTINCT CASE WHEN category = 'file' THEN data END) AS unique_files,
+         CASE WHEN SUM(CASE WHEN category = 'git' THEN 1 ELSE 0 END) > 0 THEN 1 ELSE 0 END AS has_commit,
+         CAST(COALESCE((MAX(strftime('%s', created_at)) - MIN(strftime('%s', created_at))) / 60.0, 0) AS INTEGER) AS duration_min,
+         COALESCE(SUM(CASE WHEN type = 'external_ref' THEN 1 ELSE 0 END), 0) AS sources_indexed,
+         CAST(COALESCE(SUM(bytes_avoided) / 1024.0, 0) AS INTEGER) AS total_chunks,
+         COALESCE(SUM(CASE WHEN type IN ('file_search', 'file_glob') THEN 1 ELSE 0 END), 0) AS search_queries
+       FROM session_events
+       WHERE session_id = ?`);
+        // max_file_edits: max edits on any single file path in the session.
+        // Two-level aggregation — GROUP BY data first, then MAX of those counts.
+        p(S.getMaxFileEdits, `SELECT COALESCE(MAX(c), 0) AS max_file_edits
+       FROM (
+         SELECT COUNT(*) AS c
+         FROM session_events
+         WHERE session_id = ? AND category = 'file' AND type IN ('file_edit', 'file_write')
+         GROUP BY data
+       )`);
         p(S.incrementCompactCount, `UPDATE session_meta SET compact_count = compact_count + 1 WHERE session_id = ?`);
         // ── Resume ──
         p(S.upsertResume, `INSERT INTO session_resume (session_id, snapshot, event_count)
@@ -1017,6 +1048,46 @@ export class SessionDB extends SQLiteBase {
         const row = this.stmt(S.getSessionStats).get(sessionId);
         return row ?? null;
     }
+    /**
+     * Session rollup snapshot — 12 aggregate fields the analytics platform
+     * stamps onto every outgoing event row (seed.ts shape parity).
+     *
+     * Called from session-loaders BEFORE `maybeForward`; the snapshot is
+     * computed against the LOCAL SessionDB and threaded into the canonical
+     * event so the platform-side Zod schema receives the rich shape without
+     * the bridge ever hand-mapping fields (PRD §5.4 ABI passthrough).
+     *
+     * Returns zeroed defaults for unknown sessions — callers MUST tolerate
+     * a snapshot from an empty session (first event into a fresh DB).
+     */
+    getSessionRollup(sessionId) {
+        const main = this.stmt(S.getSessionRollup).get(sessionId);
+        const maxRow = this.stmt(S.getMaxFileEdits).get(sessionId);
+        const meta = this.getSessionStats(sessionId);
+        // edit_test_cycles: heuristic — min(file edits, errors) approximates
+        // the number of edit-then-test attempts in a session. Exact pattern
+        // detection (consecutive file_edit followed by error_tool) would need
+        // a windowed query; this scalar pair under-counts but never overshoots.
+        const fileEdits = (main?.tool_calls ?? 0) > 0
+            ? (main?.unique_files ?? 0)
+            : 0;
+        const errors = main?.errors ?? 0;
+        const editTestCycles = Math.min(fileEdits, errors);
+        return {
+            tool_calls: main?.tool_calls ?? 0,
+            errors: main?.errors ?? 0,
+            unique_tools: main?.unique_tools ?? 0,
+            unique_files: main?.unique_files ?? 0,
+            max_file_edits: maxRow?.max_file_edits ?? 0,
+            has_commit: main?.has_commit ?? 0,
+            edit_test_cycles: editTestCycles,
+            duration_min: main?.duration_min ?? 0,
+            compact_count: meta?.compact_count ?? 0,
+            sources_indexed: main?.sources_indexed ?? 0,
+            total_chunks: main?.total_chunks ?? 0,
+            search_queries: main?.search_queries ?? 0,
+        };
+    }
     /**
      * Increment the compact_count for a session (tracks snapshot rebuilds).
      */