@cortexkit/opencode-magic-context 0.31.5 → 0.32.1

package/src/shared/rpc-notifications.ts

@@ -26,6 +26,8 @@ let nextNotificationId = 1;
 export interface NotificationSink {
     /** The TUI's active session at connect time (its hello scope). */
     sessionId?: string;
+    /** Protocol 2 clients use strict session scoping; absent means legacy behavior. */
+    protocol?: number;
     /** Deliver one notification over this sink's live socket. */
     send: (notification: RpcNotification) => void;
 }
@@ -48,23 +50,19 @@ export function registerNotificationSink(sink: NotificationSink): () => void {
     };
 }
 
-/** Whether a given notification may be delivered to a given sink. A global
- *  notification (no sessionId) reaches every sink; a session-scoped one reaches
- *  only sinks for that session (or session-less sinks). Mirrors the drain filter
- *  from the sink's perspective. */
+/** Whether a notification may be delivered to a sink. Protocol 2 makes a
+ * session-less socket global-only; legacy sockets retain broad compatibility. */
 function notificationMatchesSink(notification: RpcNotification, sink: NotificationSink): boolean {
-    return (
-        notification.sessionId === undefined ||
-        sink.sessionId === undefined ||
-        notification.sessionId === sink.sessionId
-    );
+    if (notification.sessionId === undefined) return true;
+    if (sink.sessionId !== undefined) return notification.sessionId === sink.sessionId;
+    return sink.protocol !== 2;
 }
 
 /** Push a notification to the TUI. Fans out to any live WS sink immediately and
  *  also enqueues it so a TUI that is momentarily disconnected (reconnecting, or
  *  not yet connected) still receives it on its next hello via the backlog drain.
  *  At-least-once: a live push that the socket drops is re-delivered from the
- *  queue on reconnect (pruned only when the client acks via `lastReceivedId`). */
+ *  queue on reconnect (pruned only when the client acknowledges it). */
 export function pushNotification(
     type: string,
     payload: Record<string, unknown>,
@@ -83,30 +81,40 @@ export function pushNotification(
             // unregister it, and the queue backlog re-delivers on reconnect.
         }
     }
-    // Cap queue size to prevent unbounded growth if a TUI is not draining.
-    // Session-FAIR eviction: a naive `slice(-50)` drops the globally-oldest
-    // items, so a noisy session could evict ANOTHER session's single unseen
-    // notification. Instead, always retain each session's newest item, then
-    // fill the rest of the budget with the newest overall — no session can
-    // starve another's pending dialog out of the window.
+    // Keep a strict global bound. Reserve the newest item for at most 25 recently
+    // active scopes, then evict the oldest unreserved item. This protects a quiet
+    // session from one noisy peer without allowing one item per session to grow
+    // the queue without limit.
     if (queue.length > 100) {
-        const newestPerSession = new Map<string | undefined, number>();
-        for (const n of queue) {
-            const prev = newestPerSession.get(n.sessionId);
-            if (prev === undefined || n.id > prev) {
-                newestPerSession.set(n.sessionId, n.id);
-            }
+        const reservedIds = new Set<number>();
+        const reservedScopes = new Set<string>();
+        for (let i = queue.length - 1; i >= 0 && reservedScopes.size < 25; i -= 1) {
+            const candidate = queue[i];
+            const scope = candidate.sessionId ?? "\0global";
+            if (reservedScopes.has(scope)) continue;
+            reservedScopes.add(scope);
+            reservedIds.add(candidate.id);
         }
-        const mustKeep = new Set(newestPerSession.values());
-        const byNewest = [...queue].sort((a, b) => b.id - a.id);
-        const kept: RpcNotification[] = [];
-        for (const n of byNewest) {
-            if (kept.length < 50 || mustKeep.has(n.id)) kept.push(n);
-        }
-        queue = kept.sort((a, b) => a.id - b.id);
+        const evictionIndex = queue.findIndex((candidate) => !reservedIds.has(candidate.id));
+        queue.splice(evictionIndex >= 0 ? evictionIndex : 0, 1);
     }
 }
 
+export function acknowledgeNotifications(ids: readonly number[]): void {
+    const acknowledged = new Set(ids.filter((id) => Number.isSafeInteger(id) && id > 0));
+    if (acknowledged.size === 0) return;
+    // Exact removal preserves an earlier notification when a later handler finishes
+    // first or the earlier handler declines to consume its notification.
+    queue = queue.filter((notification) => !acknowledged.has(notification.id));
+}
+
+/** Reset process-local state to simulate a fresh server module in protocol tests. */
+export function __resetNotificationStateForTests(): void {
+    queue = [];
+    nextNotificationId = 1;
+    sinks.clear();
+}
+
 export interface DrainNotificationsOptions {
     /**
      * Cursor for global notifications when a session-scoped client sends separate
@@ -133,8 +141,8 @@ function cursor(value: number | undefined): number {
  *  behavior.
  *
  *  Delivery is at-least-once (non-destructive return + prune-on-ack): a returned
- *  notification stays queued until a later call acks it via the matching scope's
- *  cursor, so a dropped WS socket re-delivers unhandled backlog on reconnect. */
+ *  notification stays queued until an exact acknowledgement or a legacy cursor
+ *  removes it, so a dropped WS socket re-delivers unhandled backlog on reconnect. */
 export function drainNotifications(
     lastReceivedId = 0,
     sessionId?: string,
@@ -200,14 +208,15 @@ export function drainNotifications(
  *  Pass `sessionId` (preferred) to ask whether a TUI is connected FOR THAT
  *  SESSION — this is what producers (`/ctx-status`, `/ctx-recomp`, the upgrade
  *  reminder) must use to decide dialog-vs-message, so a TUI on a different
- *  session in the same process does not misroute their delivery. A session-less
- *  sink (legacy/global) counts for any session query. Omit `sessionId` only for
- *  callers with no session context; they get "any sink connected". */
+ *  session in the same process does not misroute their delivery. A modern
+ *  session-less sink is global-only; a legacy sink retains broad compatibility.
+ *  Omit `sessionId` only for callers with no session context. */
 export function isTuiConnected(sessionId?: string): boolean {
     if (sinks.size === 0) return false;
     if (sessionId === undefined) return true;
     for (const sink of sinks) {
-        if (sink.sessionId === undefined || sink.sessionId === sessionId) return true;
+        if (sink.sessionId === sessionId) return true;
+        if (sink.sessionId === undefined && sink.protocol !== 2) return true;
     }
     return false;
 }

package/src/shared/rpc-server.ts

@@ -13,6 +13,7 @@ import { dirname } from "node:path";
 import type { Server, ServerWebSocket } from "bun";
 import { log } from "./logger";
 import {
+    acknowledgeNotifications,
     drainNotifications,
     type NotificationSink,
     registerNotificationSink,
@@ -57,8 +58,12 @@ function bearerToken(req: Request): string {
     return typeof auth === "string" ? auth.replace(/^Bearer\s+/i, "") : "";
 }
 
-function websocketToken(req: Request, url: URL): string {
-    return bearerToken(req) || url.searchParams.get("token") || "";
+function websocketToken(req: Request): string {
+    const headerToken = bearerToken(req);
+    if (headerToken) return headerToken;
+    // v0.32 TUI clients put the token in the upgrade URL. Keep this fallback only
+    // for the v0.32→v0.32.1 skew window; remove it when v0.32 clients are unsupported.
+    return new URL(req.url).searchParams.get("token") ?? "";
 }
 
 /**
@@ -102,6 +107,14 @@ export class MagicContextRpcServer {
 
     /** Start the server on a random port, write port to disk. */
     async start(): Promise<number> {
+        if (typeof Bun === "undefined") {
+            // The only RPC consumer is the terminal-TUI sidebar, which exists only
+            // under the Bun runtime (OpenCode CLI). On Node/Electron (Desktop) there
+            // is no consumer, and Bun.serve would throw — skip cleanly instead of
+            // logging a misleading boot error.
+            log("rpc server skipped: Bun runtime not available (no TUI consumer)");
+            return 0;
+        }
         this.startedAt = Date.now();
         const self = this;
         const server = Bun.serve<WsData>({
@@ -234,7 +247,7 @@ export class MagicContextRpcServer {
         // WebSocket upgrade — the persistent push channel. Authenticate before
         // `srv.upgrade` so an unauthorized request never becomes a live socket.
         if (url.pathname === "/ws") {
-            if (!tokensMatch(websocketToken(req, url), this.token)) {
+            if (!tokensMatch(websocketToken(req), this.token)) {
                 return new Response("Unauthorized", { status: 401 });
             }
             const ok = srv.upgrade(req, { data: { authed: false } });
@@ -245,7 +258,7 @@ export class MagicContextRpcServer {
         // No wildcard CORS: the only legitimate client is the in-process TUI
         // client, not a browser origin.
         if (req.method === "GET" && url.pathname === "/health") {
-            return json({ ok: true, pid: process.pid });
+            return json({ ok: true, pid: process.pid, instance_id: this.instanceId });
         }
 
         if (req.method !== "POST" || !url.pathname.startsWith("/rpc/")) {
@@ -285,8 +298,8 @@ export class MagicContextRpcServer {
         }
     }
 
-    /** WS message handler: hello (auth + sink registration + backlog drain) and
-     *  ack (cursor advance → queue prune). All other messages are ignored. */
+    /** WS message handler: hello (auth + sink registration + backlog delivery) and
+     *  ack (exact removal or legacy cursor pruning). All other messages are ignored. */
     private handleWsMessage(ws: ServerWebSocket<WsData>, raw: string | Buffer): void {
         let msg: {
             type?: string;
@@ -295,6 +308,10 @@ export class MagicContextRpcServer {
             lastReceivedId?: number;
             globalLastReceivedId?: number;
             ackScope?: string;
+            protocol?: number;
+            instanceId?: string;
+            ids?: unknown;
+            cursor?: number;
         };
         try {
             msg = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
@@ -328,6 +345,7 @@ export class MagicContextRpcServer {
             // Register a live sink so future pushes reach this socket immediately.
             const sink: NotificationSink = {
                 sessionId: ws.data.sessionId,
+                protocol: msg.protocol,
                 send: (notification) => {
                     ws.send(JSON.stringify({ type: "notification", notification }));
                 },
@@ -335,40 +353,66 @@ export class MagicContextRpcServer {
             ws.data.unregister = registerNotificationSink(sink);
             this.sockets.add(ws);
 
-            // Deliver any backlog the client hasn't seen (at-least-once). Modern
-            // clients send separate session and global cursors; keeping those
-            // watermarks independent prevents a high id in one session from pruning
-            // lower unseen notifications in another session.
-            const lastReceivedId = Number(msg.lastReceivedId ?? 0);
-            const sessionCursor = Number.isFinite(lastReceivedId) ? lastReceivedId : 0;
-            const hasGlobalCursor = typeof msg.globalLastReceivedId === "number";
-            const globalLastReceivedId = hasGlobalCursor
-                ? Number.isFinite(msg.globalLastReceivedId)
-                    ? msg.globalLastReceivedId
-                    : 0
-                : 0;
-            const backlog =
-                ws.data.sessionId === undefined && hasGlobalCursor
-                    ? drainNotifications(globalLastReceivedId, undefined, { globalOnly: true })
-                    : drainNotifications(
-                          sessionCursor,
-                          ws.data.sessionId,
-                          hasGlobalCursor
-                              ? { globalLastReceivedId: globalLastReceivedId }
-                              : undefined,
-                      );
+            const usesExactAcknowledgements = msg.protocol === 2;
+            // The epoch arrives before backlog frames so the client can discard
+            // cursors and deduplication entries from a replaced server first.
+            ws.send(
+                JSON.stringify({
+                    type: "hello-ack",
+                    protocol: 2,
+                    instanceId: this.instanceId,
+                }),
+            );
+
+            let backlog: ReturnType<typeof drainNotifications>;
+            if (usesExactAcknowledgements) {
+                // Protocol 2 never treats a high handled id as proof that lower ids
+                // were consumed. Exact acknowledgements are the only destructive
+                // operation, so declined or interrupted dialogs survive reconnects.
+                backlog =
+                    ws.data.sessionId === undefined
+                        ? drainNotifications(0, undefined, { globalOnly: true })
+                        : drainNotifications(0, ws.data.sessionId, {
+                              globalLastReceivedId: 0,
+                          });
+            } else {
+                // Legacy clients use independent session and global watermarks.
+                const lastReceivedId = Number(msg.lastReceivedId ?? 0);
+                const sessionCursor = Number.isFinite(lastReceivedId) ? lastReceivedId : 0;
+                const hasGlobalCursor = typeof msg.globalLastReceivedId === "number";
+                const globalLastReceivedId = hasGlobalCursor
+                    ? Number.isFinite(msg.globalLastReceivedId)
+                        ? msg.globalLastReceivedId
+                        : 0
+                    : 0;
+                backlog =
+                    ws.data.sessionId === undefined && hasGlobalCursor
+                        ? drainNotifications(globalLastReceivedId, undefined, { globalOnly: true })
+                        : drainNotifications(
+                              sessionCursor,
+                              ws.data.sessionId,
+                              hasGlobalCursor
+                                  ? { globalLastReceivedId: globalLastReceivedId }
+                                  : undefined,
+                          );
+            }
             for (const notification of backlog) {
                 ws.send(JSON.stringify({ type: "notification", notification }));
             }
-            ws.send(JSON.stringify({ type: "hello-ack" }));
             return;
         }
 
         if (msg.type === "ack") {
-            // Advance only the cursor scope the client handled. Acking session A
-            // must not prune session B, and acking a global notification must not
-            // become a session watermark. Cheap, event-driven queue cleanup.
-            const lastReceivedId = Number(msg.lastReceivedId ?? 0);
+            if (Array.isArray(msg.ids)) {
+                acknowledgeNotifications(
+                    msg.ids.filter((id): id is number => typeof id === "number"),
+                );
+                return;
+            }
+
+            // Keep watermark acknowledgements during the one-release skew window.
+            // Scope isolation remains mandatory for these legacy messages.
+            const lastReceivedId = Number(msg.cursor ?? msg.lastReceivedId ?? 0);
             if (Number.isFinite(lastReceivedId) && lastReceivedId > 0) {
                 if (msg.ackScope === "global") {
                     drainNotifications(lastReceivedId, undefined, { globalOnly: true });

package/src/shared/sqlite.ts

@@ -137,11 +137,15 @@ function buildNodeSqliteDatabaseClass(DatabaseSync: any): typeof BetterSqlite3 {
         transaction<F extends (...args: any[]) => any>(fn: F): F {
             // biome-ignore lint/suspicious/noExplicitAny: faithful pass-through of this/args to fn.
             const self = this as any;
-            const wrapped = function (this: unknown, ...args: unknown[]): unknown {
+            const execute = (
+                mode: "" | "DEFERRED" | "IMMEDIATE" | "EXCLUSIVE",
+                receiver: unknown,
+                args: unknown[],
+            ) => {
                 const nested = self.isTransaction === true;
-                self.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : "BEGIN");
+                self.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : `BEGIN${mode ? ` ${mode}` : ""}`);
                 try {
-                    const result = fn.apply(this, args);
+                    const result = fn.apply(receiver, args);
                     self.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
                     return result;
                 } catch (error) {
@@ -157,6 +161,21 @@ function buildNodeSqliteDatabaseClass(DatabaseSync: any): typeof BetterSqlite3 {
                     throw error;
                 }
             };
+            const wrapped = function (this: unknown, ...args: unknown[]): unknown {
+                return execute("", this, args);
+            };
+            wrapped.default = function (this: unknown, ...args: unknown[]): unknown {
+                return execute("", this, args);
+            };
+            wrapped.deferred = function (this: unknown, ...args: unknown[]): unknown {
+                return execute("DEFERRED", this, args);
+            };
+            wrapped.immediate = function (this: unknown, ...args: unknown[]): unknown {
+                return execute("IMMEDIATE", this, args);
+            };
+            wrapped.exclusive = function (this: unknown, ...args: unknown[]): unknown {
+                return execute("EXCLUSIVE", this, args);
+            };
             return wrapped as unknown as F;
         }
     }

package/src/shared/tag-transcript.test.ts

@@ -1,8 +1,12 @@
 /// <reference types="bun-types" />
 
 import { describe, expect, it } from "bun:test";
+import { runMigrations } from "../features/magic-context/migrations";
 import type { ContextDatabase } from "../features/magic-context/storage";
-import type { Tagger } from "../features/magic-context/tagger";
+import { initializeDatabase } from "../features/magic-context/storage-db";
+import type { Tagger, ToolTagAccounting } from "../features/magic-context/tagger";
+import { createTagger } from "../features/magic-context/tagger";
+import { Database } from "./sqlite";
 import { tagTranscript } from "./tag-transcript";
 import type { Transcript, TranscriptPart, TranscriptPartKind } from "./transcript";
 
@@ -11,6 +15,7 @@ class FakeTagger implements Tagger {
     private toolTags = new Map<string, number>();
     readonly owners: string[] = [];
     readonly byteSizes = new Map<number, number>();
+    private readonly toolAccounting = new Map<number, ToolTagAccounting>();
 
     assignTag(): number {
         return this.nextTag++;
@@ -40,6 +45,23 @@ class FakeTagger implements Tagger {
         return this.toolTags.get(`${ownerMsgId}\0${callId}`);
     }
 
+    getToolTagAccounting(
+        _sessionId: string,
+        callId: string,
+        ownerMsgId: string,
+    ): ToolTagAccounting | undefined {
+        const tag = this.getToolTag(_sessionId, callId, ownerMsgId);
+        return tag === undefined ? undefined : this.toolAccounting.get(tag);
+    }
+
+    setToolTagAccounting(
+        _sessionId: string,
+        tagNumber: number,
+        accounting: ToolTagAccounting,
+    ): void {
+        this.toolAccounting.set(tagNumber, accounting);
+    }
+
     bindTag(): void {}
 
     bindToolTag(_sessionId: string, callId: string, ownerMsgId: string, tagNumber: number): void {
@@ -123,18 +145,31 @@ class NonTextToolResultPart extends TestPart {
 class FakeDb {
     readonly byteSizeUpdates: Array<{ byteSize: number; sessionId: string; tagNumber: number }> =
         [];
+    readonly tokenCountUpdates: Array<{
+        sessionId: string;
+        tagNumber: number;
+        tokenCount: number;
+    }> = [];
 
     prepare(sql: string): { run: (...args: unknown[]) => void } {
         return {
             run: (...args: unknown[]) => {
-                if (!sql.startsWith("UPDATE tags SET byte_size =")) return;
-                const [byteSize, sessionId, tagNumber] = args;
+                const [value, sessionId, tagNumber] = args;
                 if (
-                    typeof byteSize === "number" &&
-                    typeof sessionId === "string" &&
-                    typeof tagNumber === "number"
+                    typeof value !== "number" ||
+                    typeof sessionId !== "string" ||
+                    typeof tagNumber !== "number"
                 ) {
-                    this.byteSizeUpdates.push({ byteSize, sessionId, tagNumber });
+                    return;
+                }
+                if (sql.startsWith("UPDATE tags SET byte_size =")) {
+                    this.byteSizeUpdates.push({ byteSize: value, sessionId, tagNumber });
+                } else if (sql.startsWith("UPDATE tags SET token_count =")) {
+                    this.tokenCountUpdates.push({
+                        sessionId,
+                        tagNumber,
+                        tokenCount: value,
+                    });
                 }
             },
         };
@@ -271,6 +306,217 @@ describe("tagTranscript tool aggregation", () => {
         expect(result.getText()).toBe(`[dropped §${nearestTag}§]`);
     });
 
+    it("reuses owner-scoped identities without collapsing duplicate callIds", () => {
+        const tagger = new FakeTagger();
+        const seedDb = new FakeDb();
+        const seedTranscript: Transcript = {
+            harness: "pi",
+            messages: [
+                {
+                    info: { id: "assistant-old", role: "assistant" },
+                    parts: [new TestPart("tool_use", "duplicate-call", '{"turn":1}')],
+                },
+                {
+                    info: { id: "user-old", role: "user" },
+                    parts: [new TestPart("tool_result", "duplicate-call", "old result")],
+                },
+                {
+                    info: { id: "assistant-new", role: "assistant" },
+                    parts: [new TestPart("tool_use", "duplicate-call", '{"turn":2}')],
+                },
+                {
+                    info: { id: "user-new", role: "user" },
+                    parts: [new TestPart("tool_result", "duplicate-call", "new result")],
+                },
+            ],
+            commit() {},
+        };
+        tagTranscript(
+            "session-duplicate-reuse",
+            seedTranscript,
+            tagger,
+            seedDb as unknown as ContextDatabase,
+        );
+
+        const reusedParts = {
+            oldUse: new TestPart("tool_use", "duplicate-call", '{"turn":1}'),
+            oldResult: new TestPart("tool_result", "duplicate-call", "old result"),
+            newUse: new TestPart("tool_use", "duplicate-call", '{"turn":2}'),
+            newResult: new TestPart("tool_result", "duplicate-call", "new result"),
+        };
+        const reusedTranscript: Transcript = {
+            harness: "pi",
+            messages: [
+                {
+                    info: { id: "assistant-old", role: "assistant" },
+                    parts: [reusedParts.oldUse],
+                },
+                {
+                    info: { id: "user-old", role: "user" },
+                    parts: [reusedParts.oldResult],
+                },
+                {
+                    info: { id: "assistant-new", role: "assistant" },
+                    parts: [reusedParts.newUse],
+                },
+                {
+                    info: { id: "user-new", role: "user" },
+                    parts: [reusedParts.newResult],
+                },
+            ],
+            commit() {},
+        };
+        const reuseDb = new FakeDb();
+        const reused = tagTranscript(
+            "session-duplicate-reuse",
+            reusedTranscript,
+            tagger,
+            reuseDb as unknown as ContextDatabase,
+            {
+                reuseMessageIds: new Set([
+                    "assistant-old",
+                    "user-old",
+                    "assistant-new",
+                    "user-new",
+                ]),
+            },
+        );
+
+        const oldTag = tagger.getToolTag(
+            "session-duplicate-reuse",
+            "duplicate-call",
+            "assistant-old",
+        );
+        const newTag = tagger.getToolTag(
+            "session-duplicate-reuse",
+            "duplicate-call",
+            "assistant-new",
+        );
+        expect(oldTag).toBeDefined();
+        expect(newTag).toBeDefined();
+        expect(oldTag).not.toBe(newTag);
+        expect(reused.targets.size).toBe(2);
+        expect(reusedParts.oldResult.getText()).toBe(`§${oldTag}§ old result`);
+        expect(reusedParts.newResult.getText()).toBe(`§${newTag}§ new result`);
+        expect(reuseDb.byteSizeUpdates).toEqual([]);
+    });
+
+    it("backfills a newly appended result after reusing its stable invocation", () => {
+        const tagger = new FakeTagger();
+        const callId = "late-result";
+        tagTranscript(
+            "session-late-result",
+            {
+                harness: "pi",
+                messages: [
+                    {
+                        info: { id: "assistant-owner", role: "assistant" },
+                        parts: [new TestPart("tool_use", callId, '{"path":"a"}')],
+                    },
+                ],
+                commit() {},
+            },
+            tagger,
+            new FakeDb() as unknown as ContextDatabase,
+        );
+
+        const result = new TestPart("tool_result", callId, "late output");
+        const db = new FakeDb();
+        tagTranscript(
+            "session-late-result",
+            {
+                harness: "pi",
+                messages: [
+                    {
+                        info: { id: "assistant-owner", role: "assistant" },
+                        parts: [new TestPart("tool_use", callId, '{"path":"a"}')],
+                    },
+                    {
+                        info: { id: "user-result", role: "user" },
+                        parts: [result],
+                    },
+                ],
+                commit() {},
+            },
+            tagger,
+            db as unknown as ContextDatabase,
+            { reuseMessageIds: new Set(["assistant-owner"]) },
+        );
+
+        const tag = tagger.getToolTag("session-late-result", callId, "assistant-owner");
+        expect(result.getText()).toBe(`§${tag}§ late output`);
+        expect(db.byteSizeUpdates.some((update) => update.tagNumber === tag)).toBe(true);
+    });
+
+    it("persists the same grown folded-result accounting with reuse or full derivation", () => {
+        interface AccountingRow {
+            tagNumber: number;
+            byteSize: number;
+            tokenCount: number;
+        }
+
+        const runScenario = (reuse: boolean): { before: AccountingRow; after: AccountingRow } => {
+            const db = new Database(":memory:");
+            initializeDatabase(db);
+            runMigrations(db);
+            const sessionId = reuse ? "session-grown-reuse" : "session-grown-derive";
+            const tagger = createTagger();
+            tagger.initFromDb(sessionId, db);
+            const callId = "folded-growth";
+            const makeTranscript = (resultText: string): Transcript => ({
+                harness: "pi",
+                messages: [
+                    {
+                        info: { id: "assistant-owner", role: "assistant" },
+                        parts: [new TestPart("tool_use", callId, '{"path":"a"}')],
+                    },
+                    {
+                        // Pi folds the tool result into this following user entry, so
+                        // reuse is decided from the user's stable id.
+                        info: { id: "user-fold-target", role: "user" },
+                        parts: [new TestPart("tool_result", callId, resultText)],
+                    },
+                ],
+                commit() {},
+            });
+            const readAccounting = (): AccountingRow => {
+                const row = db
+                    .prepare(
+                        "SELECT tag_number AS tagNumber, byte_size AS byteSize, token_count AS tokenCount FROM tags WHERE session_id = ? AND type = 'tool'",
+                    )
+                    .get(sessionId) as AccountingRow | null;
+                if (!row) throw new Error("missing tool accounting row");
+                return row;
+            };
+
+            tagTranscript(sessionId, makeTranscript("small result"), tagger, db);
+            const before = readAccounting();
+            const nextPassTagger = createTagger();
+            nextPassTagger.initFromDb(sessionId, db);
+            tagTranscript(
+                sessionId,
+                makeTranscript("larger result ".repeat(80)),
+                nextPassTagger,
+                db,
+                {
+                    reuseMessageIds: reuse
+                        ? new Set(["assistant-owner", "user-fold-target"])
+                        : undefined,
+                },
+            );
+            const after = readAccounting();
+            db.close();
+            return { before, after };
+        };
+
+        const reused = runScenario(true);
+        const derived = runScenario(false);
+        expect(reused.after.tagNumber).toBe(reused.before.tagNumber);
+        expect(reused.after.byteSize).toBeGreaterThan(reused.before.byteSize);
+        expect(reused.after.tokenCount).toBeGreaterThan(reused.before.tokenCount);
+        expect(reused.after).toEqual(derived.after);
+    });
+
     it("accounts non-text tool_result content when ranking tool output byte size", () => {
         const tagger = new FakeTagger();
         const db = new FakeDb();