@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/conversation-agent-loop.test.ts

@@ -1,13 +1,25 @@
 import { createRequire } from "node:module";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
 import type {
   AgentEvent,
-  CheckpointDecision,
-  CheckpointInfo,
+  AgentLoopRunOptions,
+  AgentLoopRunResult,
+  MidLoopCompaction,
 } from "../agent/loop.js";
+import type { ContextWindowResult } from "../context/window-manager.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import { defaultCompactionTerminal } from "../plugins/defaults/compaction/terminal.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
+import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
+import { getMiddlewaresFor } from "../plugins/registry.js";
+import type {
+  CompactionArgs,
+  CompactionResult,
+  TurnContext,
+} from "../plugins/types.js";
+import { PluginTimeoutError } from "../plugins/types.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
 const conversationCrudRealSnapshot = {
@@ -176,6 +188,12 @@ let mockConversationRow: Record<string, unknown> = {
   title: null,
 };
 let mockMessageById: Record<string, unknown> | null = null;
+const deleteMessageByIdMock = mock(() => ({
+  segmentIds: [],
+  deletedSummaryIds: [],
+}));
+const reserveMessageMock = mock(async () => ({ id: "msg-reserve" }));
+const updateMessageContentMock = mock(() => {});
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationUsage: () => {},
@@ -189,7 +207,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   }),
   getConversationOriginInterface: () => null,
   addMessage: () => ({ id: "mock-msg-id" }),
-  deleteMessageById: () => {},
+  deleteMessageById: deleteMessageByIdMock,
   updateConversationContextWindow: () => {},
   updateConversationSlackContextWatermark:
     updateConversationSlackContextWatermarkMock,
@@ -197,6 +215,36 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginChannel: () => null,
   getMessageById: () => mockMessageById,
   getLastUserTimestampBefore: () => 0,
+  reserveMessage: reserveMessageMock,
+  updateMessageContent: updateMessageContentMock,
+  // The real schema is a Zod object; tests don't exercise validation,
+  // so a passthrough is sufficient — the production code at
+  // `handleMessageComplete` only branches on `success` and reads two
+  // fields off `data`. `safeParse` of an empty object satisfies the
+  // schema (every field is optional).
+  messageMetadataSchema: {
+    safeParse: (input: unknown) => ({ success: true, data: input ?? {} }),
+  },
+}));
+
+// The B3 indexing-restoration path imports `indexMessageNow` from
+// `../memory/indexer.js` and `projectAssistantMessage` from
+// `../memory/conversation-attention-store.js`; without these stubs the
+// real modules would try to open a SQLite DB and read a real config.
+const indexMessageNowMock = mock(async () => ({
+  indexedSegments: 0,
+  enqueuedJobs: 0,
+}));
+const projectAssistantMessageMock = mock(() => false);
+const publishSyncInvalidationMock = mock(async () => {});
+mock.module("../memory/indexer.js", () => ({
+  indexMessageNow: indexMessageNowMock,
+}));
+mock.module("../memory/conversation-attention-store.js", () => ({
+  projectAssistantMessage: projectAssistantMessageMock,
+}));
+mock.module("../runtime/sync/sync-publisher.js", () => ({
+  publishSyncInvalidation: publishSyncInvalidationMock,
 }));
 
 afterAll(() => {
@@ -371,7 +419,7 @@ mock.module("../daemon/date-context.js", () => ({
   resolveTurnTimezoneContext: resolveTurnTimezoneContextMock,
 }));
 
-mock.module("../daemon/history-repair.js", () => ({
+mock.module("../plugins/defaults/history-repair/terminal.js", () => ({
   repairHistory: (msgs: Message[]) => ({
     messages: msgs,
     stats: {
@@ -512,13 +560,149 @@ import {
 type AgentLoopRun = (
   messages: Message[],
   onEvent: (event: AgentEvent) => void | Promise<void>,
-  signal?: AbortSignal,
-  requestId?: string,
-  onCheckpoint?: (
-    checkpoint: CheckpointInfo,
-  ) => CheckpointDecision | Promise<CheckpointDecision>,
+  options?: AgentLoopRunOptions,
 ) => Promise<Message[]>;
 
+/**
+ * Faithful re-implementation of `AgentLoop.compact()` for the mock loop: run
+ * the compaction pipeline against the supplied turn context (which carries the
+ * test's `contextWindowManager`), invoke the orchestrator-supplied hooks, and
+ * return the continuation history — or `null` on timeout/exhaustion so the
+ * caller yields "budget".
+ */
+async function simulateInlineCompaction(
+  compaction: MidLoopCompaction,
+  history: Message[],
+  turnContext: TurnContext | undefined,
+  signal: AbortSignal | undefined,
+  onEvent: (event: AgentEvent) => void | Promise<void>,
+  compactionCircuit: CompactionCircuit,
+): Promise<Message[] | null> {
+  await onEvent({ type: "context_compacting" });
+  const { rawHistory, options } = compaction.prepare(history);
+  let result: CompactionResult;
+  try {
+    result = await runPipeline<CompactionArgs, CompactionResult>(
+      "compaction",
+      getMiddlewaresFor("compaction"),
+      (args) => defaultCompactionTerminal(args, turnContext as TurnContext),
+      { messages: rawHistory, signal, options },
+      turnContext as TurnContext,
+      DEFAULT_TIMEOUTS.compaction,
+    );
+  } catch (error) {
+    if (error instanceof PluginTimeoutError) {
+      await compactionCircuit.recordOutcome(
+        {
+          currentRequestId: turnContext?.requestId,
+          currentTurnTrustContext: turnContext?.trust,
+          turnCount: turnContext?.turnIndex ?? 0,
+        },
+        true,
+        onEvent,
+      );
+      return null;
+    }
+    throw error;
+  }
+  const compactResult = result as ContextWindowResult;
+  if (compactResult.summaryFailed !== undefined) {
+    await compactionCircuit.recordOutcome(
+      {
+        currentRequestId: turnContext?.requestId,
+        currentTurnTrustContext: turnContext?.trust,
+        turnCount: turnContext?.turnIndex ?? 0,
+      },
+      compactResult.summaryFailed,
+      onEvent,
+    );
+  }
+  if (compactResult.compacted) {
+    await compaction.applyResult(compactResult, rawHistory);
+  }
+  if (compactResult.exhausted ?? false) {
+    return null;
+  }
+  return compaction.reinject();
+}
+
+/**
+ * Adapt a `Message[]`-returning mock loop body into `run()`'s real result
+ * shape. Mirrors the production loop: the pause-reason carried back is
+ * whatever the most recent `onCheckpoint` call yielded with (null when it
+ * never yielded), so the orchestrator derives its yield bookkeeping the same
+ * way it does against the real loop.
+ */
+const asAgentLoopRun = (
+  fn: AgentLoopRun,
+  compactionCircuit: CompactionCircuit,
+): ((
+  messages: Message[],
+  onEvent: (event: AgentEvent) => void | Promise<void>,
+  options?: AgentLoopRunOptions,
+) => Promise<AgentLoopRunResult>) => {
+  return async (messages, onEvent, options) => {
+    let exitReason: AgentLoopRunResult["exitReason"] = null;
+    let wrapped = options;
+    if (options?.onCheckpoint) {
+      const inner = options.onCheckpoint;
+      wrapped = {
+        ...options,
+        onCheckpoint: async (info) => {
+          // Handoff is offered first, mirroring the loop's ordering.
+          const decision = await inner(info);
+          if (decision !== "continue") {
+            exitReason = decision;
+            return decision;
+          }
+          // The mid-loop budget gate and inline compaction both live inside
+          // `AgentLoop.run`. Replicate them here — same formula, stubbed
+          // estimator, and the loop's own `compact()` ceremony — so these
+          // orchestrator tests drive the real escalation path now that the
+          // orchestrator's `onCheckpoint` is handoff-only and compaction runs
+          // inline rather than via an orchestrator re-entry loop.
+          const contextWindow = options.resolveContextWindow?.();
+          if (contextWindow?.overflowRecovery.enabled) {
+            const { maxInputTokens, overflowRecovery } = contextWindow;
+            const safetyMargin =
+              info.history.length > 50
+                ? Math.max(overflowRecovery.safetyMarginRatio, 0.15)
+                : overflowRecovery.safetyMarginRatio;
+            const preflightBudget = Math.floor(
+              maxInputTokens * (1 - safetyMargin),
+            );
+            if (mockEstimateTokens > preflightBudget * 0.85) {
+              // Mirror `AgentLoop.compact()`: when a compaction path is
+              // supplied, run it in place and continue; on timeout or
+              // exhaustion it returns null, so the loop yields "budget".
+              const compacted = options.compaction
+                ? await simulateInlineCompaction(
+                    options.compaction,
+                    info.history,
+                    options.turnContext,
+                    options.signal,
+                    onEvent,
+                    compactionCircuit,
+                  )
+                : null;
+              if (compacted) {
+                exitReason = null;
+                return "continue";
+              }
+              exitReason = "budget";
+              return "budget";
+            }
+          }
+          exitReason = null;
+          return "continue";
+        },
+      };
+    }
+    const history = await fn(messages, onEvent, wrapped);
+    return { history, exitReason };
+  };
+};
+
 function makeCtx(
   overrides?: Partial<AgentLoopConversationContext> & {
     agentLoopRun?: AgentLoopRun;
@@ -534,6 +718,8 @@ function makeCtx(
       },
     ]);
 
+  const compactionCircuit = new CompactionCircuit("test-conv");
+
   return {
     conversationId: "test-conv",
     messages: [
@@ -544,12 +730,13 @@ function makeCtx(
     currentRequestId: "test-req",
 
     agentLoop: {
-      run: agentLoopRun,
+      run: asAgentLoopRun(agentLoopRun, compactionCircuit),
       getToolTokenBudget: () => 0,
       getResolvedTools: () => [],
       // Tests here don't exercise calibration; returning undefined makes
       // the estimator use the per-provider aggregate key.
       getActiveModel: () => undefined,
+      compactionCircuit,
     } as unknown as AgentLoopConversationContext["agentLoop"],
     provider: {
       name: "mock-provider",
@@ -692,6 +879,13 @@ beforeEach(() => {
   mockSlackChronologicalContext = null;
   loadSlackChronologicalContextMock.mockClear();
   getSlackCompactionWatermarkForPrefixMock.mockClear();
+  deleteMessageByIdMock.mockClear();
+  reserveMessageMock.mockClear();
+  updateMessageContentMock.mockClear();
+  indexMessageNowMock.mockClear();
+  projectAssistantMessageMock.mockClear();
+  publishSyncInvalidationMock.mockClear();
+  mockMessageById = null;
   // Orchestrator pipelines (overflowReduce, persistence, …) run through the
   // plugin registry; reset and re-register every default so the pipelines
   // dispatch to middleware backed by the mocked collaborators these tests
@@ -762,7 +956,7 @@ describe("session-agent-loop", () => {
   });
 
   describe("proactive artifact trigger", () => {
-    test("suppresses proactive app build when the foreground turn used app tools", async () => {
+    test("does not start proactive artifact jobs after foreground user turns", async () => {
       mockConversationRow = {
         ...mockConversationRow,
         id: "test-conv",
@@ -776,13 +970,10 @@ describe("session-agent-loop", () => {
       mockHasProactiveArtifactCompleted = false;
       mockTryClaimProactiveArtifactTrigger = true;
 
-      const agentLoopRun: AgentLoopRun = async (
-        messages,
-        onEvent,
-        _signal,
-        _requestId,
-        onCheckpoint,
-      ) => {
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent, options) => {
+        // Prime the assistant row anchor for LLM call 1 — production code
+        // emits this from `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         await onEvent({
           type: "message_complete",
           message: {
@@ -802,12 +993,15 @@ describe("session-agent-loop", () => {
           content: "{}",
           isError: false,
         });
-        await onCheckpoint?.({
+        await options?.onCheckpoint?.({
           turnIndex: 0,
           toolCount: 1,
           hasToolUse: true,
           history: messages,
         });
+        // Prime the anchor again for LLM call 2 — multi-call agent turns
+        // reserve a fresh assistant row per LLM call.
+        await onEvent({ type: "llm_call_started" });
         await onEvent({
           type: "message_complete",
           message: {
@@ -839,11 +1033,7 @@ describe("session-agent-loop", () => {
       );
       await new Promise((resolve) => setTimeout(resolve, 0));
 
-      expect(runProactiveArtifactJobMock).toHaveBeenCalledTimes(1);
-      expect(runProactiveArtifactJobMock.mock.calls[0]?.[0]).toMatchObject({
-        conversationId: "test-conv",
-        suppressAppBuild: true,
-      });
+      expect(runProactiveArtifactJobMock).toHaveBeenCalledTimes(0);
     });
   });
 
@@ -981,7 +1171,10 @@ describe("session-agent-loop", () => {
           },
         } as unknown as AgentLoopConversationContext["traceEmitter"],
       });
-      ctx.agentLoop.run = agentLoopRun as AgentLoopRun;
+      ctx.agentLoop.run = asAgentLoopRun(
+        agentLoopRun,
+        ctx.agentLoop.compactionCircuit,
+      );
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
@@ -990,8 +1183,7 @@ describe("session-agent-loop", () => {
       expect(activityStates).toContainEqual([
         "idle",
         "error_terminal",
-        "global",
-        "test-req",
+        { anchor: "global", requestId: "test-req" },
       ]);
       expect(traceEvents[0]).toEqual([
         "request_error",
@@ -1053,8 +1245,7 @@ describe("session-agent-loop", () => {
       expect(activityStates).toContainEqual([
         "idle",
         "error_terminal",
-        "global",
-        "test-req",
+        { anchor: "global", requestId: "test-req" },
       ]);
     });
   });
@@ -1064,6 +1255,9 @@ describe("session-agent-loop", () => {
       const events: ServerMessage[] = [];
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         // Simulate tool_use + error during execution
         onEvent({
           type: "tool_use",
@@ -1113,6 +1307,9 @@ describe("session-agent-loop", () => {
       const events: ServerMessage[] = [];
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         onEvent({
           type: "message_complete",
           message: {
@@ -1173,6 +1370,9 @@ describe("session-agent-loop", () => {
       };
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         onEvent({
           type: "message_complete",
           message: {
@@ -1238,6 +1438,9 @@ describe("session-agent-loop", () => {
       };
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         onEvent({
           type: "message_complete",
           message: {
@@ -1320,6 +1523,9 @@ describe("session-agent-loop", () => {
       };
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         onEvent({
           type: "message_complete",
           message: {
@@ -1388,6 +1594,9 @@ describe("session-agent-loop", () => {
       }> = [];
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         onEvent({ type: "text_delta", text: "Hi." });
         onEvent({
           type: "message_complete",
@@ -1463,6 +1672,9 @@ describe("session-agent-loop", () => {
       }> = [];
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         // No text_delta — pure tool-call response
         onEvent({
           type: "message_complete",
@@ -1526,6 +1738,9 @@ describe("session-agent-loop", () => {
       const events: ServerMessage[] = [];
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         onEvent({
           type: "message_complete",
           message: {
@@ -1638,6 +1853,9 @@ describe("session-agent-loop", () => {
       });
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         onEvent({
           type: "message_complete",
           message: {
@@ -1728,6 +1946,11 @@ describe("session-agent-loop", () => {
       };
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`. Retry branches
+        // need this on every invocation: each agent-loop iteration reserves
+        // its own row.
+        await onEvent({ type: "llm_call_started" });
         callCount++;
         if (callCount === 1) {
           onEvent({
@@ -1855,6 +2078,11 @@ describe("session-agent-loop", () => {
       };
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`. Retry branches
+        // need this on every invocation: each agent-loop iteration reserves
+        // its own row.
+        await onEvent({ type: "llm_call_started" });
         callCount++;
         if (callCount === 1) {
           onEvent({
@@ -1940,6 +2168,11 @@ describe("session-agent-loop", () => {
       mockOverflowAction = "auto_compress_latest_turn";
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`. Retry branches
+        // need this on every invocation: each agent-loop iteration reserves
+        // its own row.
+        await onEvent({ type: "llm_call_started" });
         callCount++;
         if (callCount <= 2) {
           onEvent({
@@ -2059,13 +2292,7 @@ describe("session-agent-loop", () => {
       // call). 90k satisfies both so the path reaches call 3.
       mockEstimateTokens = 90_000;
 
-      const agentLoopRun: AgentLoopRun = async (
-        messages,
-        onEvent,
-        _signal,
-        _reqId,
-        onCheckpoint,
-      ) => {
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent, options) => {
         callCount++;
         if (callCount <= 2) {
           // Calls 1 (initial) and 2 (convergence rerun): error so
@@ -2089,8 +2316,8 @@ describe("session-agent-loop", () => {
         // flips `yieldedForBudget` to true, then return without
         // finishing — mirroring what AgentLoop.run does when its
         // checkpoint returns "yield".
-        if (onCheckpoint) {
-          await onCheckpoint({
+        if (options?.onCheckpoint) {
+          await options.onCheckpoint({
             turnIndex: 0,
             toolCount: 1,
             hasToolUse: true,
@@ -2237,6 +2464,9 @@ describe("session-agent-loop", () => {
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
         agentLoopCalls++;
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         onEvent({
           type: "message_complete",
           message: {
@@ -2285,6 +2515,11 @@ describe("session-agent-loop", () => {
       let callCount = 0;
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`. Retry branches
+        // need this on every invocation: each agent-loop iteration reserves
+        // its own row.
+        await onEvent({ type: "llm_call_started" });
         callCount++;
         if (callCount === 1) {
           onEvent({
@@ -2362,13 +2597,12 @@ describe("session-agent-loop", () => {
     test("yields at checkpoint when canHandoffAtCheckpoint returns true", async () => {
       const events: ServerMessage[] = [];
 
-      const agentLoopRun: AgentLoopRun = async (
-        messages,
-        onEvent,
-        _signal,
-        _reqId,
-        onCheckpoint,
-      ) => {
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent, options) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`. Retry branches
+        // need this on every invocation: each agent-loop iteration reserves
+        // its own row.
+        await onEvent({ type: "llm_call_started" });
         // Simulate tool use followed by checkpoint
         onEvent({ type: "tool_use", id: "tu-1", name: "file_read", input: {} });
         onEvent({
@@ -2391,14 +2625,14 @@ describe("session-agent-loop", () => {
           model: "test-model",
           providerDurationMs: 100,
         });
-        if (onCheckpoint) {
-          const decision = await onCheckpoint({
+        if (options?.onCheckpoint) {
+          const decision = await options.onCheckpoint({
             turnIndex: 0,
             toolCount: 1,
             hasToolUse: true,
             history: messages,
           });
-          if (decision === "yield") {
+          if (decision !== "continue") {
             return [
               ...messages,
               {
@@ -2435,13 +2669,12 @@ describe("session-agent-loop", () => {
     test("continues when canHandoffAtCheckpoint returns false", async () => {
       const events: ServerMessage[] = [];
 
-      const agentLoopRun: AgentLoopRun = async (
-        messages,
-        onEvent,
-        _signal,
-        _reqId,
-        onCheckpoint,
-      ) => {
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent, options) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`. Retry branches
+        // need this on every invocation: each agent-loop iteration reserves
+        // its own row.
+        await onEvent({ type: "llm_call_started" });
         onEvent({ type: "tool_use", id: "tu-1", name: "file_read", input: {} });
         onEvent({
           type: "tool_result",
@@ -2463,8 +2696,8 @@ describe("session-agent-loop", () => {
           model: "test-model",
           providerDurationMs: 100,
         });
-        if (onCheckpoint) {
-          await onCheckpoint({
+        if (options?.onCheckpoint) {
+          await options.onCheckpoint({
             turnIndex: 0,
             toolCount: 1,
             hasToolUse: true,
@@ -2504,6 +2737,9 @@ describe("session-agent-loop", () => {
       const abortController = new AbortController();
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         onEvent({
           type: "message_complete",
           message: {
@@ -2564,6 +2800,9 @@ describe("session-agent-loop", () => {
       resolveAssistantAttachmentsMock.mockClear();
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`.
+        await onEvent({ type: "llm_call_started" });
         onEvent({
           type: "message_complete",
           message: {
@@ -2603,6 +2842,9 @@ describe("session-agent-loop", () => {
     test("increments turnCount after successful run", async () => {
       const ctx = makeCtx({
         agentLoopRun: async (messages, onEvent) => {
+          // Prime the assistant row anchor — production code emits this from
+          // `AgentLoop.run` just before `provider.sendMessage`.
+          await onEvent({ type: "llm_call_started" });
           onEvent({
             type: "message_complete",
             message: {
@@ -2636,6 +2878,9 @@ describe("session-agent-loop", () => {
     test("clears processing state and abort controller", async () => {
       const ctx = makeCtx({
         agentLoopRun: async (messages, onEvent) => {
+          // Prime the assistant row anchor — production code emits this from
+          // `AgentLoop.run` just before `provider.sendMessage`.
+          await onEvent({ type: "llm_call_started" });
           onEvent({
             type: "message_complete",
             message: {
@@ -2699,8 +2944,13 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({
         agentLoopRun: async (
           messages: Message[],
-          onEvent: (event: AgentEvent) => void,
+          onEvent: (event: AgentEvent) => void | Promise<void>,
         ) => {
+          // Prime the assistant row anchor — production code emits this from
+          // `AgentLoop.run` just before `provider.sendMessage`. Must be
+          // awaited so the assistant row is reserved before message_complete
+          // tries to write into it.
+          await onEvent({ type: "llm_call_started" });
           onEvent({
             type: "message_complete",
             message: {
@@ -3044,6 +3294,674 @@ describe("session-agent-loop", () => {
     });
   });
 
+  describe("B3 pre-allocation: indexing + cleanup", () => {
+    test("handleMessageComplete indexes and projects the finalized assistant row", async () => {
+      // The pre-B3 path inserted assistant rows via `addMessage`, which ran
+      // the memory indexer and the conversation-attention projector as
+      // side-effects of the insert. B3 splits the write into
+      // `reserveMessage` + `updateMessageContent`, both of which are CRUD-only,
+      // so the indexing + projection calls had to be re-driven explicitly
+      // after `updateContent` succeeds. Codex P1 caught a regression where
+      // this path was missing entirely; this test pins it down.
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+      // Force attention projection to report a state change so we also
+      // observe the sync-invalidation publish path on the same turn.
+      projectAssistantMessageMock.mockImplementationOnce(() => true);
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        await onEvent({ type: "llm_call_started" });
+        // `message_complete` is awaited so `handleMessageComplete` (and its
+        // async indexer + projector chain) completes before the next event
+        // or before the loop returns. Without the await the projector's
+        // synchronous call still races against the test's assertion phase
+        // because the indexer's `await` yields microtasks.
+        await onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "indexed reply" }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 10,
+          outputTokens: 5,
+          model: "test",
+          providerDurationMs: 50,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [
+              { type: "text", text: "indexed reply" },
+            ] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      // Indexer fired with the reserved row's id + the finalized content.
+      expect(indexMessageNowMock).toHaveBeenCalledTimes(1);
+      const indexCallArgs = indexMessageNowMock.mock.calls[0] as unknown as [
+        {
+          messageId: string;
+          conversationId: string;
+          role: string;
+          content: string;
+          createdAt: number;
+          scopeId: string;
+        },
+        unknown,
+      ];
+      const indexCall = indexCallArgs[0];
+      expect(indexCall).toMatchObject({
+        messageId: "msg-reserve",
+        conversationId: "test-conv",
+        role: "assistant",
+        createdAt: 1234567,
+        scopeId: "default",
+      });
+      expect(indexCall.content).toContain("indexed reply");
+
+      // Attention projector fired with the same row coordinates.
+      expect(projectAssistantMessageMock).toHaveBeenCalledTimes(1);
+      const projectCall = projectAssistantMessageMock.mock
+        .calls[0] as unknown as [
+        { conversationId: string; messageId: string; messageAt: number },
+      ];
+      expect(projectCall[0]).toEqual({
+        conversationId: "test-conv",
+        messageId: "msg-reserve",
+        messageAt: 1234567,
+      });
+
+      // Projection reported a state change → sync invalidation fires with
+      // the conversation `:metadata` tag. The mock also receives a
+      // `:messages` invalidation from the orchestrator's
+      // `publishLoopMessagesChanged` post-loop emit, so we filter by tag
+      // rather than asserting a total call count.
+      const metadataPublishes = (
+        publishSyncInvalidationMock.mock.calls as unknown as Array<[string[]]>
+      ).filter((args) => args[0]?.includes("conversation:test-conv:metadata"));
+      expect(metadataPublishes).toHaveLength(1);
+    });
+
+    test("handleMessageComplete skips sync invalidation when attention state unchanged", async () => {
+      // Mirror of the previous test but with the default projector return
+      // (`false`). The projection still runs every turn, but the sync
+      // invalidation publish must be gated on attention-state movement to
+      // avoid flooding clients with no-op metadata refreshes.
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 999,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        await onEvent({ type: "llm_call_started" });
+        // See sibling test — `message_complete` must be awaited so the
+        // projector call lands before the assertion phase.
+        await onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "quiet" }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 1,
+          outputTokens: 1,
+          model: "test",
+          providerDurationMs: 1,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text", text: "quiet" }] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      expect(projectAssistantMessageMock).toHaveBeenCalledTimes(1);
+      // The mock will still receive a `:messages` invalidation from the
+      // orchestrator's `publishLoopMessagesChanged` — filter to the
+      // `:metadata` tag and assert it never landed.
+      const metadataPublishes = (
+        publishSyncInvalidationMock.mock.calls as unknown as Array<[string[]]>
+      ).filter((args) => args[0]?.includes("conversation:test-conv:metadata"));
+      expect(metadataPublishes).toHaveLength(0);
+    });
+
+    test("handleLlmCallStarted deletes a stranded reservation before reserving a new row", async () => {
+      // Simulates a retry path: the first LLM call reserves an assistant row
+      // but exits without `message_complete` (e.g. context-overflow rescue,
+      // ordering-error rescue, image-overflow rescue). The next
+      // `llm_call_started` must delete the stranded row so the transcript
+      // does not accumulate empty assistant bubbles.
+      reserveMessageMock
+        .mockImplementationOnce(async () => ({ id: "msg-strand-A" }))
+        .mockImplementationOnce(async () => ({ id: "msg-strand-B" }));
+      // Indexer/projector mocks default to no-op; no finalized row in this
+      // test, so `mockMessageById` stays null.
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // First LLM call: reserve msg-strand-A, never finalize.
+        await onEvent({ type: "llm_call_started" });
+        // Second LLM call: should delete msg-strand-A before reserving
+        // msg-strand-B.
+        await onEvent({ type: "llm_call_started" });
+        // Finalize the second one so the loop has a valid assistant message
+        // and exits cleanly.
+        onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "retry succeeded" }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 5,
+          outputTokens: 3,
+          model: "test",
+          providerDurationMs: 25,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [
+              { type: "text", text: "retry succeeded" },
+            ] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      // Exactly one delete fires — for msg-strand-A, before the second
+      // reserve. The second reservation is committed via `updateContent`
+      // (not deleted), and after the run completes
+      // `assistantRowAwaitingFinalization` is false, so no further delete
+      // is attempted on shutdown.
+      expect(deleteMessageByIdMock).toHaveBeenCalledTimes(1);
+      const strandDeleteCall = deleteMessageByIdMock.mock
+        .calls[0] as unknown as [string];
+      expect(strandDeleteCall[0]).toBe("msg-strand-A");
+      expect(reserveMessageMock).toHaveBeenCalledTimes(2);
+    });
+
+    test("provider-error branch deletes the orphaned reservation and repoints lastAssistantMessageId", async () => {
+      // Codex P2 regression: B3 reserves an empty assistant row at
+      // `llm_call_started`. When the call exits via the provider-error
+      // branch (no `message_complete`), the synthetic error message is
+      // inserted separately. Without cleanup the transcript would carry
+      // both the empty reserved row AND the error message, and
+      // `syncLastAssistantMessageToDisk` (which reads
+      // `state.lastAssistantMessageId`) would mis-target the deleted
+      // reservation id.
+      reserveMessageMock.mockImplementationOnce(async () => ({
+        id: "msg-orphaned-reservation",
+      }));
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // Reserve the orphan.
+        await onEvent({ type: "llm_call_started" });
+        // Provider rejects — writes the llm_request_log row and arms
+        // `state.providerErrorUserMessage` via `handleError`.
+        onEvent({
+          type: "provider_error",
+          error: new Error("upstream 500"),
+          rawRequest: { model: "gpt-4.1", messages: [] },
+          actualProvider: "openai",
+        });
+        onEvent({
+          type: "error",
+          error: new Error("upstream 500"),
+        });
+        // No assistant message in the result — the synthetic-error branch
+        // below the agent loop fires.
+        return messages;
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      // The orphan was deleted exactly once, before the synthetic error
+      // message landed.
+      expect(deleteMessageByIdMock).toHaveBeenCalledTimes(1);
+      const deleteCall = deleteMessageByIdMock.mock.calls[0] as unknown as [
+        string,
+      ];
+      expect(deleteCall[0]).toBe("msg-orphaned-reservation");
+
+      // Post-loop `syncLastAssistantMessageToDisk` targets the synthetic
+      // error row's id (`mock-msg-id` from the mocked `addMessage`), NOT
+      // the deleted reservation id. This is the externally-observable
+      // proof that `state.lastAssistantMessageId` was repointed.
+      expect(syncMessageToDiskMock).toHaveBeenCalled();
+      const syncCalls = syncMessageToDiskMock.mock.calls as unknown as Array<
+        [string, string, number]
+      >;
+      const lastSync = syncCalls[syncCalls.length - 1];
+      expect(lastSync?.[1]).toBe("mock-msg-id");
+      expect(lastSync?.[1]).not.toBe("msg-orphaned-reservation");
+    });
+  });
+
+  describe("partial persistence", () => {
+    // The legacy flow reserves an empty assistant row at `llm_call_started`
+    // (`content: "[]"`) and never touches it again until
+    // `handleMessageComplete` fires the single authoritative
+    // `updateContent`. Between those events the row is empty for the full
+    // duration of a turn — a browser refresh mid-turn sees nothing where
+    // the in-progress assistant reply should be.
+    //
+    // Partial persistence closes that durability gap with a debounced
+    // flush from `handleTextDelta` (250ms timer). `handleToolUse`
+    // intentionally does NOT flush — `AgentLoop.run` emits `tool_use`
+    // strictly AFTER `message_complete`, so any flush from that handler
+    // would land after the authoritative finalize and overwrite the
+    // finalized row. The indexer + projector still fire ONLY at
+    // `message_complete` — partial rows are never indexed.
+    //
+    // These tests pin down the wire-level contract by counting
+    // `updateMessageContent` calls and inspecting the JSON payload of the
+    // partial-flush writes. The indexing / sync-invalidation paths are
+    // covered by the pre-allocation block above.
+
+    test("debounced time gate flushes one partial write after PARTIAL_PERSIST_DEBOUNCE_MS", async () => {
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        await onEvent({ type: "llm_call_started" });
+        // Two small deltas — well under the 1024-char size gate — should
+        // schedule a single debounced flush.
+        onEvent({ type: "text_delta", text: "Hello, " });
+        onEvent({ type: "text_delta", text: "world." });
+        // Wait long enough for the 250ms debounce to fire.
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        await onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "Hello, world." }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 10,
+          outputTokens: 5,
+          model: "test",
+          providerDurationMs: 50,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [
+              { type: "text", text: "Hello, world." },
+            ] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      // Exactly two `updateContent` calls land:
+      //   1. the debounced partial flush after both deltas accumulated, and
+      //   2. the final authoritative flush in `handleMessageComplete`.
+      // Without the debounce gate this would be one-per-delta + one final
+      // (3). Without the partial flush at all it would be just 1.
+      expect(updateMessageContentMock).toHaveBeenCalledTimes(2);
+      const calls = updateMessageContentMock.mock.calls as unknown as Array<
+        [string, string]
+      >;
+      const partialFlush = calls[0];
+      expect(partialFlush?.[0]).toBe("msg-reserve");
+      const partialBlocks = JSON.parse(partialFlush?.[1] ?? "[]") as Array<{
+        type: string;
+        text?: string;
+      }>;
+      expect(partialBlocks).toEqual([{ type: "text", text: "Hello, world." }]);
+    });
+
+    test("handleToolUse does NOT trigger a partial flush of its own", async () => {
+      // `AgentLoop.run` emits `tool_use` strictly AFTER `message_complete`,
+      // so a flush from the tool_use handler would land after the
+      // authoritative final `updateContent` and overwrite the finalized
+      // row (Codex P1 / Vargas review feedback). The handler must be a
+      // no-op for the partial-persist accumulator.
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        await onEvent({ type: "llm_call_started" });
+        // No text delta — only a tool_use. If `handleToolUse` were
+        // flushing, this would land a partial write before
+        // `message_complete`.
+        onEvent({
+          type: "tool_use",
+          id: "tu-no-flush",
+          name: "file_read",
+          input: { path: "/foo" },
+        });
+        // Yield a microtask so any (incorrectly) fire-and-forget
+        // pipeline call has a chance to land before message_complete.
+        await new Promise((resolve) => setImmediate(resolve));
+        onEvent({
+          type: "tool_result",
+          toolUseId: "tu-no-flush",
+          content: "ok",
+          isError: false,
+        });
+        await onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [
+              {
+                type: "tool_use",
+                id: "tu-no-flush",
+                name: "file_read",
+                input: { path: "/foo" },
+              },
+            ],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 10,
+          outputTokens: 5,
+          model: "test",
+          providerDurationMs: 50,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [
+              {
+                type: "tool_use",
+                id: "tu-no-flush",
+                name: "file_read",
+                input: { path: "/foo" },
+              },
+            ] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      // Only the authoritative final flush from `handleMessageComplete`
+      // lands. A partial flush from `handleToolUse` would have made this
+      // 2; that's the regression this test guards against.
+      expect(updateMessageContentMock).toHaveBeenCalledTimes(1);
+    });
+
+    test("handleMessageComplete clears any pending debounce timer before the final flush", async () => {
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        await onEvent({ type: "llm_call_started" });
+        // Short delta — schedules a debounce timer but does NOT trip the
+        // size gate. message_complete then arrives immediately after,
+        // before the 250ms timer can fire.
+        onEvent({ type: "text_delta", text: "Quick reply." });
+        await onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "Quick reply." }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 10,
+          outputTokens: 5,
+          model: "test",
+          providerDurationMs: 50,
+        });
+        // Wait past the original debounce window to prove a late timer
+        // does NOT fire a stray partial flush.
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text", text: "Quick reply." }] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      // Only the final flush from `handleMessageComplete` lands. The
+      // debounced partial would have fired around T+250ms; the timer-clear
+      // at the top of `handleMessageComplete` cancels it.
+      expect(updateMessageContentMock).toHaveBeenCalledTimes(1);
+    });
+
+    test("partial flushes never trigger the indexer or attention projector", async () => {
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        await onEvent({ type: "llm_call_started" });
+        onEvent({ type: "text_delta", text: "hello world" });
+        // Wait past the 250ms debounce so the partial flush definitely
+        // lands BEFORE message_complete fires.
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        // Snapshot the indexer/projector call counts AFTER the partial
+        // flush has run but BEFORE message_complete. They must be zero.
+        const indexerCallsBeforeComplete =
+          indexMessageNowMock.mock.calls.length;
+        const projectorCallsBeforeComplete =
+          projectAssistantMessageMock.mock.calls.length;
+        // Stash on a side channel the assertion phase can read.
+        (
+          ctx as unknown as { __partialSnapshot?: [number, number] }
+        ).__partialSnapshot = [
+          indexerCallsBeforeComplete,
+          projectorCallsBeforeComplete,
+        ];
+        await onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "hello world" }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 10,
+          outputTokens: 5,
+          model: "test",
+          providerDurationMs: 50,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text", text: "hello world" }] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      const snapshot = (
+        ctx as unknown as { __partialSnapshot?: [number, number] }
+      ).__partialSnapshot;
+      expect(snapshot).toBeDefined();
+      // Indexer + projector were both ZERO during the mid-turn partial
+      // flush — they only fire from `handleMessageComplete` after the
+      // authoritative `updateContent`.
+      expect(snapshot![0]).toBe(0);
+      expect(snapshot![1]).toBe(0);
+      // After the loop completes the indexer + projector each ran exactly
+      // once (the pre-allocation finalize path).
+      expect(indexMessageNowMock).toHaveBeenCalledTimes(1);
+      expect(projectAssistantMessageMock).toHaveBeenCalledTimes(1);
+    });
+
+    test("partial flushes redact secrets from text blocks before writing", async () => {
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+      // A GitHub PAT-shaped token mid-stream — the redaction discipline
+      // mirrors `handleMessageComplete`'s final flush so a refresh mid-turn
+      // never sees plaintext credentials in the persisted row.
+      const ghToken = "ghp_" + "a".repeat(36);
+      const payload = "Here's the key: " + ghToken + " enjoy.";
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        await onEvent({ type: "llm_call_started" });
+        onEvent({ type: "text_delta", text: payload });
+        // Wait past the 250ms debounce so the partial flush lands.
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        await onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: payload }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 10,
+          outputTokens: 5,
+          model: "test",
+          providerDurationMs: 50,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text", text: payload }] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      expect(updateMessageContentMock).toHaveBeenCalledTimes(2);
+      const partialPayload = (
+        updateMessageContentMock.mock.calls[0] as unknown as [string, string]
+      )[1];
+      // The raw PAT must never appear in the persisted snapshot. The
+      // redaction substitute is implementation-defined; the contract here
+      // is "the literal token string is gone".
+      expect(partialPayload).not.toContain(ghToken);
+    });
+
+    test("provider-error cleanup deletes a row that has accumulated partial content", async () => {
+      // Regression check: the pre-allocation orphan-cleanup branch
+      // already deletes the reserved row when the LLM call exits via
+      // `provider_error`. Partial-persist writes content to that row
+      // mid-turn; the cleanup must still fire and the row (along with
+      // its partial content) must still be deleted before the synthetic
+      // error message lands.
+      reserveMessageMock.mockImplementationOnce(async () => ({
+        id: "msg-orphan-with-partial",
+      }));
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        await onEvent({ type: "llm_call_started" });
+        // A debounced delta lands a partial flush BEFORE the provider
+        // error fires.
+        onEvent({ type: "text_delta", text: "hello world" });
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        onEvent({
+          type: "provider_error",
+          error: new Error("upstream 500"),
+          rawRequest: { model: "gpt-4.1", messages: [] },
+          actualProvider: "openai",
+        });
+        onEvent({
+          type: "error",
+          error: new Error("upstream 500"),
+        });
+        return messages;
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      // Partial flush fired exactly once (before the provider error).
+      // The orphan row was then deleted; the synthetic error message is
+      // inserted separately via `addMessage` (`mock-msg-id`) and never
+      // touched by `updateContent`.
+      const partialFlushes = (
+        updateMessageContentMock.mock.calls as unknown as Array<
+          [string, string]
+        >
+      ).filter(([id]) => id === "msg-orphan-with-partial");
+      expect(partialFlushes).toHaveLength(1);
+      expect(deleteMessageByIdMock).toHaveBeenCalledTimes(1);
+      const deleteCall = deleteMessageByIdMock.mock.calls[0] as unknown as [
+        string,
+      ];
+      expect(deleteCall[0]).toBe("msg-orphan-with-partial");
+    });
+  });
+
   describe("pkbSystemReminderBlock metadata persistence", () => {
     test("persists pkbSystemReminderBlock in full mode with PKB active", async () => {
       const reminder = "<system_reminder>\npkb content\n</system_reminder>";
@@ -3539,21 +4457,22 @@ describe("session-agent-loop", () => {
       const agentLoopRun: AgentLoopRun = async (
         messages,
         _onEvent,
-        _signal,
-        _reqId,
-        onCheckpoint,
+        options,
       ) => {
         runCount++;
         if (runCount === 1) {
+          // The loop reaches its mid-loop budget checkpoint with the raw
+          // persistent basis as its in-loop history; the wrapped onCheckpoint
+          // trips the gate and runs inline compaction over that basis.
           mockEstimateTokens = 90_000;
-          const decision = await onCheckpoint?.({
+          const decision = await options?.onCheckpoint?.({
             turnIndex: 0,
             toolCount: 1,
             hasToolUse: true,
-            history: messages,
+            history: rawMidLoopBasis,
           });
           mockEstimateTokens = 1000;
-          if (decision === "yield") {
+          if (decision !== "continue") {
             return rawMidLoopBasis;
           }
         }
@@ -3908,6 +4827,11 @@ describe("session-agent-loop", () => {
       let callCount = 0;
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
         callCount++;
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`. Retry branches
+        // need this on every invocation: each agent-loop iteration reserves
+        // its own row.
+        await onEvent({ type: "llm_call_started" });
         if (callCount === 1) {
           // Trigger convergence path: error + appended assistant message so
           // updatedHistory.length > preRunHistoryLength at the strip site.
@@ -3968,5 +4892,86 @@ describe("session-agent-loop", () => {
       );
       expect(stripCalls.length).toBeGreaterThanOrEqual(1);
     });
+
+    test("strip-site marker write is non-fatal when the helper throws", async () => {
+      setConversationHistoryStrippedAtMock.mockImplementation(() => {
+        throw new Error("db write failed");
+      });
+
+      mockReducerStepFn = (msgs: Message[]) => ({
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: ["forced_compaction"],
+          injectionMode: "full",
+          exhausted: false,
+        },
+        estimatedTokens: 5000,
+      });
+
+      let callCount = 0;
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        callCount++;
+        // Prime the assistant row anchor — production code emits this from
+        // `AgentLoop.run` just before `provider.sendMessage`. Retry branches
+        // need this on every invocation: each agent-loop iteration reserves
+        // its own row.
+        await onEvent({ type: "llm_call_started" });
+        if (callCount === 1) {
+          onEvent({
+            type: "error",
+            error: new Error("context_length_exceeded"),
+          });
+          onEvent({
+            type: "usage",
+            inputTokens: 100,
+            outputTokens: 0,
+            model: "test-model",
+            providerDurationMs: 50,
+          });
+          return [
+            ...messages,
+            {
+              role: "assistant" as const,
+              content: [{ type: "text", text: "partial" }] as ContentBlock[],
+            },
+          ];
+        }
+        onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "recovered" }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 50,
+          outputTokens: 25,
+          model: "test-model",
+          providerDurationMs: 100,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text", text: "recovered" }] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({
+        agentLoopRun,
+        contextWindowManager: {
+          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+          maybeCompact: async () => ({ compacted: false }),
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+      });
+
+      // Must not throw — the strip-site marker write is wrapped in try/catch.
+      await expect(
+        runAgentLoopImpl(ctx, "hello", "msg-1", () => {}),
+      ).resolves.toBeUndefined();
+    });
   });
 });