context-mode 1.0.130 → 1.0.132

package/build/session/analytics.js

@@ -1256,7 +1256,16 @@ function renderNarrative5Section(args) {
     const lifetimeLegacyTokens = lifetimeEventsTokens + lifetimeRescueTokens;
     const lifetimeRealTokens = realBytes?.lifetime?.totalSavedTokens ?? 0;
     const lifetimeTokensWithout = Math.max(lifetimeLegacyTokens, lifetimeRealTokens);
-    const lifetimeTokensWith = Math.max(1, Math.round(lifetimeTokensWithout * 0.02));
+    // Lifetime "with" — measured when available, else legacy 0.02 fallback.
+    // Honest definition (matches conversation bar below):
+    //   "with"    = bytes_returned (what the model actually re-saw)
+    //   "without" = bytes_returned + bytes_avoided
+    // When the schema has measurement, derive `with` from `bytes_returned/4`.
+    const lifeRet = realBytes?.lifetime?.bytesReturned ?? 0;
+    const lifeAv = realBytes?.lifetime?.bytesAvoided ?? 0;
+    const lifetimeTokensWith = (lifeRet + lifeAv) > 0
+        ? Math.max(1, Math.floor(lifeRet / 4))
+        : Math.max(1, Math.round(lifetimeTokensWithout * 0.02));
     // Bytes from realBytes when present, else derive from tokens (×4 — same
     // ratio Phase 8 uses everywhere). All-work bytes drives the opener tally
     // + the section-3 receipt + section-4 cost example.
@@ -1328,15 +1337,32 @@ function renderNarrative5Section(args) {
         out.push(`  Without that, you'd be re-explaining everything to a blank model right now.`);
     }
     out.push("");
-    // Without/With bars — the screenshottable proof for THIS conversation.
-    const convTokensWith = Math.max(1, Math.round(conversationTokens * 0.02));
-    const withoutBar = dataBar(conversationTokens, conversationTokens, 32);
-    const withBar = dataBar(convTokensWith, conversationTokens, 32);
-    const convPct = conversationTokens > 0 ? (1 - convTokensWith / conversationTokens) * 100 : 0;
-    out.push(`  Without context-mode  ${kb(convBytes).padStart(8)}  ${withoutBar}   ${fmtNum(conversationTokens).padStart(7)} tokens`);
-    out.push(`  With context-mode     ${kb(Math.max(1, Math.round(convBytes * 0.02))).padStart(8)}  ${withBar}   ${fmtNum(convTokensWith).padStart(7)} tokens`);
-    out.push(`                          ${convPct.toFixed(0)}% kept out of context · your AI ran ${Math.max(1, Math.round(conversationTokens / convTokensWith))}× longer before /compact fired`);
-    out.push("");
+    // Without/With bars — measured from real per-event bytes_returned / bytes_avoided.
+    //
+    // Honest definitions:
+    //   Without = bytes the model WOULD have re-seen with no filtering    = bytes_returned + bytes_avoided
+    //   With    = bytes the model ACTUALLY re-saw after context-mode      = bytes_returned
+    //
+    // No fallback to heuristic. If the schema has zero signal for this
+    // conversation (no hook ever populated bytes_avoided / bytes_returned),
+    // the section is skipped entirely. Honesty over decoration.
+    const realConv = realBytes?.conversation;
+    const measuredAvoided = realConv?.bytesAvoided ?? 0;
+    const measuredReturned = realConv?.bytesReturned ?? 0;
+    if (measuredAvoided + measuredReturned > 0) {
+        const convBytesWithout = measuredReturned + measuredAvoided;
+        const convBytesWith = Math.max(1, measuredReturned);
+        const convTokensWithout = Math.max(1, Math.floor(convBytesWithout / 4));
+        const convTokensWith = Math.max(1, Math.floor(convBytesWith / 4));
+        const withoutBar = dataBar(convTokensWithout, convTokensWithout, 32);
+        const withBar = dataBar(convTokensWith, convTokensWithout, 32);
+        const convPct = (1 - convTokensWith / convTokensWithout) * 100;
+        const convMult = Math.max(1, Math.round(convTokensWithout / convTokensWith));
+        out.push(`  Without context-mode  ${kb(convBytesWithout).padStart(8)}  ${withoutBar}   ${fmtNum(convTokensWithout).padStart(7)} tokens`);
+        out.push(`  With context-mode     ${kb(convBytesWith).padStart(8)}  ${withBar}   ${fmtNum(convTokensWith).padStart(7)} tokens`);
+        out.push(`                          ${convPct.toFixed(0)}% kept out of context · your AI ran ${convMult}× longer before /compact fired`);
+        out.push("");
+    }
     // Timeline — drop-in if conversation has byDay.
     if (conversation.byDay && conversation.byDay.length > 0) {
         const totalConvDays = conversation.lastEventMs && conversation.firstEventMs

package/build/session/extract.d.ts

@@ -15,6 +15,13 @@ export interface SessionEvent {
     data: string;
     /** 1=critical (rules, files, tasks) … 5=low */
     priority: number;
+    /**
+     * Optional — bytes context-mode prevented from entering the model context
+     * window for this event. Currently populated by external_ref when a
+     * ctx_fetch_and_index tool_response carries the
+     * `Fetched and indexed N sections (XKB)` preamble.
+     */
+    bytes_avoided?: number;
 }
 export interface ToolCall {
     toolName: string;

package/build/session/extract.js

@@ -678,12 +678,28 @@ function extractExternalRef(input) {
     }
     if (refs.size === 0)
         return [];
-    return [{
-            type: "external_ref",
-            category: "external-ref",
-            data: safeString(Array.from(refs).join(", ")),
-            priority: 3,
-        }];
+    // ctx_fetch_and_index returns a preamble like
+    //   "Fetched and indexed **5 sections** (47.50KB) from: <label>"
+    // Parse the size to credit bytes_avoided on the event so per-session
+    // honest-savings stats reflect what was kept out of the context window.
+    // KB literal in the preamble is decimal (KB = 1024 bytes per the formatter).
+    let bytesAvoided;
+    const preambleMatch = safeString(input.tool_response).match(/Fetched and indexed[^\(]*\(([\d.]+)\s*KB\)/i);
+    if (preambleMatch) {
+        const kb = Number(preambleMatch[1]);
+        if (Number.isFinite(kb) && kb > 0) {
+            bytesAvoided = Math.round(kb * 1024);
+        }
+    }
+    const event = {
+        type: "external_ref",
+        category: "external-ref",
+        data: safeString(Array.from(refs).join(", ")),
+        priority: 3,
+    };
+    if (bytesAvoided !== undefined)
+        event.bytes_avoided = bytesAvoided;
+    return [event];
 }
 /**
  * Category 8: env (worktree)

package/build/store.d.ts

@@ -41,13 +41,25 @@ export declare class ContentStore {
         content?: string;
         path?: string;
         source?: string;
+        /**
+         * Optional FK metadata recorded on each indexed chunk so per-session
+         * honest-savings stats can join chunks → session_events. When omitted,
+         * chunks fall back to empty-string columns (legacy behaviour).
+         */
+        attribution?: {
+            sessionId?: string;
+            eventId?: string;
+        };
     }): IndexResult;
     /**
      * Index plain-text output (logs, build output, test results) by splitting
      * into fixed-size line groups. Unlike markdown indexing, this does not
      * look for headings — it chunks by line count with overlap.
      */
-    indexPlainText(content: string, source: string, linesPerChunk?: number): IndexResult;
+    indexPlainText(content: string, source: string, linesPerChunk?: number, attribution?: {
+        sessionId?: string;
+        eventId?: string;
+    }): IndexResult;
     /**
      * Index JSON content by walking the object tree and using key paths
      * as chunk titles (analogous to heading hierarchy in markdown). Objects
@@ -55,7 +67,10 @@ export declare class ContentStore {
      *
      * Falls back to `indexPlainText` if the content is not valid JSON.
      */
-    indexJSON(content: string, source: string, maxChunkBytes?: number): IndexResult;
+    indexJSON(content: string, source: string, maxChunkBytes?: number, attribution?: {
+        sessionId?: string;
+        eventId?: string;
+    }): IndexResult;
     search(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose", sourceMatchMode?: SourceMatchMode): SearchResult[];
     searchTrigram(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose", sourceMatchMode?: SourceMatchMode): SearchResult[];
     fuzzyCorrect(query: string): string | null;

package/build/store.js

@@ -714,7 +714,7 @@ export class ContentStore {
     }
     // ── Index ──
     index(options) {
-        const { content, path, source } = options;
+        const { content, path, source, attribution } = options;
         // Treat empty string as "no content" so an empty `content` paired with a
         // valid `path` falls back to reading the file. Some MCP clients
         // materialize optional string fields as `""` and the previous
@@ -754,7 +754,7 @@ export class ContentStore {
         // Stale detection: store file_path + SHA-256 for file-backed sources
         const filePath = path ?? undefined;
         const contentHash = filePath ? createHash("sha256").update(text).digest("hex") : undefined;
-        return withRetry(() => this.#insertChunks(chunks, label, text, filePath, contentHash));
+        return withRetry(() => this.#insertChunks(chunks, label, text, filePath, contentHash, attribution));
     }
     // ── Index Plain Text ──
     /**
@@ -762,12 +762,12 @@ export class ContentStore {
      * into fixed-size line groups. Unlike markdown indexing, this does not
      * look for headings — it chunks by line count with overlap.
      */
-    indexPlainText(content, source, linesPerChunk = 20) {
+    indexPlainText(content, source, linesPerChunk = 20, attribution) {
         if (!content || content.trim().length === 0) {
-            return this.#insertChunks([], source, "");
+            return this.#insertChunks([], source, "", undefined, undefined, attribution);
         }
         const chunks = this.#chunkPlainText(content, linesPerChunk);
-        return withRetry(() => this.#insertChunks(chunks.map((c) => ({ ...c, hasCode: false })), source, content));
+        return withRetry(() => this.#insertChunks(chunks.map((c) => ({ ...c, hasCode: false })), source, content, undefined, undefined, attribution));
     }
     // ── Index JSON ──
     /**
@@ -777,23 +777,23 @@ export class ContentStore {
      *
      * Falls back to `indexPlainText` if the content is not valid JSON.
      */
-    indexJSON(content, source, maxChunkBytes = MAX_CHUNK_BYTES) {
+    indexJSON(content, source, maxChunkBytes = MAX_CHUNK_BYTES, attribution) {
         if (!content || content.trim().length === 0) {
-            return this.indexPlainText("", source);
+            return this.indexPlainText("", source, undefined, attribution);
         }
         let parsed;
         try {
             parsed = JSON.parse(content);
         }
         catch {
-            return this.indexPlainText(content, source);
+            return this.indexPlainText(content, source, undefined, attribution);
         }
         const chunks = [];
         this.#walkJSON(parsed, [], chunks, maxChunkBytes);
         if (chunks.length === 0) {
-            return this.indexPlainText(content, source);
+            return this.indexPlainText(content, source, undefined, attribution);
         }
-        return withRetry(() => this.#insertChunks(chunks, source, content));
+        return withRetry(() => this.#insertChunks(chunks, source, content, undefined, undefined, attribution));
     }
     // ── Shared DB Insertion ──
     /**
@@ -801,8 +801,12 @@ export class ContentStore {
      * into both FTS5 tables within a transaction and extracts vocabulary.
      * Uses cached prepared statements from #prepareStatements().
      */
-    #insertChunks(chunks, label, text, filePath, contentHash) {
+    #insertChunks(chunks, label, text, filePath, contentHash, attribution) {
         const codeChunks = chunks.filter((c) => c.hasCode).length;
+        // FK columns on chunks. Empty-string fallback preserves the FTS5-friendly
+        // "not-null but unattributed" sentinel used by legacy rows.
+        const sessionIdCol = attribution?.sessionId ?? "";
+        const eventIdCol = attribution?.eventId ?? "";
         // Atomic dedup + insert: delete previous source with same label,
         // then insert new content — all within a single transaction.
         // Prevents stale results in iterative workflows. (See: GitHub issue #67)
@@ -819,8 +823,8 @@ export class ContentStore {
             const now = new Date().toISOString();
             for (const chunk of chunks) {
                 const ct = chunk.hasCode ? "code" : "prose";
-                this.#stmtInsertChunk.run(chunk.title, chunk.content, sourceId, ct, null, null, null, now);
-                this.#stmtInsertChunkTrigram.run(chunk.title, chunk.content, sourceId, ct, null, null, null, now);
+                this.#stmtInsertChunk.run(chunk.title, chunk.content, sourceId, ct, null, sessionIdCol, eventIdCol, now);
+                this.#stmtInsertChunkTrigram.run(chunk.title, chunk.content, sourceId, ct, null, sessionIdCol, eventIdCol, now);
             }
             return sourceId;
         });

package/build/util/sibling-mcp.d.ts

@@ -38,6 +38,21 @@ export interface DiscoverOptions {
     platform?: NodeJS.Platform;
     /** Test injection point — defaults to `child_process.execFileSync`. */
     runCommand?: RunCommand;
+    /**
+     * When true, only return pids whose parent (ppid) is the SAME as the
+     * caller's own ppid (i.e. siblings under the same host process).
+     *
+     * Used by the startup sweep (#565) so an opencode-spawned MCP child
+     * only reaps OTHER opencode-spawned MCP children, never the children
+     * of a different opencode/Claude host running in parallel.
+     *
+     * Requires a way to read each pid's ppid. Defaults to a `ps -o ppid=`
+     * probe on POSIX and PowerShell `Get-CimInstance` on Windows. Set
+     * `readPpid` to inject in tests.
+     */
+    sameParentOnly?: boolean;
+    /** Test injection — read ppid for a given pid. Defaults to platform probe. */
+    readPpid?: (pid: number) => number;
 }
 export interface KillOptions {
     pids: readonly number[];
@@ -77,3 +92,28 @@ export declare function discoverSiblingMcpPids(opts: DiscoverOptions): number[];
  *      counted — they were not ours to kill.
  */
 export declare function killSiblingMcpServers(opts: KillOptions): Promise<KillReport>;
+/**
+ * Startup-time sibling sweep (#565).
+ *
+ * Discovers any context-mode MCP server pids that share OUR parent process
+ * (i.e. other MCP children of the same host like `opencode serve`) and
+ * terminates them. The intent is "exactly one MCP child per host" — when a
+ * new MCP client spawns inside an opencode host that already has 25 stale
+ * idle siblings, this sweep reclaims them at boot rather than waiting for
+ * the idle timeout to fire on each one independently.
+ *
+ * Gated by env (default-on but easy to disable):
+ *
+ *   CONTEXT_MODE_STARTUP_SWEEP=0   → disabled
+ *   CONTEXT_MODE_STARTUP_SWEEP=1   → enabled (default)
+ *
+ * Safety:
+ *   - `sameParentOnly: true` — never touches MCP children of a different host.
+ *   - Best-effort throughout: failures never block server startup.
+ *   - Composes with the idle-timeout path: if a sibling is actively in use
+ *     by another session, the parent process will simply spawn a new MCP
+ *     child on its next request. The cost is one cold-start (~1–3 s) for
+ *     that session, which is identical to opencode's existing behaviour
+ *     of spawning a fresh MCP child per session anyway.
+ */
+export declare function startupSiblingSweep(env?: NodeJS.ProcessEnv): Promise<KillReport>;

package/build/util/sibling-mcp.js

@@ -26,19 +26,70 @@
  * cross-platform without spawning real processes.
  */
 import { execFileSync } from "node:child_process";
-// Match BOTH `~/.claude/plugins/cache/context-mode/context-mode/<v>/start.mjs`
-// AND `~/.claude/plugins/marketplaces/context-mode/start.mjs` shapes.
-// Both can be alive concurrently — VERDICT R1 dump confirmed all four
-// PIDs simultaneously across three different versions on a real Mac.
-const POSIX_PGREP_PATTERN = "node.*plugins/(cache|marketplaces)/.*context-mode.*start\\.mjs";
+// Match every shape an installed context-mode MCP server can take in argv:
+//
+//   1. `~/.claude/plugins/cache/context-mode/context-mode/<v>/start.mjs`
+//      and `~/.claude/plugins/marketplaces/context-mode/start.mjs` — Claude
+//      Code plugin shapes (original #559 case).
+//   2. `<prefix>/node_modules/context-mode/start.mjs` or `.../server.bundle.mjs`
+//      — npm-global, marketplace, manual installs.
+//   3. `<prefix>/bin/context-mode` — npm-global bin shim. This is the argv
+//      OpenCode + KiloCode see when they spawn `mcp.command = ["context-mode"]`.
+//      Without this entry, sibling discovery missed the 26-child / 1.6 GB
+//      RSS accumulation reported in #565.
+//   4. `bun .../context-mode/server.bundle.mjs` — Pi/Bun hosts.
+//
+// All four can be alive concurrently — VERDICT R1 dump confirmed multi-version
+// coexistence on real macOS, and #565 confirmed concurrent OpenCode children
+// alongside Claude Code children on Linux.
+const POSIX_PGREP_PATTERN = "(node|bun).*(plugins/(cache|marketplaces)/.*context-mode.*start\\.mjs" +
+    "|context-mode/start\\.mjs" +
+    "|context-mode/server\\.bundle\\.mjs" +
+    "|bin/context-mode($|[^a-zA-Z0-9_-]))";
 // Windows: PowerShell + Get-CimInstance (wmic deprecated since Win11 22H2).
-// Filter on CommandLine because Win32_Process.Name is just "node.exe".
-// Two backslashes inside `start\.mjs` are needed because the Like operator
-// uses regex-ish escaping at the JS layer.
+// Filter includes both node.exe and bun.exe (Pi/Bun hosts). CommandLine
+// matching covers the same four install shapes as POSIX_PGREP_PATTERN.
 const WIN_PS_SCRIPT = "Get-CimInstance Win32_Process " +
-    "-Filter \"Name='node.exe'\" | " +
-    "Where-Object { $_.CommandLine -match 'plugins[\\\\/](cache|marketplaces)[\\\\/].*context-mode.*start\\.mjs' } | " +
+    "-Filter \"Name='node.exe' OR Name='bun.exe'\" | " +
+    "Where-Object { $_.CommandLine -match " +
+    "'plugins[\\\\/](cache|marketplaces)[\\\\/].*context-mode.*start\\.mjs" +
+    "|context-mode[\\\\/]start\\.mjs" +
+    "|context-mode[\\\\/]server\\.bundle\\.mjs" +
+    "|bin[\\\\/]context-mode($|[^a-zA-Z0-9_-])' } | " +
     "Select-Object -ExpandProperty ProcessId";
+/** POSIX ppid probe — empty / NaN on failure. */
+function readPpidPosix(pid) {
+    try {
+        const out = execFileSync("ps", ["-o", "ppid=", "-p", String(pid)], {
+            encoding: "utf-8",
+            timeout: 2000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        const n = Number.parseInt(out, 10);
+        return Number.isFinite(n) ? n : NaN;
+    }
+    catch {
+        return NaN;
+    }
+}
+/** Windows ppid probe — empty / NaN on failure. */
+function readPpidWin32(pid) {
+    try {
+        const out = execFileSync("powershell", [
+            "-NoProfile",
+            "-Command",
+            `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").ParentProcessId`,
+        ], { encoding: "utf-8", timeout: 2000, stdio: ["ignore", "pipe", "ignore"] }).trim();
+        const n = Number.parseInt(out, 10);
+        return Number.isFinite(n) ? n : NaN;
+    }
+    catch {
+        return NaN;
+    }
+}
+function defaultReadPpid(pid) {
+    return process.platform === "win32" ? readPpidWin32(pid) : readPpidPosix(pid);
+}
 const defaultRun = (cmd, args) => execFileSync(cmd, [...args], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
 const defaultIsAlive = (pid) => {
     try {
@@ -94,7 +145,18 @@ export function discoverSiblingMcpPids(opts) {
     catch {
         return [];
     }
-    return parsePidList(stdout).filter((pid) => pid !== opts.ownPid && pid !== opts.ownPpid);
+    const candidates = parsePidList(stdout).filter((pid) => pid !== opts.ownPid && pid !== opts.ownPpid);
+    if (!opts.sameParentOnly)
+        return candidates;
+    // Startup-sweep mode (#565): only reap siblings sharing OUR ppid. This
+    // prevents an opencode-spawned MCP child from killing a Claude Code MCP
+    // child (or another concurrent opencode host's children) when both are
+    // present on the same machine.
+    const readPpid = opts.readPpid ?? defaultReadPpid;
+    return candidates.filter((pid) => {
+        const ppid = readPpid(pid);
+        return Number.isFinite(ppid) && ppid === opts.ownPpid;
+    });
 }
 /** Sleep helper — Promise-based for use inside the kill polling loop. */
 function delay(ms) {
@@ -179,3 +241,46 @@ export async function killSiblingMcpServers(opts) {
         totalKilled: terminatedBySigterm + terminatedBySigkill,
     };
 }
+/**
+ * Startup-time sibling sweep (#565).
+ *
+ * Discovers any context-mode MCP server pids that share OUR parent process
+ * (i.e. other MCP children of the same host like `opencode serve`) and
+ * terminates them. The intent is "exactly one MCP child per host" — when a
+ * new MCP client spawns inside an opencode host that already has 25 stale
+ * idle siblings, this sweep reclaims them at boot rather than waiting for
+ * the idle timeout to fire on each one independently.
+ *
+ * Gated by env (default-on but easy to disable):
+ *
+ *   CONTEXT_MODE_STARTUP_SWEEP=0   → disabled
+ *   CONTEXT_MODE_STARTUP_SWEEP=1   → enabled (default)
+ *
+ * Safety:
+ *   - `sameParentOnly: true` — never touches MCP children of a different host.
+ *   - Best-effort throughout: failures never block server startup.
+ *   - Composes with the idle-timeout path: if a sibling is actively in use
+ *     by another session, the parent process will simply spawn a new MCP
+ *     child on its next request. The cost is one cold-start (~1–3 s) for
+ *     that session, which is identical to opencode's existing behaviour
+ *     of spawning a fresh MCP child per session anyway.
+ */
+export async function startupSiblingSweep(env = process.env) {
+    const empty = { terminatedBySigterm: 0, terminatedBySigkill: 0, totalKilled: 0 };
+    const raw = env.CONTEXT_MODE_STARTUP_SWEEP;
+    if (raw === "0" || raw === "false")
+        return empty;
+    try {
+        const pids = discoverSiblingMcpPids({
+            ownPid: process.pid,
+            ownPpid: process.ppid,
+            sameParentOnly: true,
+        });
+        if (pids.length === 0)
+            return empty;
+        return await killSiblingMcpServers({ pids });
+    }
+    catch {
+        return empty;
+    }
+}