@tea-agent/loop-agent 0.40.0-next.11 → 0.40.0-next.13

package/dist/shared/pi-context-pressure/sift-bridge.js

@@ -0,0 +1,386 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
+import path from "node:path";
+import { parseBoundedNumber, parseEnabledFlag } from "./env.js";
+import { emptyContextPressureCounters, incrementCounter, } from "./telemetry.js";
+export const SIFT_POLICY_VERSION = "sift-v1-query-undefined";
+export const SIFT_RETRIEVE_TOOL_NAME = "sift_retrieve";
+export const SIFT_STASH_KEY_PATTERN = /^[0-9a-f]{24}$/;
+export const SIFT_RETRIEVE_DEFAULT_BYTES = 24 * 1024;
+export const SIFT_RETRIEVE_MAX_BYTES = 48 * 1024;
+export const DEFAULT_MEMO_MAX_ENTRIES = 128;
+export const DEFAULT_MEMO_MAX_BYTES = 32 * 1024 * 1024;
+export const DEFAULT_STASH_RETENTION_DAYS = 14;
+class BoundedMemo {
+    maxEntries;
+    maxBytes;
+    entries = new Map();
+    bytes = 0;
+    constructor(maxEntries, maxBytes) {
+        this.maxEntries = maxEntries;
+        this.maxBytes = maxBytes;
+    }
+    get(key) {
+        const hit = this.entries.get(key);
+        if (!hit)
+            return undefined;
+        this.entries.delete(key);
+        this.entries.set(key, hit);
+        try {
+            return JSON.parse(hit.json);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    set(key, value) {
+        const json = JSON.stringify(value);
+        const size = Buffer.byteLength(json);
+        if (size > this.maxBytes)
+            return;
+        this.delete(key);
+        while (this.entries.size >= this.maxEntries ||
+            this.bytes + size > this.maxBytes) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.delete(oldest);
+        }
+        this.entries.set(key, { json, bytes: size });
+        this.bytes += size;
+    }
+    delete(key) {
+        const current = this.entries.get(key);
+        if (!current)
+            return;
+        this.entries.delete(key);
+        this.bytes -= current.bytes;
+    }
+}
+export function parseSiftBridgeConfig(input) {
+    const env = input.env ?? process.env;
+    const override = env.HARNESS_CONSOLE_SIFT_STASH_DIR?.trim();
+    const root = override || input.defaultStashRoot;
+    const stashDir = path.join(root, input.sessionId);
+    const entries = parseBoundedNumber(env.HARNESS_CONSOLE_SIFT_MEMO_MAX_ENTRIES, DEFAULT_MEMO_MAX_ENTRIES, 8, 4096);
+    const bytes = parseBoundedNumber(env.HARNESS_CONSOLE_SIFT_MEMO_MAX_BYTES, DEFAULT_MEMO_MAX_BYTES, 1024, 256 * 1024 * 1024);
+    const retention = parseBoundedNumber(env.HARNESS_CONSOLE_SIFT_STASH_RETENTION_DAYS, DEFAULT_STASH_RETENTION_DAYS, 1, 365);
+    return {
+        sessionId: input.sessionId,
+        stashDir,
+        memoMaxEntries: entries.value,
+        memoMaxBytes: bytes.value,
+        retentionDays: retention.value,
+        ...(input.siftFactory ? { siftFactory: input.siftFactory } : {}),
+        ...(input.importSift ? { importSift: input.importSift } : {}),
+    };
+}
+export function createSiftBridgeState(config) {
+    return {
+        sessionId: config.sessionId,
+        stashDir: config.stashDir,
+        config,
+        counters: emptyContextPressureCounters(),
+        retrieveBypassIds: new Set(),
+        diagnostics: new Set(),
+        memo: new BoundedMemo(config.memoMaxEntries, config.memoMaxBytes),
+        importFailed: false,
+    };
+}
+function noteOnce(state, code) {
+    if (state.diagnostics.has(code))
+        return;
+    state.diagnostics.add(code);
+    incrementCounter(state.counters, "fail-open");
+}
+function memoKey(payload) {
+    return createHash("sha256")
+        .update(SIFT_POLICY_VERSION)
+        .update("\0")
+        .update(JSON.stringify(payload))
+        .digest("hex");
+}
+function ensureStashDir(stashDir) {
+    mkdirSync(stashDir, { recursive: true, mode: 0o700 });
+}
+async function ensureSift(state) {
+    if (state.sift)
+        return state.sift;
+    if (state.importFailed)
+        return undefined;
+    try {
+        ensureStashDir(state.stashDir);
+        if (state.config.siftFactory) {
+            state.sift = state.config.siftFactory({ stashDir: state.stashDir });
+            return state.sift;
+        }
+        const importer = state.config.importSift ??
+            (async () => (await import("@agent-context/sift")));
+        const mod = await importer();
+        if (typeof mod.createSift !== "function") {
+            state.importFailed = true;
+            noteOnce(state, "sift-import-invalid");
+            return undefined;
+        }
+        state.sift = mod.createSift({ stashDir: state.stashDir });
+        return state.sift;
+    }
+    catch {
+        state.importFailed = true;
+        noteOnce(state, "sift-import-failed");
+        return undefined;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasTrailingAnthropicCacheAnchor(payload) {
+    if (!isRecord(payload) || !Array.isArray(payload.messages))
+        return false;
+    const last = payload.messages[payload.messages.length - 1];
+    if (!isRecord(last))
+        return false;
+    const content = last.content;
+    if (!Array.isArray(content) || content.length === 0)
+        return false;
+    const lastBlock = content[content.length - 1];
+    return isRecord(lastBlock) && lastBlock.cache_control !== undefined;
+}
+function restoreProtectedToolResults(originalPayload, compressed, protectedIds) {
+    if (protectedIds.size === 0)
+        return compressed;
+    const original = structuredClone(originalPayload);
+    const next = structuredClone(compressed);
+    restoreInMessages(original, next, protectedIds);
+    restoreInResponsesInput(original, next, protectedIds);
+    return next;
+}
+function restoreInMessages(original, next, protectedIds) {
+    if (!isRecord(original) || !isRecord(next))
+        return;
+    if (!Array.isArray(original.messages) || !Array.isArray(next.messages))
+        return;
+    for (let index = 0; index < next.messages.length; index += 1) {
+        const origMsg = original.messages[index];
+        const nextMsg = next.messages[index];
+        if (!isRecord(origMsg) || !isRecord(nextMsg))
+            continue;
+        const origId = typeof origMsg.tool_call_id === "string"
+            ? origMsg.tool_call_id
+            : undefined;
+        if (origId && protectedIds.has(origId)) {
+            next.messages[index] = origMsg;
+            continue;
+        }
+        if (Array.isArray(origMsg.content) && Array.isArray(nextMsg.content)) {
+            for (let blockIndex = 0; blockIndex < nextMsg.content.length; blockIndex += 1) {
+                const origBlock = origMsg.content[blockIndex];
+                if (!isRecord(origBlock))
+                    continue;
+                const toolUseId = typeof origBlock.tool_use_id === "string"
+                    ? origBlock.tool_use_id
+                    : undefined;
+                if (toolUseId && protectedIds.has(toolUseId)) {
+                    nextMsg.content[blockIndex] = origBlock;
+                }
+            }
+        }
+    }
+}
+function restoreInResponsesInput(original, next, protectedIds) {
+    if (!isRecord(original) || !isRecord(next))
+        return;
+    if (!Array.isArray(original.input) || !Array.isArray(next.input))
+        return;
+    for (let index = 0; index < next.input.length; index += 1) {
+        const origItem = original.input[index];
+        if (!isRecord(origItem))
+            continue;
+        const callId = typeof origItem.call_id === "string" ? origItem.call_id : undefined;
+        if (callId && protectedIds.has(callId)) {
+            next.input[index] = origItem;
+        }
+    }
+}
+export async function compressProviderPayload(state, payload) {
+    if (payload === undefined)
+        return undefined;
+    if (!isRecord(payload)) {
+        noteOnce(state, "unknown-format");
+        return undefined;
+    }
+    const key = memoKey(payload);
+    const cached = state.memo.get(key);
+    if (cached !== undefined)
+        return cached;
+    if (hasTrailingAnthropicCacheAnchor(payload)) {
+        const sift = await ensureSift(state);
+        if (!sift)
+            return undefined;
+        try {
+            const result = sift.siftRequest(payload, undefined);
+            if (result.changed === false &&
+                result.blocksExamined === 0 &&
+                result.frozenMessages ===
+                    (Array.isArray(payload.messages)
+                        ? (payload.messages.length)
+                        : 0)) {
+                return undefined;
+            }
+            if (!result.changed)
+                return undefined;
+            noteOnce(state, "anthropic-unexpected-change");
+            return undefined;
+        }
+        catch {
+            noteOnce(state, "sift-handler-error");
+            return undefined;
+        }
+    }
+    const sift = await ensureSift(state);
+    if (!sift)
+        return undefined;
+    try {
+        const result = sift.siftRequest(payload, undefined);
+        if (!result || result.changed !== true)
+            return undefined;
+        const restored = restoreProtectedToolResults(payload, result.body, state.retrieveBypassIds);
+        state.counters.tokensSavedEstimate += Math.max(0, result.tokensSaved ?? 0);
+        state.counters.blocksCompressed += Math.max(0, result.blocksCompressed ?? 0);
+        incrementCounter(state.counters, "wire-compression");
+        state.memo.set(key, restored);
+        return restored;
+    }
+    catch {
+        noteOnce(state, "sift-handler-error");
+        return undefined;
+    }
+}
+export function clearRetrieveBypass(state) {
+    state.retrieveBypassIds.clear();
+}
+export function sliceUtf8Range(text, offset, maxBytes) {
+    const totalBytes = Buffer.byteLength(text, "utf8");
+    const start = Math.max(0, Math.floor(offset));
+    const limit = Math.min(SIFT_RETRIEVE_MAX_BYTES, Math.max(1, Math.floor(maxBytes)));
+    if (start >= totalBytes) {
+        return { slice: "", nextOffset: null, totalBytes, complete: true };
+    }
+    const buffer = Buffer.from(text, "utf8");
+    let end = Math.min(totalBytes, start + limit);
+    while (end > start && (buffer[end] & 0b1100_0000) === 0b1000_0000) {
+        end -= 1;
+    }
+    const slice = buffer.subarray(start, end).toString("utf8");
+    const complete = end >= totalBytes;
+    return {
+        slice,
+        nextOffset: complete ? null : end,
+        totalBytes,
+        complete,
+    };
+}
+export async function executeSiftRetrieve(state, toolCallId, params) {
+    const key = typeof params.key === "string" ? params.key.trim() : "";
+    if (!SIFT_STASH_KEY_PATTERN.test(key)) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "STASH_NOT_FOUND_OR_EXPIRED",
+                        complete: true,
+                    }),
+                },
+            ],
+        };
+    }
+    const sift = await ensureSift(state);
+    const original = sift?.retrieve(key) ?? null;
+    if (original === null) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "STASH_NOT_FOUND_OR_EXPIRED",
+                        complete: true,
+                    }),
+                },
+            ],
+        };
+    }
+    const offset = typeof params.offset === "number" && Number.isFinite(params.offset)
+        ? Math.max(0, Math.floor(params.offset))
+        : 0;
+    const maxBytes = typeof params.maxBytes === "number" && Number.isFinite(params.maxBytes)
+        ? params.maxBytes
+        : SIFT_RETRIEVE_DEFAULT_BYTES;
+    const page = sliceUtf8Range(original, offset, maxBytes);
+    if (toolCallId)
+        state.retrieveBypassIds.add(toolCallId);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    key,
+                    offset,
+                    maxBytes: Math.min(SIFT_RETRIEVE_MAX_BYTES, Math.max(1, Math.floor(maxBytes))),
+                    totalBytes: page.totalBytes,
+                    nextOffset: page.nextOffset,
+                    complete: page.complete,
+                    text: page.slice,
+                }),
+            },
+        ],
+    };
+}
+export function housekeepSiftStash(input) {
+    let removed = 0;
+    try {
+        const entries = readdirSync(input.root, { withFileTypes: true });
+        const cutoff = (input.now ?? Date.now()) - input.retentionDays * 24 * 60 * 60 * 1000;
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (input.activeSessionId && entry.name === input.activeSessionId)
+                continue;
+            const full = path.join(input.root, entry.name);
+            let mtime = 0;
+            try {
+                mtime = statSync(full).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if (mtime <= cutoff) {
+                rmSync(full, { recursive: true, force: true });
+                removed += 1;
+            }
+        }
+        return { removed, failed: false };
+    }
+    catch {
+        return { removed, failed: true };
+    }
+}
+export function createSiftRetrieveToolDefinition(state) {
+    return {
+        name: SIFT_RETRIEVE_TOOL_NAME,
+        label: "Sift Retrieve",
+        description: "Retrieve a previously compressed tool-output page by 24-hex stash key. Use offset/maxBytes to page; default 24KiB, max 48KiB.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                key: { type: "string", description: "24-hex stash key" },
+                offset: { type: "number", description: "UTF-8 byte offset" },
+                maxBytes: { type: "number", description: "Page size in bytes" },
+            },
+            required: ["key"],
+        },
+        execute: (toolCallId, params) => executeSiftRetrieve(state, toolCallId, params),
+    };
+}
+export { parseEnabledFlag };

package/dist/shared/pi-context-pressure/telemetry.js

@@ -0,0 +1,51 @@
+export function emptyContextPressureCounters() {
+    return {
+        prePromptThreshold: 0,
+        overflow: 0,
+        manual: 0,
+        wireCompression: 0,
+        failOpen: 0,
+        usageUnavailable: 0,
+        l0CompactFailed: 0,
+        tokensSavedEstimate: 0,
+        blocksCompressed: 0,
+    };
+}
+export function incrementCounter(counters, reason, amount = 1) {
+    switch (reason) {
+        case "pre-prompt-threshold":
+            counters.prePromptThreshold += amount;
+            break;
+        case "overflow":
+            counters.overflow += amount;
+            break;
+        case "manual":
+            counters.manual += amount;
+            break;
+        case "wire-compression":
+            counters.wireCompression += amount;
+            break;
+        case "fail-open":
+            counters.failOpen += amount;
+            break;
+        case "usage-unavailable":
+            counters.usageUnavailable += amount;
+            break;
+        case "l0-compact-failed":
+            counters.l0CompactFailed += amount;
+            break;
+        default:
+            break;
+    }
+}
+export function projectSafeTelemetry(counters) {
+    return {
+        prePromptThreshold: counters.prePromptThreshold,
+        overflow: counters.overflow,
+        manual: counters.manual,
+        wireCompression: counters.wireCompression,
+        failOpen: counters.failOpen,
+        tokensSavedEstimate: counters.tokensSavedEstimate,
+        blocksCompressed: counters.blocksCompressed,
+    };
+}

package/dist/worker/console/chat/assistant-content.js

@@ -98,6 +98,13 @@ function isFinalAnswerBlock(block) {
 }
 export function splitFinalAssistantBlocks(blocks, options = {}) {
     const displayable = getDisplayableAssistantBlocks(blocks, options);
+    // A streaming Pi message is cumulative: a later update may append a toolCall
+    // after text that is already visible. Keep the whole live message in the
+    // chronological process subtree so that update appends the tool in place
+    // instead of reparenting the earlier text from answer -> process.
+    if (options.isStreaming) {
+        return { answerBlocks: [], processBlocks: displayable };
+    }
     let lastProcessIndex = -1;
     for (let i = displayable.length - 1; i >= 0; i--) {
         if (!isFinalAnswerBlock(displayable[i])) {

package/dist/worker/console/chat/chat-event-store.js

@@ -136,7 +136,7 @@ export function projectOperationForChat(operation) {
         state: operation.state,
         createdAt: operation.createdAt,
         updatedAt: operation.finishedAt ?? operation.startedAt ?? operation.createdAt,
-        inspectHref: `/inspect/?operationId=${encodeURIComponent(operation.operationId)}#/`,
+        inspectHref: `/#/inspect?operationId=${encodeURIComponent(operation.operationId)}`,
         ...(taskId ? { taskId } : {}),
         ...(dagRunId ? { dagRunId } : {}),
         ...(featureId ? { featureId } : {}),
@@ -381,12 +381,26 @@ function dropOneByPriority(ring) {
     const events = ring.events;
     if (events.length === 0)
         return undefined;
-    const textIndex = events.findIndex((event) => event.kind === "message_update");
+    // Keep the newest Goal snapshot/tombstone as the session's durable Goal
+    // source of truth. Otherwise a long thread could forget an active Goal or
+    // resurrect a cleared one after ring eviction.
+    let protectedGoalIndex = -1;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        if (events[index].kind === "goal_changed" ||
+            events[index].kind === "goal_cleared") {
+            protectedGoalIndex = index;
+            break;
+        }
+    }
+    const textIndex = events.findIndex((event, index) => index !== protectedGoalIndex && event.kind === "message_update");
     if (textIndex !== -1)
         return events.splice(textIndex, 1)[0];
-    const structuralIndex = events.findIndex((event) => event.kind !== "message_end");
+    const structuralIndex = events.findIndex((event, index) => index !== protectedGoalIndex && event.kind !== "message_end");
     if (structuralIndex !== -1)
         return events.splice(structuralIndex, 1)[0];
+    const anyUnprotected = events.findIndex((_event, index) => index !== protectedGoalIndex);
+    if (anyUnprotected !== -1)
+        return events.splice(anyUnprotected, 1)[0];
     return events.shift();
 }
 /**
@@ -430,6 +444,13 @@ const DEFAULT_MAX_EVENTS = 2000;
 const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
 /** Same-turn `message_update` events inside this window coalesce into one persisted event. */
 const DEFAULT_COALESCE_WINDOW_MS = 100;
+/** B5-1: `message_update` appends persist at most once per this window (driven
+ *  by the event `at` clock, same as coalescing — no timers involved). */
+const DEFAULT_PERSIST_DEBOUNCE_MS = 250;
+/** B5-1: hard cap on pending debounced `message_update` appends before an
+ *  interim flush is forced, so a fast stream never widens the loss window
+ *  unboundedly even if the `at` clock stalls. */
+const DEFAULT_PERSIST_MAX_PENDING_UPDATES = 250;
 /** Conservative per-event scale for the byte pre-check gate (UTF-8 multibyte ≤ 4 bytes/char × pretty-print expansion). */
 const BYTE_GATE_SCALE = 12;
 /** Fixed envelope slack (schema keys, turnCount, nextSeq, minSeq, turns) for the byte pre-check gate. */
@@ -632,6 +653,9 @@ export function createChatEventStore(options) {
     const maxBytes = options?.maxBytesPerSession ?? DEFAULT_MAX_BYTES;
     const coalesceWindowMs = options?.coalesceWindowMs ?? DEFAULT_COALESCE_WINDOW_MS;
     const eventEpoch = options?.epoch?.trim() || LEGACY_EPOCH;
+    const persistWriter = options?.persistWriter ?? writeSecureJsonSync;
+    const persistDebounceMs = options?.persistDebounceMs ?? DEFAULT_PERSIST_DEBOUNCE_MS;
+    const persistMaxPendingUpdates = options?.persistMaxPendingUpdates ?? DEFAULT_PERSIST_MAX_PENDING_UPDATES;
     const persistenceDir = options?.appData?.chatEvents
         ? path.resolve(options.appData.chatEvents)
         : undefined;
@@ -642,6 +666,9 @@ export function createChatEventStore(options) {
     const turnCounts = new Map();
     /** Live subscribers per session. */
     const subscribers = new Map();
+    /** B5-1: sessions whose latest `message_update` appends are still waiting
+     *  for the next persist (debounced; structural events / turn changes flush). */
+    const pendingPersists = new Map();
     function persistedPath(sessionId) {
         return persistenceDir
             ? path.join(persistenceDir, `${safeSessionId(sessionId)}.json`)
@@ -709,7 +736,7 @@ export function createChatEventStore(options) {
             // current limits if it was written by an older config or hand-edited.
             enforceBounds(sessionId, ring);
             if (orphaned)
-                persist(sessionId, ring);
+                persistNow(sessionId, ring);
             return ring;
         }
         catch (error) {
@@ -763,11 +790,36 @@ export function createChatEventStore(options) {
             ring.minSeq = ring.events[0].seq;
         }
     }
-    function persist(sessionId, ring) {
+    /** Persist the full ring synchronously (atomic tmp+rename) and clear any
+     *  B5-1 pending-debounce marker for this session. */
+    function persistNow(sessionId, ring) {
         const file = persistedPath(sessionId);
+        pendingPersists.delete(sessionId);
         if (!file)
             return;
-        writeSecureJsonSync(file, ringPayload(sessionId, ring));
+        persistWriter(file, ringPayload(sessionId, ring));
+    }
+    /** B5-1: defer the persist of a `message_update` append. The window is driven
+     *  by the append `at` clock (mirroring `shouldCoalesce`) — a structural event,
+     *  turn change, elapsed window or the pending-count cap each force a real
+     *  flush, so a streaming turn no longer serializes the whole ring per token. */
+    function persistDebounced(sessionId, ring, atMs) {
+        const file = persistedPath(sessionId);
+        if (!file)
+            return;
+        const pending = pendingPersists.get(sessionId);
+        if (!pending) {
+            pendingPersists.set(sessionId, {
+                firstPendingAtMs: atMs,
+                pendingUpdates: 1,
+            });
+            return;
+        }
+        pending.pendingUpdates += 1;
+        if (atMs - pending.firstPendingAtMs >= persistDebounceMs ||
+            pending.pendingUpdates >= persistMaxPendingUpdates) {
+            persistNow(sessionId, ring);
+        }
     }
     function ringFor(sessionId) {
         let ring = rings.get(sessionId);
@@ -870,7 +922,7 @@ export function createChatEventStore(options) {
             };
             ring.turns.push(turn);
             ring.approxBytes += byteHint(turn);
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return { ok: true, turn: { ...turn }, created: true, idempotent: false };
         },
         setTurnState(sessionId, turnId, state, error) {
@@ -889,7 +941,7 @@ export function createChatEventStore(options) {
                 turn.error = error;
             ring.approxBytes +=
                 (JSON.stringify(turn).length - before) * BYTE_GATE_SCALE;
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return { ...turn };
         },
         markAbortRequested(sessionId, turnId, at) {
@@ -902,7 +954,7 @@ export function createChatEventStore(options) {
                 turn.abortRequestedAt = at ?? new Date().toISOString();
             ring.approxBytes +=
                 (JSON.stringify(turn).length - before) * BYTE_GATE_SCALE;
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return { ...turn };
         },
         findTurnByClientRequestId(sessionId, clientRequestId) {
@@ -962,7 +1014,23 @@ export function createChatEventStore(options) {
                 ring.approxBytes += byteHint(live);
             }
             enforceBounds(sessionId, ring);
-            persist(sessionId, ring);
+            // B5-1: only high-frequency `message_update` appends defer the persist;
+            // every other kind (message_end / tool_call / error / turn signals …)
+            // still persists synchronously. Because persistNow writes the FULL
+            // in-memory ring, one flush also lands any earlier pending updates in
+            // order — no two-phase flush is needed.
+            if (partial.kind === "message_update") {
+                const atMs = partial.at ? Date.parse(partial.at) : Date.now();
+                if (!Number.isNaN(atMs)) {
+                    persistDebounced(sessionId, ring, atMs);
+                }
+                else {
+                    persistNow(sessionId, ring);
+                }
+            }
+            else {
+                persistNow(sessionId, ring);
+            }
             const subs = subscribers.get(sessionId);
             if (subs) {
                 for (const fn of subs) {
@@ -1017,7 +1085,7 @@ export function createChatEventStore(options) {
             const ring = ringFor(sessionId);
             const next = (turnCounts.get(sessionId) ?? 0) + 1;
             turnCounts.set(sessionId, next);
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return next;
         },
         latestTurnId(sessionId) {
@@ -1043,6 +1111,9 @@ export function createChatEventStore(options) {
             rings.delete(sessionId);
             turnCounts.delete(sessionId);
             subscribers.delete(sessionId);
+            // B5-1: drop any debounced (not yet written) updates with the ring itself —
+            // the file is being deleted, so flushing first would only resurrect it.
+            pendingPersists.delete(sessionId);
             const file = persistedPath(sessionId);
             if (file)
                 rmSync(file, { force: true });