@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

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

@@ -28,6 +28,20 @@ let mockUiConfig: { userTimezone?: string; detectedTimezone?: string } = {};
 
 // ── Module mocks (must precede imports of the module under test) ─────
 
+// The real AgentLoop resolves the per-conversation ContextWindowManager from
+// the compaction store keyed by conversationId. These orchestrator tests build
+// fake conversations whose manager is a canned stub, so register each stub in a
+// map the mocked store reads from.
+const fakeContextWindowManagers = new Map<string, unknown>();
+mock.module("../plugins/defaults/compaction/manager-store.js", () => ({
+  createContextWindowManager: () => undefined,
+  getContextWindowManager: (conversationId: string) =>
+    fakeContextWindowManagers.get(conversationId),
+  disposeContextWindowManager: (conversationId: string) => {
+    fakeContextWindowManagers.delete(conversationId);
+  },
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
@@ -100,35 +114,38 @@ mock.module("../context/token-estimator.js", () => ({
 let mockReducerStepFn:
   | ((msgs: Message[], cfg: unknown, state: unknown) => unknown)
   | null = null;
-mock.module("../daemon/context-overflow-reducer.js", () => ({
-  createInitialReducerState: () => ({
-    appliedTiers: [],
-    injectionMode: "full" as const,
-    exhausted: false,
+mock.module(
+  "../plugins/defaults/compaction/context-overflow-reducer.js",
+  () => ({
+    createInitialReducerState: () => ({
+      appliedTiers: [],
+      injectionMode: "full" as const,
+      exhausted: false,
+    }),
+    reduceContextOverflow: async (
+      msgs: Message[],
+      cfg: unknown,
+      state: unknown,
+    ) => {
+      if (mockReducerStepFn) return mockReducerStepFn(msgs, cfg, state);
+      return {
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: [
+            "forced_compaction",
+            "tool_result_truncation",
+            "media_stubbing",
+            "injection_downgrade",
+          ],
+          injectionMode: "full",
+          exhausted: true,
+        },
+        estimatedTokens: 1000,
+      };
+    },
   }),
-  reduceContextOverflow: async (
-    msgs: Message[],
-    cfg: unknown,
-    state: unknown,
-  ) => {
-    if (mockReducerStepFn) return mockReducerStepFn(msgs, cfg, state);
-    return {
-      messages: msgs,
-      tier: "forced_compaction",
-      state: {
-        appliedTiers: [
-          "forced_compaction",
-          "tool_result_truncation",
-          "media_stubbing",
-          "injection_downgrade",
-        ],
-        injectionMode: "full",
-        exhausted: true,
-      },
-      estimatedTokens: 1000,
-    };
-  },
-}));
+);
 
 // Policy: default to fail_gracefully
 let mockOverflowAction: string = "fail_gracefully";
@@ -312,16 +329,14 @@ let mockInjectionBlocks: {
   pkbSystemReminder?: string;
   unifiedTurnContext?: string;
 } = {};
-const buildUnifiedTurnContextBlockMock = mock(
-  (options: Record<string, unknown>) =>
-    `<turn_context>\ncurrent_time: ${String(options.timestamp)}\n</turn_context>`,
-);
-const applyRuntimeInjectionsMock = mock(
-  async (msgs: Message[], _options?: unknown) => ({
-    messages: msgs,
-    blocks: { ...mockInjectionBlocks },
-  }),
-);
+const defaultApplyRuntimeInjectionsImpl = async (
+  msgs: Message[],
+  _options?: unknown,
+) => ({
+  messages: msgs,
+  blocks: { ...mockInjectionBlocks },
+});
+const applyRuntimeInjectionsMock = mock(defaultApplyRuntimeInjectionsImpl);
 let mockSlackChronologicalContext: {
   renderedMessages: Array<{
     message: Message;
@@ -358,7 +373,6 @@ const getSlackCompactionWatermarkForPrefixMock = mock(
 );
 mock.module("../daemon/conversation-runtime-assembly.js", () => ({
   applyRuntimeInjections: applyRuntimeInjectionsMock,
-  buildUnifiedTurnContextBlock: buildUnifiedTurnContextBlockMock,
   stripInjectionsForCompaction: (msgs: Message[]) => msgs,
   isSlackChannelConversation: () => false,
   getSlackCompactionWatermarkForPrefix:
@@ -523,22 +537,11 @@ mock.module("../memory/llm-request-log-store.js", () => ({
   setAgentLoopExitReasonOnLatestLog: setAgentLoopExitReasonOnLatestLogMock,
 }));
 
-let mockHasProactiveArtifactCompleted = true;
-let mockTryClaimProactiveArtifactTrigger = false;
-const runProactiveArtifactJobMock = mock(
-  async (_params: Record<string, unknown>) => {},
-);
-mock.module("../proactive-artifact/index.js", () => ({
-  hasProactiveArtifactCompleted: () => mockHasProactiveArtifactCompleted,
-  tryClaimProactiveArtifactTrigger: () => mockTryClaimProactiveArtifactTrigger,
-  runProactiveArtifactJob: runProactiveArtifactJobMock,
-}));
-
 // ── Imports (after mocks) ────────────────────────────────────────────
 
 import { AgentLoop } from "../agent/loop.js";
+import type { Conversation } from "../daemon/conversation.js";
 import {
-  type AgentLoopConversationContext,
   applyCompactionResult,
   runAgentLoopImpl,
 } from "../daemon/conversation-agent-loop.js";
@@ -552,13 +555,13 @@ import {
 // ── Test helpers ─────────────────────────────────────────────────────
 
 function makeCtx(
-  overrides?: Partial<AgentLoopConversationContext> & {
+  overrides?: Partial<Conversation> & {
     providerResponses?: ScriptedResponse[];
     loopProvider?: Provider;
     loopTools?: ToolDefinition[];
     toolExecutor?: LoopToolExecutor;
   },
-): AgentLoopConversationContext {
+): Conversation {
   const {
     providerResponses,
     loopProvider,
@@ -589,13 +592,15 @@ function makeCtx(
       providerResponses ?? [textResponse("response")],
       loopProviderName,
     ).provider;
-  const agentLoop = new AgentLoop(provider, "system prompt", {
+  const agentLoop = new AgentLoop({
+    provider: provider,
+    systemPrompt: "system prompt",
     conversationId,
     tools: loopTools ?? [],
     toolExecutor,
   });
 
-  return {
+  const ctx = {
     conversationId: "test-conv",
     messages: [
       { role: "user", content: [{ type: "text", text: "Hello" }] },
@@ -616,15 +621,24 @@ function makeCtx(
         usage: { inputTokens: 0, outputTokens: 0 },
         stopReason: "end_turn",
       }),
-    } as unknown as AgentLoopConversationContext["provider"],
+    } as unknown as Conversation["provider"],
     systemPrompt: "system prompt",
 
     contextWindowManager: {
+      updateConfig: () => {},
       shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
       maybeCompact: async () => ({ compacted: false }),
-    } as unknown as AgentLoopConversationContext["contextWindowManager"],
-    contextCompactedMessageCount: 0,
-    contextCompactedAt: null,
+    } as unknown as Conversation["contextWindowManager"],
+    conversationType: mockConversationRow?.conversationType ?? undefined,
+    source: mockConversationRow?.source ?? undefined,
+    contextSummary: mockConversationRow?.contextSummary ?? null,
+    contextCompactedMessageCount:
+      mockConversationRow?.contextCompactedMessageCount ?? 0,
+    contextCompactedAt: mockConversationRow?.contextCompactedAt ?? null,
+    slackContextCompactionWatermarkTs:
+      mockConversationRow?.slackContextCompactionWatermarkTs ?? null,
+    lastNotifiedInferenceProfile:
+      mockConversationRow?.lastNotifiedInferenceProfile ?? null,
 
     memoryPolicy: { scopeId: "default", includeDefaultFallback: true },
 
@@ -636,8 +650,6 @@ function makeCtx(
     currentTurnSurfaces: [],
 
     workingDir: "/tmp",
-    workspaceTopLevelContext: null,
-    workspaceTopLevelDirty: false,
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
@@ -647,15 +659,15 @@ function makeCtx(
     preactivatedSkillIds: undefined,
     skillProjectionState: new Map(),
     skillProjectionCache:
-      new Map() as unknown as AgentLoopConversationContext["skillProjectionCache"],
+      new Map() as unknown as Conversation["skillProjectionCache"],
 
     traceEmitter: {
       emit: () => {},
-    } as unknown as AgentLoopConversationContext["traceEmitter"],
+    } as unknown as Conversation["traceEmitter"],
     profiler: {
       startRequest: () => {},
       emitSummary: () => {},
-    } as unknown as AgentLoopConversationContext["profiler"],
+    } as unknown as Conversation["profiler"],
     usageStats: {
       totalInputTokens: 0,
       totalOutputTokens: 0,
@@ -668,13 +680,12 @@ function makeCtx(
     lastAttachmentWarnings: [],
 
     hasNoClient: false,
-    prompter: {} as unknown as AgentLoopConversationContext["prompter"],
-    queue: {} as unknown as AgentLoopConversationContext["queue"],
+    prompter: {} as unknown as Conversation["prompter"],
+    queue: {} as unknown as Conversation["queue"],
 
     getWorkspaceGitService: () => ({ ensureInitialized: async () => {} }),
     commitTurnChanges: async () => {},
 
-    refreshWorkspaceTopLevelContextIfNeeded: () => {},
     markWorkspaceTopLevelDirty: () => {},
     emitActivityState: () => {},
     getQueueDepth: () => 0,
@@ -701,10 +712,34 @@ function makeCtx(
       }),
       retrackCachedNodes: () => {},
       recordPkbQueryVectors: () => {},
-    } as unknown as AgentLoopConversationContext["graphMemory"],
+    } as unknown as Conversation["graphMemory"],
 
     ...ctxOverrides,
-  } as AgentLoopConversationContext;
+  } as unknown as Conversation;
+  fakeContextWindowManagers.set(conversationId, ctx.contextWindowManager);
+  return ctx;
+}
+
+type CompactionResult = Parameters<typeof applyCompactionResult>[1];
+
+function makeCompactionResult(
+  overrides?: Partial<CompactionResult>,
+): CompactionResult {
+  return {
+    messages: [{ role: "user", content: [{ type: "text", text: "summary" }] }],
+    compactedPersistedMessages: 4,
+    previousEstimatedInputTokens: 12000,
+    estimatedInputTokens: 3000,
+    maxInputTokens: 100000,
+    thresholdTokens: 80000,
+    compactedMessages: 4,
+    summaryCalls: 1,
+    summaryInputTokens: 100,
+    summaryOutputTokens: 20,
+    summaryModel: "mock-model",
+    summaryText: "summary",
+    ...overrides,
+  };
 }
 
 // ── Tests ────────────────────────────────────────────────────────────
@@ -738,13 +773,12 @@ beforeEach(() => {
     title: null,
   };
   mockMessageById = null;
-  mockHasProactiveArtifactCompleted = true;
-  mockTryClaimProactiveArtifactTrigger = false;
-  runProactiveArtifactJobMock.mockClear();
   setConversationHistoryStrippedAtMock.mockClear();
   setConversationHistoryStrippedAtMock.mockImplementation(() => {});
   applyRuntimeInjectionsMock.mockClear();
-  buildUnifiedTurnContextBlockMock.mockClear();
+  applyRuntimeInjectionsMock.mockImplementation(
+    defaultApplyRuntimeInjectionsImpl,
+  );
   resolveTurnTimezoneContextMock.mockClear();
   formatTurnTimestampMock.mockClear();
   mockSlackChronologicalContext = null;
@@ -757,11 +791,10 @@ beforeEach(() => {
   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
-  // install (`reduceContextOverflow`, `syncMessageToDisk`, etc.) instead of
-  // hitting the bare terminals.
+  // The compaction pipeline runs through the plugin registry; reset and
+  // re-register every default so it dispatches to middleware backed by the
+  // mocked collaborators these tests install (`syncMessageToDisk`, etc.)
+  // instead of hitting the bare terminal.
   resetPluginRegistryAndRegisterDefaults();
 });
 
@@ -785,7 +818,7 @@ describe("session-agent-loop", () => {
       });
     });
 
-    test("passes resolved canonical timezones into unified turn context", async () => {
+    test("freezes the client timezone snapshot on the conversation, not the options bag", async () => {
       mockUiConfig = {
         userTimezone: "US/Eastern",
         detectedTimezone: "US/Central",
@@ -802,17 +835,25 @@ describe("session-agent-loop", () => {
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
 
-      expect(formatTurnTimestampMock).toHaveBeenCalledWith({
-        timeZone: "America/New_York",
-      });
-      expect(buildUnifiedTurnContextBlockMock).toHaveBeenCalled();
-      const turnContextOptions =
-        buildUnifiedTurnContextBlockMock.mock.calls[0]?.[0];
-      expect(turnContextOptions).toMatchObject({
-        configuredUserTimezone: "America/New_York",
+      // The turn-start client timezone and the long-absence gap are frozen on
+      // the conversation as `currentTurnTemporalSnapshot`; the live
+      // `clientTimezone` would otherwise be clobbered mid-turn. `current_time`
+      // is not frozen — it is computed fresh at each injection inside
+      // `applyRuntimeInjections`.
+      expect(ctx.currentTurnTemporalSnapshot).toEqual({
         clientTimezone: "America/Los_Angeles",
-        detectedTimezone: "America/Chicago",
-      });
+        timeSinceLastMessage: null,
+      });
+      // Neither the timezones nor the long-absence gap are threaded through the
+      // options bag — `applyRuntimeInjections` sources the client timezone and
+      // gap from the snapshot and the config timezones from config
+      // (`ui.userTimezone`, `ui.detectedTimezone`).
+      const injectionOptions = applyRuntimeInjectionsMock.mock.calls[0]?.[1];
+      expect(injectionOptions).not.toHaveProperty("timestamp");
+      expect(injectionOptions).not.toHaveProperty("clientTimezone");
+      expect(injectionOptions).not.toHaveProperty("configuredUserTimezone");
+      expect(injectionOptions).not.toHaveProperty("detectedTimezone");
+      expect(injectionOptions).not.toHaveProperty("timeSinceLastMessage");
     });
   });
 
@@ -826,61 +867,24 @@ describe("session-agent-loop", () => {
     });
   });
 
-  describe("proactive artifact trigger", () => {
-    test("does not start proactive artifact jobs after foreground user turns", async () => {
-      mockConversationRow = {
-        ...mockConversationRow,
-        id: "test-conv",
-        conversationType: "standard",
-      };
-      mockMessageById = {
-        id: "user-msg-1",
-        conversationId: "test-conv",
-        createdAt: 1000,
-      };
-      mockHasProactiveArtifactCompleted = false;
-      mockTryClaimProactiveArtifactTrigger = true;
-
-      // A two-call agent turn: the model invokes `app_create`, then wraps up
-      // with a final text reply.
-      const ctx = makeCtx({
-        conversationId: "test-conv",
-        providerResponses: [
-          {
-            content: [
-              { type: "text", text: "I'll build that app." },
-              {
-                type: "tool_use",
-                id: "tool-1",
-                name: "app_create",
-                input: { name: "Flow" },
-              },
-            ],
-            model: "mock-model",
-            usage: { inputTokens: 10, outputTokens: 5 },
-            stopReason: "tool_use",
-          },
-          textResponse("Done."),
-        ],
-        toolExecutor: async () => ({ content: "{}", isError: false }),
-      });
-      await runAgentLoopImpl(
-        ctx,
-        "build a kanban app",
-        "user-msg-1",
-        () => {},
-        {
-          isUserMessage: true,
-        },
-      );
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      expect(runProactiveArtifactJobMock).toHaveBeenCalledTimes(0);
-    });
-  });
-
   describe("disk pressure injection context", () => {
-    test("passes cleanup context into runtime injections for cleanup-mode turns", async () => {
+    // The loop sets `ctx.diskPressureCleanupModeActive` for the duration of the
+    // turn (the disk-pressure-warning injector reads it via the per-conversation
+    // registry) and resets it in the turn-end cleanup path. Snapshot the flag at
+    // each `applyRuntimeInjections` call so assertions observe its value while
+    // injection runs, not the post-turn reset.
+    function captureCleanupFlagDuringInjection(ctx: {
+      diskPressureCleanupModeActive?: boolean;
+    }): () => Array<boolean | undefined> {
+      const observed: Array<boolean | undefined> = [];
+      applyRuntimeInjectionsMock.mockImplementation(async (msgs: Message[]) => {
+        observed.push(ctx.diskPressureCleanupModeActive);
+        return { messages: msgs, blocks: { ...mockInjectionBlocks } };
+      });
+      return () => observed;
+    }
+
+    test("sets the cleanup-mode flag on the conversation for cleanup-mode turns", async () => {
       mockDiskPressureDecision = {
         action: "allow-cleanup-mode",
         reason: "guardian",
@@ -901,8 +905,9 @@ describe("session-agent-loop", () => {
         trustContext: {
           sourceChannel: "telegram",
           trustClass: "guardian",
-        } as AgentLoopConversationContext["trustContext"],
+        } as Conversation["trustContext"],
       });
+      const cleanupFlagDuringInjection = captureCleanupFlagDuringInjection(ctx);
 
       await runAgentLoopImpl(ctx, "free up space", "msg-1", () => {});
 
@@ -921,21 +926,16 @@ describe("session-agent-loop", () => {
           },
         }),
       );
-      const firstInjectionOptions = applyRuntimeInjectionsMock.mock
-        .calls[0]![1] as {
-        diskPressureContext?: { cleanupModeActive: boolean } | null;
-      };
-      expect(firstInjectionOptions.diskPressureContext).toEqual({
-        cleanupModeActive: true,
-      });
+      expect(cleanupFlagDuringInjection()).toEqual([true]);
     });
 
-    test("passes cleanup context into runtime injections for local-owner turns", async () => {
+    test("sets the cleanup-mode flag on the conversation for local-owner turns", async () => {
       mockDiskPressureDecision = {
         action: "allow-cleanup-mode",
         reason: "local-owner",
       };
       const ctx = makeCtx();
+      const cleanupFlagDuringInjection = captureCleanupFlagDuringInjection(ctx);
 
       await runAgentLoopImpl(ctx, "free up space", "msg-1", () => {});
 
@@ -947,16 +947,10 @@ describe("session-agent-loop", () => {
           trustContext: null,
         }),
       );
-      const firstInjectionOptions = applyRuntimeInjectionsMock.mock
-        .calls[0]![1] as {
-        diskPressureContext?: { cleanupModeActive: boolean } | null;
-      };
-      expect(firstInjectionOptions.diskPressureContext).toEqual({
-        cleanupModeActive: true,
-      });
+      expect(cleanupFlagDuringInjection()).toEqual([true]);
     });
 
-    test("keeps cleanup context on overflow recovery reinjection", async () => {
+    test("keeps the cleanup-mode flag set across overflow recovery reinjection", async () => {
       mockDiskPressureDecision = {
         action: "allow-cleanup-mode",
         reason: "guardian",
@@ -976,20 +970,16 @@ describe("session-agent-loop", () => {
         trustContext: {
           sourceChannel: "telegram",
           trustClass: "guardian",
-        } as AgentLoopConversationContext["trustContext"],
+        } as Conversation["trustContext"],
       });
+      const cleanupFlagDuringInjection = captureCleanupFlagDuringInjection(ctx);
 
       await runAgentLoopImpl(ctx, "free up space", "msg-1", () => {});
 
       expect(applyRuntimeInjectionsMock.mock.calls.length).toBeGreaterThan(1);
-      for (const call of applyRuntimeInjectionsMock.mock.calls) {
-        const options = call[1] as {
-          diskPressureContext?: { cleanupModeActive: boolean } | null;
-        };
-        expect(options.diskPressureContext).toEqual({
-          cleanupModeActive: true,
-        });
-      }
+      const flags = cleanupFlagDuringInjection();
+      expect(flags.length).toBeGreaterThan(1);
+      expect(flags.every((flag) => flag === true)).toBe(true);
     });
 
     test("blocks policy-denied turns before runtime injection or model execution", async () => {
@@ -1008,7 +998,7 @@ describe("session-agent-loop", () => {
           emit: (...args: unknown[]) => {
             traceEvents.push(args);
           },
-        } as unknown as AgentLoopConversationContext["traceEmitter"],
+        } as unknown as Conversation["traceEmitter"],
       });
       const runSpy = spyOn(ctx.agentLoop, "run");
 
@@ -1169,7 +1159,7 @@ describe("session-agent-loop", () => {
             usage: { inputTokens: 0, outputTokens: 0 },
             stopReason: "end_turn",
           }),
-        } as unknown as AgentLoopConversationContext["provider"],
+        } as unknown as Conversation["provider"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1218,7 +1208,7 @@ describe("session-agent-loop", () => {
             usage: { inputTokens: 0, outputTokens: 0 },
             stopReason: "end_turn",
           }),
-        } as unknown as AgentLoopConversationContext["provider"],
+        } as unknown as Conversation["provider"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
@@ -1284,7 +1274,7 @@ describe("session-agent-loop", () => {
             usage: { inputTokens: 0, outputTokens: 0 },
             stopReason: "end_turn",
           }),
-        } as unknown as AgentLoopConversationContext["provider"],
+        } as unknown as Conversation["provider"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1335,7 +1325,7 @@ describe("session-agent-loop", () => {
             usage: { inputTokens: 0, outputTokens: 0 },
             stopReason: "end_turn",
           }),
-        } as unknown as AgentLoopConversationContext["provider"],
+        } as unknown as Conversation["provider"],
         traceEmitter: {
           emit: (
             event: string,
@@ -1346,7 +1336,7 @@ describe("session-agent-loop", () => {
               traceEvents.push({ label, attrs: payload.attributes ?? {} });
             }
           },
-        } as unknown as AgentLoopConversationContext["traceEmitter"],
+        } as unknown as Conversation["traceEmitter"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
@@ -1393,7 +1383,7 @@ describe("session-agent-loop", () => {
             usage: { inputTokens: 0, outputTokens: 0 },
             stopReason: "end_turn",
           }),
-        } as unknown as AgentLoopConversationContext["provider"],
+        } as unknown as Conversation["provider"],
         traceEmitter: {
           emit: (
             event: string,
@@ -1404,7 +1394,7 @@ describe("session-agent-loop", () => {
               traceEvents.push({ label, attrs: payload.attributes ?? {} });
             }
           },
-        } as unknown as AgentLoopConversationContext["traceEmitter"],
+        } as unknown as Conversation["traceEmitter"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
@@ -1460,7 +1450,7 @@ describe("session-agent-loop", () => {
             usage: { inputTokens: 0, outputTokens: 0 },
             stopReason: "end_turn",
           }),
-        } as unknown as AgentLoopConversationContext["provider"],
+        } as unknown as Conversation["provider"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1521,9 +1511,21 @@ describe("session-agent-loop", () => {
         },
       });
 
-      // After the orchestrator's preflight compaction runs, the loop completes
-      // the turn normally.
-      const ctx = makeCtx({ providerResponses: [textResponse("recovered")] });
+      // The provider rejects the first call as too large; the convergence
+      // reducer compacts and the rerun completes the turn, forwarding the
+      // compaction's cache-aware usage to recordUsage.
+      const { provider } = createMockProvider([
+        new Error("context_length_exceeded"),
+        textResponse("recovered"),
+      ]);
+      const ctx = makeCtx({
+        loopProvider: provider,
+        contextWindowManager: {
+          updateConfig: () => {},
+          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+          maybeCompact: async () => ({ compacted: false }),
+        } as unknown as Conversation["contextWindowManager"],
+      });
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
       const compactorCall = recordUsageMock.mock.calls.find(
@@ -1605,9 +1607,10 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({
         loopProvider: provider,
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1626,6 +1629,7 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({
         providerResponses: [new Error("context_length_exceeded")],
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           // Compaction succeeds but context is still too large
           maybeCompact: async () => ({
@@ -1645,7 +1649,7 @@ describe("session-agent-loop", () => {
             summaryOutputTokens: 200,
             summaryModel: "mock-model",
           }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1685,9 +1689,10 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({
         loopProvider: provider,
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1705,27 +1710,31 @@ describe("session-agent-loop", () => {
     test("non-interactive auto-compress continues without approval prompt", async () => {
       const events: ServerMessage[] = [];
 
-      // Reducer exhausts all tiers
-      mockReducerStepFn = (msgs: Message[]) => ({
-        messages: msgs,
-        tier: "injection_downgrade",
-        state: {
-          appliedTiers: [
-            "forced_compaction",
-            "tool_result_truncation",
-            "media_stubbing",
-            "injection_downgrade",
-          ],
-          injectionMode: "minimal",
-          exhausted: true,
-        },
-        estimatedTokens: 120000,
-      });
+      // The ladder applies a middle tier first, then escalates to its terminal
+      // auto-compress-latest-turn rung (permitted by the overflow policy) and
+      // reports exhaustion — mirroring the reducer owning every rung.
+      let reducerCalls = 0;
+      mockReducerStepFn = (msgs: Message[]) => {
+        reducerCalls++;
+        const terminal = reducerCalls >= 2;
+        return {
+          messages: msgs,
+          tier: terminal ? "auto_compress_latest_turn" : "forced_compaction",
+          state: {
+            appliedTiers: terminal
+              ? ["forced_compaction", "auto_compress_latest_turn"]
+              : ["forced_compaction"],
+            injectionMode: "full",
+            exhausted: terminal,
+          },
+          estimatedTokens: 120000,
+        };
+      };
 
       mockOverflowAction = "auto_compress_latest_turn";
 
       // The provider rejects the first two calls with context-too-large errors,
-      // then succeeds after the emergency auto-compress runs.
+      // then succeeds after the terminal auto-compress rung runs.
       const ctx = makeCtx({
         providerResponses: [
           new Error("context_length_exceeded"),
@@ -1734,6 +1743,7 @@ describe("session-agent-loop", () => {
         ],
         hasNoClient: true,
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({
             compacted: true,
@@ -1752,7 +1762,7 @@ describe("session-agent-loop", () => {
             summaryOutputTokens: 100,
             summaryModel: "mock-model",
           }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1779,24 +1789,26 @@ describe("session-agent-loop", () => {
       // attribute the silent stall.
       const events: ServerMessage[] = [];
 
-      // Reducer exhausts all 4 tiers on first call so the convergence
-      // loop runs exactly one iteration before falling through to
-      // the auto_compress_latest_turn branch.
-      mockReducerStepFn = (msgs: Message[]) => ({
-        messages: msgs,
-        tier: "injection_downgrade",
-        state: {
-          appliedTiers: [
-            "forced_compaction",
-            "tool_result_truncation",
-            "media_stubbing",
-            "injection_downgrade",
-          ],
-          injectionMode: "minimal",
-          exhausted: true,
-        },
-        estimatedTokens: 120_000,
-      });
+      // The ladder applies a middle tier, then runs its terminal
+      // auto-compress-latest-turn rung and reports exhaustion. Its rerun is the
+      // one that still yields at the mid-loop budget checkpoint.
+      let reducerCalls = 0;
+      mockReducerStepFn = (msgs: Message[]) => {
+        reducerCalls++;
+        const terminal = reducerCalls >= 2;
+        return {
+          messages: msgs,
+          tier: terminal ? "auto_compress_latest_turn" : "forced_compaction",
+          state: {
+            appliedTiers: terminal
+              ? ["forced_compaction", "auto_compress_latest_turn"]
+              : ["forced_compaction"],
+            injectionMode: "full",
+            exhausted: terminal,
+          },
+          estimatedTokens: 120_000,
+        };
+      };
 
       mockOverflowAction = "auto_compress_latest_turn";
 
@@ -1834,6 +1846,7 @@ describe("session-agent-loop", () => {
         toolExecutor: async () => ({ content: "data", isError: false }),
         hasNoClient: true,
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({
             compacted: true,
@@ -1852,7 +1865,7 @@ describe("session-agent-loop", () => {
             summaryOutputTokens: 100,
             summaryModel: "mock-model",
           }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1919,57 +1932,18 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({
         providerResponses: [new Error("context_length_exceeded")],
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
-      });
-
-      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
-
-      // maxAttempts is 3 — reducer should be called at most 3 times
-      expect(reducerCalls).toBeLessThanOrEqual(3);
-    });
-
-    test("preflight budget evaluation invokes reducer before provider call", async () => {
-      const events: ServerMessage[] = [];
-      let reducerCalls = 0;
-
-      // Set token estimate above budget (100000 * 0.95 = 95000)
-      mockEstimateTokens = 96000;
-
-      mockReducerStepFn = (msgs: Message[]) => {
-        reducerCalls++;
-        return {
-          messages: msgs,
-          tier: "forced_compaction",
-          state: {
-            appliedTiers: ["forced_compaction"],
-            injectionMode: "full",
-            exhausted: true,
-          },
-          estimatedTokens: 50000,
-        };
-      };
-
-      // After the preflight reducer brings the estimate under budget, the loop
-      // completes the turn in a single provider call.
-      const { provider, calls } = createMockProvider([textResponse("ok")]);
-      const ctx = makeCtx({
-        loopProvider: provider,
-        contextWindowManager: {
-          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-          maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      // Reducer should have been called during preflight
-      expect(reducerCalls).toBeGreaterThanOrEqual(1);
-      // Agent loop should still succeed in a single provider call
-      expect(calls.length).toBe(1);
-      const complete = events.find((e) => e.type === "message_complete");
-      expect(complete).toBeDefined();
+      // A misbehaving reducer that never reports exhaustion is bounded by the
+      // driver's safety backstop: at most the middle-tier budget plus the
+      // emergency and terminal rungs (maxAttempts + 2 = 5).
+      expect(reducerCalls).toBeLessThanOrEqual(5);
     });
   });
 
@@ -2024,7 +1998,7 @@ describe("session-agent-loop", () => {
         ],
         toolExecutor: async () => ({ content: "file content", isError: false }),
         canHandoffAtCheckpoint: () => true,
-      } as unknown as Partial<AgentLoopConversationContext>);
+      } as unknown as Partial<Conversation>);
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
@@ -2055,7 +2029,7 @@ describe("session-agent-loop", () => {
         ],
         toolExecutor: async () => ({ content: "content", isError: false }),
         canHandoffAtCheckpoint: () => false,
-      } as unknown as Partial<AgentLoopConversationContext>);
+      } as unknown as Partial<Conversation>);
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
@@ -2206,7 +2180,7 @@ describe("session-agent-loop", () => {
         drainQueue: (reason: string) => {
           drainReason = reason;
         },
-      } as unknown as Partial<AgentLoopConversationContext>);
+      } as unknown as Partial<Conversation>);
 
       // WHEN the orchestrator runs the turn to completion
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
@@ -2648,9 +2622,10 @@ describe("session-agent-loop", () => {
           textResponse("retry succeeded"),
         ],
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
 
@@ -3112,7 +3087,7 @@ describe("session-agent-loop", () => {
   });
 
   describe("Slack compaction watermarks", () => {
-    test("start-of-turn Slack compaction derives and persists watermark from rendered context", async () => {
+    test("first-call compaction runs in the loop and drops the Slack watermark", async () => {
       const renderedSlackMessages: Message[] = [
         {
           role: "user",
@@ -3140,9 +3115,12 @@ describe("session-agent-loop", () => {
         })),
         compactableStartIndex: 0,
       };
-      const shouldCompactInputs: Message[][] = [];
       const maybeCompactInputs: Message[][] = [];
 
+      // Sits above the loop's first-call gate threshold (~80.75k), so the
+      // loop's first-call gate owns the turn-start compaction.
+      mockEstimateTokens = 90_000;
+
       const ctx = makeCtx({
         channelCapabilities: {
           channel: "slack",
@@ -3154,18 +3132,19 @@ describe("session-agent-loop", () => {
         trustContext: {
           sourceChannel: "slack",
           trustClass: "guardian",
-        } as AgentLoopConversationContext["trustContext"],
+        } as Conversation["trustContext"],
         getTurnChannelContext: () => ({
           userMessageChannel: "slack" as const,
           assistantMessageChannel: "slack" as const,
         }),
         contextWindowManager: {
-          shouldCompact: (messages: Message[]) => {
-            shouldCompactInputs.push(messages);
-            return { needed: true, estimatedTokens: 95_000 };
-          },
+          updateConfig: () => {},
+          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async (messages: Message[]) => {
             maybeCompactInputs.push(messages);
+            // Drop back under budget so the post-compaction provider call
+            // proceeds.
+            mockEstimateTokens = 1000;
             return {
               compacted: true,
               messages: [
@@ -3173,10 +3152,10 @@ describe("session-agent-loop", () => {
                   role: "user",
                   content: [{ type: "text", text: "summary" }],
                 },
-                messages[2]!,
+                messages[messages.length - 1]!,
               ],
               compactedPersistedMessages: 2,
-              previousEstimatedInputTokens: 95_000,
+              previousEstimatedInputTokens: 90_000,
               estimatedInputTokens: 5_000,
               maxInputTokens: 100_000,
               thresholdTokens: 80_000,
@@ -3189,292 +3168,24 @@ describe("session-agent-loop", () => {
               summaryFailed: false,
             };
           },
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
-      });
-
-      await runAgentLoopImpl(ctx, "next reply", "user-msg-start", () => {});
-
-      expect(shouldCompactInputs[0]).toBe(renderedSlackMessages);
-      expect(maybeCompactInputs[0]).toBe(renderedSlackMessages);
-      expect(getSlackCompactionWatermarkForPrefixMock).toHaveBeenCalledWith(
-        mockSlackChronologicalContext,
-        2,
-      );
-      expect(updateConversationSlackContextWatermarkMock).toHaveBeenCalledWith(
-        "test-conv",
-        "1700000020.000000",
-        expect.any(Number),
-      );
-      const firstInjectionOptions = applyRuntimeInjectionsMock.mock
-        .calls[0]![1] as {
-        slackChronologicalMessages?: Message[] | null;
-      };
-      expect(firstInjectionOptions.slackChronologicalMessages).toBeNull();
-    });
-
-    test("overflow reducer Slack compaction persists watermark from rendered context", async () => {
-      const renderedSlackMessages: Message[] = [
-        {
-          role: "user",
-          content: [{ type: "text", text: "first rendered Slack row" }],
-        },
-        {
-          role: "user",
-          content: [{ type: "text", text: "second rendered Slack row" }],
-        },
-        {
-          role: "user",
-          content: [{ type: "text", text: "retained Slack row" }],
-        },
-      ];
-      mockSlackChronologicalContext = {
-        messages: renderedSlackMessages,
-        renderedMessages: renderedSlackMessages.map((message, index) => ({
-          message,
-          sourceChannelTs: [
-            "1700000010.000000",
-            "1700000020.000000",
-            "1700000030.000000",
-          ][index]!,
-          tagLineProvenance: "none",
-        })),
-        compactableStartIndex: 0,
-      };
-      mockEstimateTokens = 120_000;
-      mockReducerStepFn = (_msgs: Message[]) => ({
-        messages: [
-          {
-            role: "user",
-            content: [{ type: "text", text: "summary" }],
-          },
-          renderedSlackMessages[2]!,
-        ],
-        tier: "forced_compaction",
-        state: {
-          appliedTiers: ["forced_compaction"],
-          injectionMode: "full",
-          exhausted: false,
-        },
-        estimatedTokens: 5_000,
-        compactionResult: {
-          compacted: true,
-          messages: [
-            {
-              role: "user",
-              content: [{ type: "text", text: "summary" }],
-            },
-            renderedSlackMessages[2]!,
-          ],
-          compactedPersistedMessages: 2,
-          previousEstimatedInputTokens: 120_000,
-          estimatedInputTokens: 5_000,
-          maxInputTokens: 100_000,
-          thresholdTokens: 80_000,
-          compactedMessages: 2,
-          summaryCalls: 1,
-          summaryInputTokens: 100,
-          summaryOutputTokens: 20,
-          summaryModel: "mock-model",
-          summaryText: "summary",
-          summaryFailed: false,
-        },
-      });
-
-      const ctx = makeCtx({
-        channelCapabilities: {
-          channel: "slack",
-          dashboardCapable: false,
-          supportsDynamicUi: false,
-          supportsVoiceInput: false,
-          chatType: "channel",
-        },
-        trustContext: {
-          sourceChannel: "slack",
-          trustClass: "guardian",
-        } as AgentLoopConversationContext["trustContext"],
-        getTurnChannelContext: () => ({
-          userMessageChannel: "slack" as const,
-          assistantMessageChannel: "slack" as const,
-        }),
-        contextWindowManager: {
-          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-          maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
-      await runAgentLoopImpl(ctx, "next reply", "user-msg-overflow", () => {});
-
-      expect(getSlackCompactionWatermarkForPrefixMock).toHaveBeenCalledWith(
-        mockSlackChronologicalContext,
-        2,
-      );
-      expect(updateConversationSlackContextWatermarkMock).toHaveBeenCalledWith(
-        "test-conv",
-        "1700000020.000000",
-        expect.any(Number),
+      await runAgentLoopImpl(
+        ctx,
+        "next reply",
+        "user-msg-first-call",
+        () => {},
       );
-      const reinjectionOptions = applyRuntimeInjectionsMock.mock.calls.find(
-        (call) => {
-          const options = call[1] as {
-            slackChronologicalMessages?: Message[] | null;
-          };
-          return options.slackChronologicalMessages === null;
-        },
-      )?.[1] as { slackChronologicalMessages?: Message[] | null } | undefined;
-      expect(reinjectionOptions?.slackChronologicalMessages).toBeNull();
-    });
-
-    test("same-turn Slack compaction updates watermark from projected provenance", async () => {
-      const renderedSlackMessages: Message[] = [
-        {
-          role: "user",
-          content: [{ type: "text", text: "first rendered Slack row" }],
-        },
-        {
-          role: "user",
-          content: [{ type: "text", text: "second rendered Slack row" }],
-        },
-        {
-          role: "user",
-          content: [{ type: "text", text: "third rendered Slack row" }],
-        },
-        {
-          role: "user",
-          content: [{ type: "text", text: "retained Slack row" }],
-        },
-      ];
-      mockSlackChronologicalContext = {
-        messages: renderedSlackMessages,
-        renderedMessages: renderedSlackMessages.map((message, index) => ({
-          message,
-          sourceChannelTs: [
-            "1700000010.000000",
-            "1700000020.000000",
-            "1700000030.000000",
-            "1700000040.000000",
-          ][index]!,
-          tagLineProvenance: "none",
-        })),
-        compactableStartIndex: 0,
-      };
-
-      const firstSummaryMessage: Message = {
-        role: "user",
-        content: [{ type: "text", text: "first summary" }],
-      };
-      const firstCompactedMessages: Message[] = [
-        firstSummaryMessage,
-        renderedSlackMessages[2]!,
-        renderedSlackMessages[3]!,
-      ];
-      const secondSummaryMessage: Message = {
-        role: "user",
-        content: [{ type: "text", text: "second summary" }],
-      };
-      const secondCompactedMessages: Message[] = [
-        secondSummaryMessage,
-        renderedSlackMessages[3]!,
-      ];
-      const reducerInputs: Message[][] = [];
-      mockEstimateTokens = 120_000;
-      mockReducerStepFn = (msgs: Message[]) => {
-        reducerInputs.push(msgs);
-        mockEstimateTokens = 1000;
-        return {
-          messages: secondCompactedMessages,
-          tier: "forced_compaction",
-          state: {
-            appliedTiers: ["forced_compaction"],
-            injectionMode: "full",
-            exhausted: false,
-          },
-          estimatedTokens: 5_000,
-          compactionResult: {
-            compacted: true,
-            messages: secondCompactedMessages,
-            compactedPersistedMessages: 1,
-            previousEstimatedInputTokens: 120_000,
-            estimatedInputTokens: 5_000,
-            maxInputTokens: 100_000,
-            thresholdTokens: 80_000,
-            compactedMessages: 1,
-            summaryCalls: 1,
-            summaryInputTokens: 100,
-            summaryOutputTokens: 20,
-            summaryModel: "mock-model",
-            summaryText: "second summary",
-            summaryFailed: false,
-          },
-        };
-      };
-
-      const ctx = makeCtx({
-        channelCapabilities: {
-          channel: "slack",
-          dashboardCapable: false,
-          supportsDynamicUi: false,
-          supportsVoiceInput: false,
-          chatType: "channel",
-        },
-        trustContext: {
-          sourceChannel: "slack",
-          trustClass: "guardian",
-        } as AgentLoopConversationContext["trustContext"],
-        getTurnChannelContext: () => ({
-          userMessageChannel: "slack" as const,
-          assistantMessageChannel: "slack" as const,
-        }),
-        contextWindowManager: {
-          shouldCompact: () => ({ needed: true, estimatedTokens: 120_000 }),
-          maybeCompact: async (messages: Message[]) => {
-            expect(messages).toBe(renderedSlackMessages);
-            return {
-              compacted: true,
-              messages: firstCompactedMessages,
-              compactedPersistedMessages: 2,
-              previousEstimatedInputTokens: 120_000,
-              estimatedInputTokens: 60_000,
-              maxInputTokens: 100_000,
-              thresholdTokens: 80_000,
-              compactedMessages: 2,
-              summaryCalls: 1,
-              summaryInputTokens: 100,
-              summaryOutputTokens: 20,
-              summaryModel: "mock-model",
-              summaryText: "first summary",
-              summaryFailed: false,
-            };
-          },
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
-      });
-
-      await runAgentLoopImpl(ctx, "next reply", "user-msg-repeat", () => {});
 
-      expect(reducerInputs[0]).toBe(firstCompactedMessages);
-      expect(getSlackCompactionWatermarkForPrefixMock.mock.calls).toEqual([
-        [mockSlackChronologicalContext, 2],
-        [
-          {
-            renderedMessages: [
-              {
-                message: firstSummaryMessage,
-                sourceChannelTs: null,
-                tagLineProvenance: "none",
-              },
-              mockSlackChronologicalContext!.renderedMessages[2],
-              mockSlackChronologicalContext!.renderedMessages[3],
-            ],
-            messages: firstCompactedMessages,
-            compactableStartIndex: 1,
-          },
-          1,
-        ],
-      ]);
-      expect(updateConversationSlackContextWatermarkMock.mock.calls).toEqual([
-        ["test-conv", "1700000020.000000", expect.any(Number)],
-        ["test-conv", "1700000030.000000", expect.any(Number)],
-      ]);
-      expect(loadSlackChronologicalContextMock).toHaveBeenCalledTimes(1);
+      // The loop compacts its own stripped working history, never the loaded
+      // Slack transcript array, so provenance cannot be projected and the
+      // watermark is left untouched — matching mid-loop compaction.
+      expect(maybeCompactInputs.length).toBeGreaterThan(0);
+      expect(maybeCompactInputs[0]).not.toBe(renderedSlackMessages);
+      expect(
+        updateConversationSlackContextWatermarkMock,
+      ).not.toHaveBeenCalled();
     });
 
     test("mid-loop Slack compaction does not persist watermark from mismatched loaded context", async () => {
@@ -3542,32 +3253,16 @@ describe("session-agent-loop", () => {
         trustContext: {
           sourceChannel: "slack",
           trustClass: "guardian",
-        } as AgentLoopConversationContext["trustContext"],
+        } as Conversation["trustContext"],
         getTurnChannelContext: () => ({
           userMessageChannel: "slack" as const,
           assistantMessageChannel: "slack" as const,
         }),
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async (messages: Message[]) => {
             maybeCompactInputs.push(messages);
-            if (messages === renderedSlackMessages) {
-              return {
-                compacted: false,
-                messages,
-                compactedPersistedMessages: 0,
-                previousEstimatedInputTokens: 1000,
-                estimatedInputTokens: 1000,
-                maxInputTokens: 100_000,
-                thresholdTokens: 80_000,
-                compactedMessages: 0,
-                summaryCalls: 0,
-                summaryInputTokens: 0,
-                summaryOutputTokens: 0,
-                summaryModel: "",
-                summaryText: "",
-              };
-            }
             // The mid-loop gate compacted its in-loop basis; drop the estimate
             // back under budget so the post-compaction provider call proceeds.
             mockEstimateTokens = 1000;
@@ -3593,15 +3288,16 @@ describe("session-agent-loop", () => {
               summaryFailed: false,
             };
           },
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "next reply", "user-msg-mid-loop", () => {});
 
-      expect(maybeCompactInputs[0]).toBe(renderedSlackMessages);
       // The mid-loop gate compacts the loop's own in-loop history, never the
-      // loaded Slack rows — the mismatch this test guards against.
-      expect(maybeCompactInputs[1]).not.toBe(renderedSlackMessages);
+      // loaded Slack rows — the mismatch this test guards against. No
+      // start-of-turn compaction runs, so this is the turn's only compaction.
+      expect(maybeCompactInputs).toHaveLength(1);
+      expect(maybeCompactInputs[0]).not.toBe(renderedSlackMessages);
       expect(getSlackCompactionWatermarkForPrefixMock).toHaveBeenCalledWith(
         null,
         2,
@@ -3611,7 +3307,7 @@ describe("session-agent-loop", () => {
       ).not.toHaveBeenCalled();
     });
 
-    test("next inbound Slack turn injects the watermark-filtered chronological context", async () => {
+    test("next inbound Slack turn loads chronological context using the persisted watermark", async () => {
       mockConversationRow = {
         ...mockConversationRow,
         contextSummary: "## Summary\n- compacted Slack context",
@@ -3671,7 +3367,7 @@ describe("session-agent-loop", () => {
         trustContext: {
           sourceChannel: "slack",
           trustClass: "guardian",
-        } as AgentLoopConversationContext["trustContext"],
+        } as Conversation["trustContext"],
         getTurnChannelContext: () => ({
           userMessageChannel: "slack" as const,
           assistantMessageChannel: "slack" as const,
@@ -3690,26 +3386,9 @@ describe("session-agent-loop", () => {
           trustClass: "guardian",
         }),
       );
-      const firstInjectionOptions = applyRuntimeInjectionsMock.mock
-        .calls[0]![1] as {
-        slackChronologicalMessages?: Message[] | null;
-      };
-      expect(firstInjectionOptions.slackChronologicalMessages).toBe(
-        mockSlackChronologicalContext.messages,
-      );
-      const rendered = firstInjectionOptions
-        .slackChronologicalMessages!.flatMap((message) => message.content)
-        .filter((block): block is { type: "text"; text: string } => {
-          return block.type === "text";
-        })
-        .map((block) => block.text)
-        .join("\n");
-      expect(rendered).toContain("compacted Slack context");
-      expect(rendered).toContain("after watermark reply");
-      expect(rendered).not.toContain("before watermark");
-    });
-
-    test("subsequent Slack turn keeps long-thread compaction summary and filtered tail", async () => {
+    });
+
+    test("subsequent Slack turn loads chronological context using the persisted long-thread watermark", async () => {
       mockConversationRow = {
         ...mockConversationRow,
         contextSummary: "## Summary\n- compacted long Slack thread",
@@ -3779,7 +3458,7 @@ describe("session-agent-loop", () => {
         trustContext: {
           sourceChannel: "slack",
           trustClass: "guardian",
-        } as AgentLoopConversationContext["trustContext"],
+        } as Conversation["trustContext"],
         getTurnChannelContext: () => ({
           userMessageChannel: "slack" as const,
           assistantMessageChannel: "slack" as const,
@@ -3802,21 +3481,6 @@ describe("session-agent-loop", () => {
           slackContextCompactionWatermarkTs: "1700000080.000000",
         }),
       );
-      const firstInjectionOptions = applyRuntimeInjectionsMock.mock
-        .calls[0]![1] as {
-        slackChronologicalMessages?: Message[] | null;
-      };
-      const rendered = firstInjectionOptions
-        .slackChronologicalMessages!.flatMap((message) => message.content)
-        .filter((block): block is { type: "text"; text: string } => {
-          return block.type === "text";
-        })
-        .map((block) => block.text)
-        .join("\n");
-      expect(rendered).toContain("compacted long Slack thread");
-      expect(rendered).toContain("reply after compaction");
-      expect(rendered).not.toContain("pre-compaction");
-      expect(rendered).not.toContain("original root");
     });
 
     test("applyCompactionResult records Slack timestamp watermark when provided", async () => {
@@ -3858,6 +3522,59 @@ describe("session-agent-loop", () => {
         true,
       );
     });
+
+    test("applyCompactionResult advances the persisted count from the trusted in-context boundary", async () => {
+      // Trusted views slice past the already-compacted prefix, so a further
+      // compaction advances the persisted count from the mirrored DB boundary.
+
+      // GIVEN a trusted (guardian) conversation that has already compacted 5
+      // persisted messages, so its in-context history starts past that prefix
+      const ctx = makeCtx({
+        contextCompactedMessageCount: 5,
+        trustContext: {
+          trustClass: "guardian",
+        } as Conversation["trustContext"],
+      });
+
+      // WHEN a turn compacts 4 more in-context messages
+      await applyCompactionResult(
+        ctx,
+        makeCompactionResult({ compactedPersistedMessages: 4 }),
+        () => {},
+        "req-1",
+      );
+
+      // THEN the persisted count advances from the prior boundary (5 + 4)
+      expect(ctx.contextCompactedMessageCount).toBe(9);
+    });
+
+    test("applyCompactionResult resets the persisted count to the unsliced boundary for untrusted views", async () => {
+      // Untrusted views render history unsliced (boundary 0), so a compaction
+      // must record only the new summary's prefix instead of adding to the raw
+      // mirror — otherwise future loads slice past unsummarized rows.
+
+      // GIVEN an untrusted view of a conversation whose raw DB count mirrors a
+      // 5-message compacted prefix — but untrusted views render that history
+      // unsliced (boundary 0), so the compactor operates on the full list
+      const ctx = makeCtx({
+        contextCompactedMessageCount: 5,
+        trustContext: {
+          trustClass: "unknown",
+        } as Conversation["trustContext"],
+      });
+
+      // WHEN that turn compacts 4 in-context messages
+      await applyCompactionResult(
+        ctx,
+        makeCompactionResult({ compactedPersistedMessages: 4 }),
+        () => {},
+        "req-1",
+      );
+
+      // THEN the persisted count reflects only the new summary's prefix (0 + 4)
+      // rather than double-counting the raw mirror (which would yield 9)
+      expect(ctx.contextCompactedMessageCount).toBe(4);
+    });
   });
 
   describe("compaction-strip marker persistence", () => {
@@ -3894,9 +3611,10 @@ describe("session-agent-loop", () => {
         ],
         toolExecutor: async () => ({ content: "ok", isError: false }),
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       // WHEN the orchestrator runs the turn to completion
@@ -3943,9 +3661,10 @@ describe("session-agent-loop", () => {
         ],
         toolExecutor: async () => ({ content: "ok", isError: false }),
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       // Must not throw — the strip-site marker write is wrapped in try/catch.