@vellumai/assistant 0.8.8-dev.202606081143.f600053 → 0.8.9-staging.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.8-dev.202606081143.f600053",
+  "version": "0.8.9-staging.1",
   "license": "MIT",
   "type": "module",
   "exports": {

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

@@ -100,7 +100,7 @@ mock.module("../config/loader.js", () => ({
 // Can be a number (constant), a no-arg function, or a function that
 // receives the messages array for dynamic behavior based on content.
 // Both the calibrated entry point (`estimatePromptTokens`, which backs the
-// preflight overflow gate and the convergence path) and the raw entry point
+// loop's budget gate and the convergence path) and the raw entry point
 // (`estimatePromptTokensRaw`, used by the pre-send calibration capture) are
 // stubbed so either call site can drive the test.
 let mockEstimateTokens: number | ((msgs?: Message[]) => number) = 1000;
@@ -113,7 +113,7 @@ mock.module("../context/token-estimator.js", () => ({
     typeof mockEstimateTokens === "function"
       ? mockEstimateTokens(msgs)
       : mockEstimateTokens,
-  // The preflight overflow gate calls this calibrated wrapper directly, so it
+  // The loop's budget gate calls this calibrated wrapper directly, so it
   // must honor `mockEstimateTokens` too — otherwise the real implementation
   // (which sums tool tokens onto the real calibrated estimate) ignores the
   // per-test value and the overflow scenarios below never trigger.
@@ -795,9 +795,9 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     const events: ServerMessage[] = [];
     let reducerCalled = false;
 
-    // GIVEN the estimator reports 185k — under the 190k preflight budget
-    // (200k * 0.95), so the turn proceeds to the provider rather than
-    // compacting up front.
+    // GIVEN the estimator reports 185k and the context manager's compaction
+    // is a no-op, so the first call proceeds to the provider without any
+    // up-front reduction.
     mockEstimateTokens = 185_000;
 
     // AND the post-run convergence reducer successfully compacts
@@ -1364,14 +1364,9 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
 
     // Budget = 200_000 * 0.95 = 190_000
     // Mid-loop threshold = 190_000 * 0.85 = 161_500
-    let estimateCallCount = 0;
-    mockEstimateTokens = () => {
-      estimateCallCount++;
-      // Preflight: below budget
-      if (estimateCallCount === 1) return 100_000;
-      // Every checkpoint call: above threshold — always triggers yield
-      return 170_000;
-    };
+    // Every estimate is above the threshold, so the first-call gate compacts
+    // before the first provider call and every checkpoint trips the yield.
+    mockEstimateTokens = 170_000;
 
     // The convergence reducer reduces tokens enough for the rerun to recover.
     let convergenceReducerCalled = false;
@@ -1485,16 +1480,11 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
 
     // Budget = 200_000 * 0.95 = 190_000
     // Mid-loop threshold = 190_000 * 0.85 = 161_500
-    let estimateCallCount = 0;
-    mockEstimateTokens = () => {
-      estimateCallCount++;
-      // Preflight: below budget.
-      if (estimateCallCount === 1) return 100_000;
-      // Every checkpoint estimate: above threshold — always trips the
-      // yield. Simulates a long turn where each tool call's result
-      // inflates the context past 85% even after a successful compaction.
-      return 170_000;
-    };
+    // Every estimate is above the threshold: the first-call gate compacts
+    // before the first provider call, and each subsequent checkpoint trips
+    // the yield even after a successful compaction (each tool result inflates
+    // the context back past 85%).
+    mockEstimateTokens = 170_000;
 
     // A single tool round reaches one checkpoint; the in-loop budget gate
     // trips there and compaction runs in place. The loop continues the run
@@ -1687,125 +1677,6 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     );
   });
 
-  // ── Test 8 ────────────────────────────────────────────────────────
-  // BUG: The preflight overflow reducer's budget check uses
-  // step.estimatedTokens (computed on bare ctx.messages) without
-  // accounting for tokens added by applyRuntimeInjections(). This
-  // causes the reducer to stop early when the bare estimate is under
-  // budget, even though post-injection tokens exceed it — leading to
-  // a wasted provider round-trip that gets rejected.
-  //
-  // After fix: the budget check re-estimates on runMessages (with
-  // injections) so the reducer continues to the next tier.
-  test("preflight reducer continues when post-injection tokens exceed budget", async () => {
-    const events: ServerMessage[] = [];
-
-    // Injections add an extra message, bumping the token count.
-    const injectionMessage: Message = {
-      role: "user" as const,
-      content: [
-        {
-          type: "text" as const,
-          text: "injected context " + "x".repeat(500),
-        },
-      ],
-    };
-    mockApplyRuntimeInjections = (msgs) => [...msgs, injectionMessage];
-
-    // Budget = 200_000 * 0.95 = 190_000
-    // The estimator returns different values based on whether the
-    // injection message is present:
-    //   - bare history (no injection msg) → 195_000 (triggers preflight)
-    //   - after tier 1 bare → 185_000 (under budget, would stop early without fix)
-    //   - after tier 1 with injection → 195_000 (still over budget)
-    //   - after tier 2 bare → 170_000
-    //   - after tier 2 with injection → 175_000 (under budget, reducer stops)
-    let reducerCallCount = 0;
-    mockEstimateTokens = (msgs?: Message[]) => {
-      const hasInjection = msgs?.some(
-        (m) =>
-          m.role === "user" &&
-          Array.isArray(m.content) &&
-          m.content.some(
-            (b: { type: string; text?: string }) =>
-              b.type === "text" &&
-              typeof b.text === "string" &&
-              b.text.startsWith("injected context"),
-          ),
-      );
-      if (reducerCallCount === 0) {
-        // Before any reduction: preflight check on runMessages (with injection)
-        return 195_000;
-      }
-      if (reducerCallCount === 1) {
-        // After tier 1
-        return hasInjection ? 195_000 : 185_000;
-      }
-      // After tier 2
-      return hasInjection ? 175_000 : 170_000;
-    };
-
-    mockReducerStepFn = (msgs: Message[]) => {
-      reducerCallCount++;
-      const tier =
-        reducerCallCount === 1 ? "forced_compaction" : "tool_result_truncation";
-      return {
-        messages: msgs,
-        tier,
-        state: {
-          appliedTiers:
-            reducerCallCount === 1
-              ? ["forced_compaction"]
-              : ["forced_compaction", "tool_result_truncation"],
-          injectionMode: "full" as const,
-          exhausted: reducerCallCount >= 2,
-        },
-        // Bare-history estimate (what the reducer sees on ctx.messages)
-        estimatedTokens: reducerCallCount === 1 ? 185_000 : 170_000,
-        compactionResult: {
-          compacted: true,
-          messages: msgs,
-          compactedPersistedMessages: 5,
-          summaryText: "Summary",
-          previousEstimatedInputTokens: 195_000,
-          estimatedInputTokens: reducerCallCount === 1 ? 185_000 : 170_000,
-          maxInputTokens: 200_000,
-          thresholdTokens: 160_000,
-          compactedMessages: 10,
-          summaryCalls: 1,
-          summaryInputTokens: 500,
-          summaryOutputTokens: 200,
-          summaryModel: "mock-model",
-        },
-      };
-    };
-
-    // The preflight overflow reducer runs in the orchestrator before the loop,
-    // so a single successful provider turn is enough to drive the path.
-    const ctx = makeCtx({
-      providerResponses: [textResponse("done")],
-      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));
-
-    // The reducer must be called twice — the first tier's bare estimate
-    // (185k) is under budget (190k), but post-injection tokens (195k)
-    // still exceed it. Without the fix, the reducer would stop after
-    // tier 1 and the provider call would likely fail.
-    expect(reducerCallCount).toBe(2);
-
-    // Should succeed without errors
-    const conversationError = events.find(
-      (e) => e.type === "conversation_error",
-    );
-    expect(conversationError).toBeUndefined();
-  });
-
   // ── Test 9 ────────────────────────────────────────────────────────
   // When the `auto_compress_latest_turn` rerun (the last layer of the
   // overflow-recovery ladder) still yields at the mid-loop checkpoint,

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

@@ -1559,9 +1559,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(
@@ -1973,49 +1985,6 @@ describe("session-agent-loop", () => {
       // 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: {
-          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));
-
-      // 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();
-    });
   });
 
   describe("provider ordering error retry", () => {
@@ -3188,9 +3157,8 @@ describe("session-agent-loop", () => {
       };
       const maybeCompactInputs: Message[][] = [];
 
-      // Sits above the loop's mid-loop threshold (~80.75k) but below the
-      // preflight-overflow budget (95k), so the loop's first-call gate — not
-      // the orchestrator — owns the turn-start compaction.
+      // 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({
@@ -3260,110 +3228,6 @@ describe("session-agent-loop", () => {
       ).not.toHaveBeenCalled();
     });
 
-    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 Conversation["trustContext"],
-        getTurnChannelContext: () => ({
-          userMessageChannel: "slack" as const,
-          assistantMessageChannel: "slack" as const,
-        }),
-        contextWindowManager: {
-          updateConfig: () => {},
-          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-          maybeCompact: async () => ({ compacted: false }),
-        } 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),
-      );
-    });
-
     test("mid-loop Slack compaction does not persist watermark from mismatched loaded context", async () => {
       const renderedSlackMessages: Message[] = [
         {

package/src/daemon/conversation-agent-loop.ts

@@ -41,7 +41,6 @@ import {
 } from "../context/post-turn-tool-result-truncation.js";
 import {
   estimatePromptTokens,
-  estimatePromptTokensWithTools,
   getCalibrationProviderKey,
 } from "../context/token-estimator.js";
 import type { ContextWindowCompactOptions } from "../context/window-manager.js";
@@ -147,10 +146,6 @@ import type {
   SurfaceType,
   UsageStats,
 } from "./message-protocol.js";
-import {
-  type OverflowReduceArgs,
-  runOverflowReductionLoop,
-} from "./overflow-reduction-loop.js";
 import { parseActualTokensFromError } from "./parse-actual-tokens-from-error.js";
 import {
   persistUnsendableImageDowngrades,
@@ -874,12 +869,11 @@ export async function runAgentLoopImpl(
     // outputs, persists the retrieval's own side effects (injected-block
     // metadata, recall log, `memory_recalled` event), and assembles the turn's
     // runtime-injection blocks onto the history (persisting those blocks too).
-    // Runs at the early "prompt submitted, before context assembly" moment
-    // because its output feeds the overflow-reduction transform below. It is
-    // shaped as the `user-prompt-submit-temp` hook handler but invoked directly
-    // for now: it must run early, while the canonical late `user-prompt-submit`
-    // hook (history repair, title) runs after that transform, so the two cannot
-    // share a fire site until compaction is cleared from the gap between them.
+    // Runs at the early "prompt submitted, before context assembly" moment so
+    // its injected output is what the agent loop receives. It is shaped as the
+    // `user-prompt-submit-temp` hook handler but invoked directly for now,
+    // separate from the canonical late `user-prompt-submit` hook (history
+    // repair, title) that fires just before the loop.
     // The injection inputs (`mode`, `isNonInteractive`, `modelProfile`,
     // `actorContext`) are resolved once at turn start and threaded in so
     // post-compaction re-injection reuses the same snapshot rather than live
@@ -915,144 +909,16 @@ export async function runAgentLoopImpl(
 
     // The `remember` tool handles scratchpad-style memory writes directly to the graph.
 
-    // ── Preflight budget evaluation ──────────────────────────────
-    // After runtime injections are applied, estimate the prompt token count
-    // and proactively invoke the reducer if already above budget. This avoids
-    // a wasted provider round-trip that would just fail with context_too_large.
-    const initialContextBudget = resolveCurrentContextBudget();
-    const overflowRecovery = initialContextBudget.overflowRecovery;
-    const preflightBudget = initialContextBudget.preflightBudget;
+    // Reducer state, tool-token budget, and calibration provider key consumed
+    // by the post-rejection convergence loop further down. The tool-token
+    // budget is resolved once per turn (the resolved tool set is stable across
+    // the turn); the calibration key matches the key recorded by `handleUsage`
+    // for wrapper providers (OpenRouter routing to Anthropic → key is
+    // `"anthropic"`).
     let reducerState: ReducerState | undefined;
-
     const toolTokenBudget = ctx.agentLoop.getToolTokenBudget(runMessages);
-    // Canonical calibration key — used by the preflight estimate, the
-    // overflow reducer config, and the convergence-path `estimatePromptTokens`
-    // call. Matches the key recorded by `handleUsage` for wrapper providers
-    // (OpenRouter routing to Anthropic → key is `"anthropic"`).
     const estimationProviderName = getCalibrationProviderKey(ctx.provider);
 
-    const preflightTokens = estimatePromptTokensWithTools(
-      runMessages,
-      ctx.systemPrompt,
-      ctx.agentLoop.getResolvedTools(runMessages),
-      estimationProviderName,
-    );
-
-    if (overflowRecovery.enabled && preflightTokens > preflightBudget) {
-      rlog.warn(
-        {
-          phase: "preflight",
-          estimatedTokens: preflightTokens,
-          budget: preflightBudget,
-        },
-        "Preflight budget exceeded — running overflow reducer before provider call",
-      );
-
-      // `runOverflowReductionLoop` drives the tier loop — forced compaction →
-      // tool-result truncation → media stubbing → injection downgrade — plus
-      // the re-inject/re-estimate convergence check. The callbacks below are
-      // the orchestrator-specific side effects it coordinates per iteration
-      // (activity emission, compaction application, runtime injection
-      // reassembly, token re-estimation).
-      const messagesForPreflightOverflowReduction =
-        slackChronologicalContext?.messages ?? ctx.messages;
-      const overflowArgs: OverflowReduceArgs = {
-        messages: messagesForPreflightOverflowReduction,
-        runMessages,
-        systemPrompt: ctx.systemPrompt,
-        providerName: estimationProviderName,
-        contextWindow: resolveCurrentContextWindowConfig(),
-        preflightBudget,
-        toolTokenBudget,
-        maxAttempts: resolveCurrentContextBudget().overflowRecovery.maxAttempts,
-        abortSignal: abortController.signal,
-        compactFn: async (msgs, signal, opts) => {
-          // Delegate the reducer's forced-compaction tier to the default
-          // compaction plugin, overlaying the turn's resolved inference
-          // profile and actor trust class onto the reducer-supplied options.
-          const reducerOptions = (opts ?? {}) as ContextWindowCompactOptions;
-          return defaultCompact({
-            manager: ctx.contextWindowManager,
-            messages: msgs,
-            signal,
-            ...reducerOptions,
-            overrideProfile: resolveCurrentOverrideProfile() ?? null,
-            actorTrustClass: resolveTurnActorTrustClass(ctx),
-          });
-        },
-        emitActivityState: () => {
-          ctx.emitActivityState("thinking", "context_compacting", {
-            requestId: reqId,
-          });
-        },
-        onCompactionResult: async (result, compactedBasis) => {
-          // Track circuit-breaker state whenever the reducer invoked
-          // compaction. The reducer's forced_compaction tier uses
-          // force:true, so it bypasses the open-circuit check, but we
-          // still want failure tracking to detect a run of broken
-          // summaries and clear the counter on success. Only track when
-          // the summary LLM actually ran — `summaryFailed === undefined`
-          // indicates an early return (no eligible messages,
-          // truncation-only path, etc.) that shouldn't influence the
-          // breaker.
-          if (result.summaryFailed !== undefined) {
-            await ctx.agentLoop.compactionCircuit.recordOutcome(
-              result.summaryFailed,
-              onEvent,
-            );
-          }
-          if (result.compacted) {
-            await applySuccessfulCompaction(result, compactedBasis);
-          }
-        },
-        reinjectForMode: async (reducedMessages, mode) => {
-          // `ctx.messages` must track the reducer's latest output before
-          // re-injection runs: the injectors' message-presence scans and the
-          // self-resolved Slack chronological transcript read live conversation
-          // state, and `applyCompactionResult` only updates `ctx.messages` on a
-          // compaction tier. Assigning here keeps non-compaction tiers
-          // (tool-result truncation, media stubbing, injection downgrade)
-          // observable to downstream injection assembly on the same turn.
-          ctx.messages = reducedMessages;
-
-          // When THIS iteration compacted, it stripped the existing
-          // memory-static block — so we re-inject current content. A later
-          // iteration that only truncates or downgrades must NOT re-force it,
-          // or each round would grow the token count.
-          // Gate: only the iteration that actually compacted re-injects.
-          // (The `<knowledge_base>`, NOW.md, and v2 static `<info>` blocks
-          // self-gate inside their injectors on whether they are already
-          // present in `reducedMessages`.)
-          const injection = await applyRuntimeInjections(reducedMessages, {
-            isNonInteractive,
-            modelProfile: modelProfileStr,
-            actorContext,
-            mode,
-            requestId: reqId,
-            conversationId: ctx.conversationId,
-          });
-          let next = injection.messages;
-          if (isTrustedActor && mode !== "minimal") {
-            const memResult = ctx.graphMemory.reinjectCachedMemory(next);
-            next = memResult.runMessages;
-          }
-          return next;
-        },
-        estimatePostInjection: (runMsgs) =>
-          estimatePromptTokens(runMsgs, ctx.systemPrompt, {
-            providerName: estimationProviderName,
-            toolTokenBudget,
-          }),
-      };
-
-      const overflowResult = await runOverflowReductionLoop(overflowArgs);
-
-      ctx.messages = overflowResult.messages;
-      runMessages = overflowResult.runMessages;
-      currentInjectionMode = overflowResult.injectionMode;
-      reducerState = overflowResult.reducerState;
-    }
-
     // Replace historical web_search_tool_result blocks with text summaries.
     // The opaque `encrypted_content` tokens Anthropic attaches to each result
     // expire / are route-scoped; replaying a stale token is rejected with
@@ -1557,7 +1423,7 @@ export async function runAgentLoopImpl(
       // through to the final graceful-error fallback below.
       if (state.contextTooLargeDetected) {
         const action = resolveOverflowAction({
-          overflowRecovery,
+          overflowRecovery: convergenceBudget.overflowRecovery,
           isInteractive: isInteractiveResolved,
         });
 

package/src/daemon/conversation-lifecycle.ts

@@ -242,5 +242,11 @@ export function disposeConversation(ctx: DisposeContext): void {
   ctx.accumulatedSurfaceState.clear();
   ctx.lastSurfaceAction.clear();
   ctx.workspaceTopLevelContext = null;
+  // The compaction module owns the per-conversation ContextWindowManager, so
+  // teardown releases it directly. Moving this behind a compaction-plugin hook
+  // would let the module own disposal end-to-end, but the per-turn `stop` hook 
+  // would first require relocating the manager's only
+  // cross-turn state — `nonPersistedPrefixCount` — off the manager so a
+  // per-turn dispose/rebuild stays correct.
   disposeContextWindowManager(ctx.conversationId);
 }

package/src/__tests__/overflow-reduction-loop.test.ts

@@ -1,384 +0,0 @@
-/**
- * Unit tests for `runOverflowReductionLoop` — the direct-call overflow
- * reducer driver.
- *
- * The default loop produces results **identical** to the historical inline
- * tier loop for a golden set of over-budget histories. We exercise this by
- * running the same inputs through two paths — `runOverflowReductionLoop` and
- * a faithful re-implementation of the original inline loop — and asserting
- * the final `(messages, runMessages, injectionMode, reducerState,
- * attempts)` tuple matches byte-for-byte. Additional cases
- * cover the two abort gates.
- */
-
-import { describe, expect, test } from "bun:test";
-
-import { estimatePromptTokens } from "../context/token-estimator.js";
-import type {
-  ContextWindowCompactOptions,
-  ContextWindowResult,
-} from "../context/window-manager.js";
-import { createContextSummaryMessage } from "../context/window-manager.js";
-import {
-  createInitialReducerState,
-  reduceContextOverflow,
-  type ReducerState,
-} from "../daemon/context-overflow-reducer.js";
-import type { InjectionMode } from "../daemon/conversation-runtime-assembly.js";
-import {
-  type OverflowReduceArgs,
-  runOverflowReductionLoop,
-} from "../daemon/overflow-reduction-loop.js";
-import type { Message } from "../providers/types.js";
-
-// ── Fixtures ────────────────────────────────────────────────────────────────
-
-function msg(role: "user" | "assistant", text: string): Message {
-  return { role, content: [{ type: "text", text }] };
-}
-
-function toolUseMsg(id: string, name: string): Message {
-  return {
-    role: "assistant",
-    content: [{ type: "tool_use", id, name, input: { path: "/tmp/test" } }],
-  };
-}
-
-function toolResultMsg(toolUseId: string, content: string): Message {
-  return {
-    role: "user",
-    content: [{ type: "tool_result", tool_use_id: toolUseId, content }],
-  };
-}
-
-const SYSTEM_PROMPT = "You are a helpful assistant.";
-
-const CONTEXT_WINDOW = {
-  enabled: true,
-  maxInputTokens: 2000,
-  targetBudgetRatio: 0.65,
-  compactThreshold: 0.6,
-  summaryBudgetRatio: 0.05,
-  overflowRecovery: {
-    enabled: true,
-    safetyMarginRatio: 0.05,
-    maxAttempts: 3,
-    interactiveLatestTurnCompression: "summarize" as const,
-    nonInteractiveLatestTurnCompression: "truncate" as const,
-  },
-};
-
-/**
- * Minimal compaction stub — always compacts to a one-message summary so the
- * reducer's forced-compaction tier succeeds. Mirrors `makeCompactFn` from
- * `context-overflow-reducer.test.ts` so the two test suites exercise the
- * reducer under comparable conditions.
- */
-function makeCompactFn(
-  summaryText = "## Goals\n- compacted summary",
-): (
-  messages: Message[],
-  signal: AbortSignal | undefined,
-  options: ContextWindowCompactOptions,
-) => Promise<ContextWindowResult> {
-  return async (messages, _signal, _options) => {
-    const summaryMsg = createContextSummaryMessage(summaryText);
-    const compactedMessages = [summaryMsg];
-    const estimatedInputTokens = estimatePromptTokens(
-      compactedMessages,
-      SYSTEM_PROMPT,
-      { providerName: "mock" },
-    );
-    return {
-      messages: compactedMessages,
-      compacted: true,
-      previousEstimatedInputTokens: estimatePromptTokens(
-        messages,
-        SYSTEM_PROMPT,
-        { providerName: "mock" },
-      ),
-      estimatedInputTokens,
-      maxInputTokens: 2000,
-      thresholdTokens: 1200,
-      compactedMessages: messages.length,
-      compactedPersistedMessages: messages.length,
-      summaryCalls: 1,
-      summaryInputTokens: 100,
-      summaryOutputTokens: 50,
-      summaryModel: "mock-model",
-      summaryText,
-    };
-  };
-}
-
-/**
- * Faithful re-implementation of the original inline tier loop — lives in
- * this test file rather than the production module so we have an immutable
- * baseline `runOverflowReductionLoop` can be diffed against. If either
- * implementation drifts, the golden-output cases below fail.
- *
- * The function intentionally avoids any side effects on external state — no
- * circuit-breaker tracking, no activity emission, no `applyCompactionResult`.
- * The production orchestrator still runs those through callbacks; this
- * baseline only needs the *message mutation* behavior so we can compare
- * reducer output.
- */
-async function runInlineBaseline(args: {
-  readonly messages: Message[];
-  readonly runMessages: Message[];
-  readonly systemPrompt: string;
-  readonly providerName: string;
-  readonly preflightBudget: number;
-  readonly toolTokenBudget?: number;
-  readonly maxAttempts: number;
-  readonly abortSignal?: AbortSignal;
-  readonly compactFn: (
-    messages: Message[],
-    signal: AbortSignal | undefined,
-    options: ContextWindowCompactOptions,
-  ) => Promise<ContextWindowResult>;
-  readonly contextWindow: typeof CONTEXT_WINDOW;
-  readonly reinjectForMode: (
-    reducedMessages: Message[],
-    mode: InjectionMode,
-  ) => Promise<Message[]>;
-  readonly estimatePostInjection: (runMsgs: Message[]) => number;
-}): Promise<{
-  messages: Message[];
-  runMessages: Message[];
-  injectionMode: InjectionMode;
-  reducerState: ReducerState;
-  attempts: number;
-}> {
-  let messages = args.messages;
-  let runMessages = args.runMessages;
-  let injectionMode: InjectionMode = "full";
-  let reducerState: ReducerState = createInitialReducerState();
-  let attempts = 0;
-
-  while (attempts < args.maxAttempts && !reducerState.exhausted) {
-    args.abortSignal?.throwIfAborted();
-    attempts++;
-    const step = await reduceContextOverflow(
-      messages,
-      {
-        providerName: args.providerName,
-        systemPrompt: args.systemPrompt,
-        contextWindow: args.contextWindow,
-        targetTokens: args.preflightBudget,
-        toolTokenBudget: args.toolTokenBudget,
-      },
-      reducerState,
-      args.compactFn,
-      args.abortSignal,
-    );
-
-    reducerState = step.state;
-    messages = step.messages;
-    injectionMode = step.state.injectionMode;
-
-    args.abortSignal?.throwIfAborted();
-
-    runMessages = await args.reinjectForMode(messages, injectionMode);
-
-    const postInjectionTokens = args.estimatePostInjection(runMessages);
-    if (postInjectionTokens <= args.preflightBudget) break;
-  }
-
-  return {
-    messages,
-    runMessages,
-    injectionMode,
-    reducerState,
-    attempts,
-  };
-}
-
-function buildArgs(messages: Message[]): {
-  args: OverflowReduceArgs;
-  reinjectCalls: Array<{ mode: InjectionMode }>;
-  compactionResults: ContextWindowResult[];
-  rawCompactFn: (
-    messages: Message[],
-    signal: AbortSignal | undefined,
-    options: ContextWindowCompactOptions,
-  ) => Promise<ContextWindowResult>;
-} {
-  const reinjectCalls: Array<{ mode: InjectionMode }> = [];
-  const compactionResults: ContextWindowResult[] = [];
-  const compactFn = makeCompactFn();
-
-  // Identity reinject: the test harness does not exercise the full
-  // `applyRuntimeInjections` pipeline; it simply tracks how many times the
-  // orchestrator would have been asked to rebuild `runMessages`. Returns the
-  // reducer's latest `messages` untouched — real orchestrator code re-injects
-  // runtime blocks.
-  const reinjectForMode = async (
-    reducedMessages: Message[],
-    mode: InjectionMode,
-  ): Promise<Message[]> => {
-    reinjectCalls.push({ mode });
-    return reducedMessages;
-  };
-
-  const estimatePostInjection = (runMsgs: Message[]): number =>
-    estimatePromptTokens(runMsgs, SYSTEM_PROMPT, {
-      providerName: "mock",
-    });
-
-  const args: OverflowReduceArgs = {
-    messages,
-    runMessages: messages,
-    systemPrompt: SYSTEM_PROMPT,
-    providerName: "mock",
-    contextWindow: CONTEXT_WINDOW,
-    preflightBudget: 1000,
-    toolTokenBudget: 0,
-    maxAttempts: CONTEXT_WINDOW.overflowRecovery.maxAttempts,
-    // `OverflowReduceArgs.compactFn` types `options` as `unknown` to avoid
-    // leaking the `ContextWindowCompactOptions` shape into the loop's args
-    // surface. The test helper produces a real `ContextWindowCompactOptions`
-    // signature, so we trampoline through a widened wrapper.
-    compactFn: (msgs, signal, opts) =>
-      compactFn(msgs, signal, opts as ContextWindowCompactOptions),
-    emitActivityState: () => {
-      /* no-op — the orchestrator owns activity emission */
-    },
-    onCompactionResult: (result) => {
-      compactionResults.push(result);
-    },
-    reinjectForMode,
-    estimatePostInjection,
-  };
-
-  return { args, reinjectCalls, compactionResults, rawCompactFn: compactFn };
-}
-
-// ── Test suite ──────────────────────────────────────────────────────────────
-
-describe("runOverflowReductionLoop", () => {
-  describe("matches historical inline loop", () => {
-    test("large tool-result history — identical reduced output", async () => {
-      // GIVEN an over-budget history dominated by a large tool result.
-      const longToolResult = "r".repeat(8000);
-      const goldenHistory: Message[] = [
-        msg("user", "Start"),
-        toolUseMsg("tu_1", "read_file"),
-        toolResultMsg("tu_1", longToolResult),
-        msg("assistant", "Result"),
-        msg("user", "Next"),
-      ];
-
-      // AND two independently-built arg sets over the SAME fixture so the
-      // direct call and the inline baseline never share a `compactFn`.
-      const directBuild = buildArgs(goldenHistory);
-      const inlineBuild = buildArgs(goldenHistory);
-
-      // WHEN we reduce via the direct loop and the inline baseline.
-      const directResult = await runOverflowReductionLoop(directBuild.args);
-      const inlineResult = await runInlineBaseline({
-        messages: goldenHistory,
-        runMessages: goldenHistory,
-        systemPrompt: SYSTEM_PROMPT,
-        providerName: "mock",
-        preflightBudget: inlineBuild.args.preflightBudget,
-        toolTokenBudget: inlineBuild.args.toolTokenBudget,
-        maxAttempts: inlineBuild.args.maxAttempts,
-        compactFn: inlineBuild.rawCompactFn,
-        contextWindow: CONTEXT_WINDOW,
-        reinjectForMode: inlineBuild.args.reinjectForMode,
-        estimatePostInjection: inlineBuild.args.estimatePostInjection,
-      });
-
-      // THEN every field the orchestrator relies on matches byte-for-byte.
-      expect(directResult.messages).toEqual(inlineResult.messages);
-      expect(directResult.runMessages).toEqual(inlineResult.runMessages);
-      expect(directResult.injectionMode).toBe(inlineResult.injectionMode);
-      expect(directResult.reducerState).toEqual(inlineResult.reducerState);
-      expect(directResult.attempts).toBe(inlineResult.attempts);
-    });
-
-    test("small conversation that fits after first reduction — single attempt", async () => {
-      // GIVEN a history that the first forced compaction brings under budget.
-      const smallHistory: Message[] = [
-        msg("user", "Hello"),
-        msg("assistant", "Hi there — how can I help?"),
-      ];
-
-      const directBuild = buildArgs(smallHistory);
-      const inlineBuild = buildArgs(smallHistory);
-
-      // WHEN we reduce via the direct loop and the inline baseline.
-      const directResult = await runOverflowReductionLoop(directBuild.args);
-      const inlineResult = await runInlineBaseline({
-        messages: smallHistory,
-        runMessages: smallHistory,
-        systemPrompt: SYSTEM_PROMPT,
-        providerName: "mock",
-        preflightBudget: inlineBuild.args.preflightBudget,
-        toolTokenBudget: inlineBuild.args.toolTokenBudget,
-        maxAttempts: inlineBuild.args.maxAttempts,
-        compactFn: inlineBuild.rawCompactFn,
-        contextWindow: CONTEXT_WINDOW,
-        reinjectForMode: inlineBuild.args.reinjectForMode,
-        estimatePostInjection: inlineBuild.args.estimatePostInjection,
-      });
-
-      // THEN both paths converge in the same single attempt with equal output.
-      expect(directResult.attempts).toBe(inlineResult.attempts);
-      expect(directResult.attempts).toBeGreaterThanOrEqual(1);
-      expect(directResult.messages).toEqual(inlineResult.messages);
-    });
-  });
-
-  describe("abort signal propagation", () => {
-    test("bails between iterations when abortSignal fires", async () => {
-      // GIVEN a history that won't converge in one step (multiple iterations).
-      const longToolResult = "r".repeat(8000);
-      const history: Message[] = [
-        msg("user", "Start"),
-        toolUseMsg("tu_1", "read_file"),
-        toolResultMsg("tu_1", longToolResult),
-        msg("user", "Next"),
-      ];
-
-      const controller = new AbortController();
-      const build = buildArgs(history);
-      // AND an estimator that aborts on its first call while reporting
-      // over-budget — so without the abort gate another iteration would run.
-      let estimateCalls = 0;
-      const aborting: OverflowReduceArgs = {
-        ...build.args,
-        abortSignal: controller.signal,
-        estimatePostInjection: () => {
-          estimateCalls++;
-          if (estimateCalls === 1) controller.abort();
-          return build.args.preflightBudget + 1_000_000;
-        },
-      };
-
-      // WHEN the loop runs THEN it throws on the post-side-effect abort gate.
-      await expect(runOverflowReductionLoop(aborting)).rejects.toThrow();
-      // AND exactly one iteration ran; the gate stopped the next round.
-      expect(estimateCalls).toBe(1);
-    });
-
-    test("refuses to start when abortSignal is already aborted", async () => {
-      // GIVEN an already-aborted signal.
-      const history: Message[] = [msg("user", "Hi")];
-      const controller = new AbortController();
-      controller.abort();
-      const build = buildArgs(history);
-      const args: OverflowReduceArgs = {
-        ...build.args,
-        abortSignal: controller.signal,
-      };
-
-      // WHEN the loop runs THEN it throws before the reducer ever runs.
-      await expect(runOverflowReductionLoop(args)).rejects.toThrow();
-      // AND no compaction or reinject callbacks were observed.
-      expect(build.compactionResults).toHaveLength(0);
-      expect(build.reinjectCalls).toHaveLength(0);
-    });
-  });
-});

package/src/daemon/overflow-reduction-loop.ts

@@ -1,197 +0,0 @@
-import type { ContextWindowConfig } from "../config/schemas/inference.js";
-import type {
-  ContextWindowCompactOptions,
-  ContextWindowResult,
-} from "../context/window-manager.js";
-import type { Message } from "../providers/types.js";
-import {
-  createInitialReducerState,
-  reduceContextOverflow,
-  type ReducerState,
-} from "./context-overflow-reducer.js";
-import type { InjectionMode } from "./conversation-runtime-assembly.js";
-
-/**
- * Input to the overflow-reduction loop. Captures everything the reducer
- * tier loop needs, including the message history, reducer configuration,
- * and side-effect callbacks that bridge the loop back to the orchestrator's
- * mutable per-turn state (context-window manager, activity emitter, runtime
- * injection reassembly, memory reinjection).
- *
- * The callbacks are supplied by the orchestrator because the reducer loop
- * needs to coordinate with state that lives on the `Conversation`
- * (message mutation, compaction event emission, circuit breaker tracking,
- * injection block reassembly). Keeping them as explicit callbacks keeps the
- * loop free of any dependency on the agent-loop context object.
- */
-export interface OverflowReduceArgs {
-  /** Bare persisted message history (the reducer applies results to a copy
-   *  of this array). */
-  readonly messages: Message[];
-  /** Current run-time message array with runtime injections applied. */
-  readonly runMessages: Message[];
-  /** System prompt used for post-step token estimation. */
-  readonly systemPrompt: string;
-  /** Provider name used for token estimation (calibration provider key). */
-  readonly providerName: string;
-  /** Context window config (drives compaction behavior). */
-  readonly contextWindow: ContextWindowConfig;
-  /** Token budget the reducer must get below (preflight budget). */
-  readonly preflightBudget: number;
-  /** Tool-token overhead included in every estimation call. */
-  readonly toolTokenBudget?: number;
-  /** Maximum reducer iterations before the loop exits unconditionally. */
-  readonly maxAttempts: number;
-  /** Abort signal threaded through compaction calls. */
-  readonly abortSignal?: AbortSignal;
-  /**
-   * Compaction callback — the loop never owns the ContextWindowManager
-   * instance. The orchestrator supplies this closure so the loop can
-   * delegate the forced-compaction tier without crossing the infra
-   * boundary on its own.
-   */
-  readonly compactFn: (
-    messages: Message[],
-    signal: AbortSignal | undefined,
-    options: unknown,
-  ) => Promise<ContextWindowResult>;
-  /**
-   * Invoked before each reducer iteration to emit the `context_compacting`
-   * activity state. The orchestrator owns activity emission because the
-   * signal is trust/channel aware.
-   */
-  readonly emitActivityState: () => void;
-  /**
-   * Invoked after each reducer step that produced a successful compaction.
-   * Handles circuit-breaker tracking, event emission, and context mutation.
-   */
-  readonly onCompactionResult: (
-    result: ContextWindowResult,
-    compactedBasis?: Message[],
-  ) => void | Promise<void>;
-  /**
-   * Invoked after each step to rebuild `runMessages` from the step's
-   * reduced history with the requested injection mode. The orchestrator
-   * owns this helper so the full per-turn injection options object doesn't
-   * leak into the loop. The current reduced messages array is passed
-   * explicitly so the orchestrator doesn't need to read mutable shared
-   * state. Returns the new `runMessages`.
-   *
-   * Re-injection self-resolves every per-turn block (including the Slack
-   * chronological transcript, which it loads scoped by the conversation's
-   * current compaction boundary), so the loop's compaction signals don't
-   * need to be threaded in.
-   */
-  readonly reinjectForMode: (
-    messages: Message[],
-    mode: InjectionMode,
-  ) => Promise<Message[]>;
-  /**
-   * Invoked after each step to post-estimate the rebuilt `runMessages`.
-   * Pulled out so the orchestrator controls how estimation is performed
-   * (and which fields feed it) without the loop reimplementing it.
-   */
-  readonly estimatePostInjection: (runMessages: Message[]) => number;
-}
-
-/** Output of the overflow-reduction loop. */
-export interface OverflowReduceResult {
-  /** Final reduced `ctx.messages` value. */
-  readonly messages: Message[];
-  /** Final `runMessages` with re-applied runtime injections. */
-  readonly runMessages: Message[];
-  /** Final injection mode (may be `"minimal"` if the downgrade tier fired). */
-  readonly injectionMode: InjectionMode;
-  /** Accumulated reducer state at exit. */
-  readonly reducerState: ReducerState;
-  /** How many iterations of the tier loop executed. */
-  readonly attempts: number;
-}
-
-/**
- * Run the context-overflow reducer tier loop — forced compaction, tool-result
- * truncation, media stubbing, injection downgrade — plus the post-step
- * re-injection / re-estimation convergence check.
- *
- * The forced-compaction tier is delegated through `args.compactFn`; the other
- * tiers mutate the message array directly. After each step the orchestrator
- * rebuilds `runMessages` via `args.reinjectForMode` and the loop re-estimates
- * the post-injection token count, exiting once it fits the preflight budget,
- * the reducer is exhausted, or `maxAttempts` is reached.
- */
-export async function runOverflowReductionLoop(
-  args: OverflowReduceArgs,
-): Promise<OverflowReduceResult> {
-  let messages = args.messages;
-  let runMessages = args.runMessages;
-  let injectionMode: "full" | "minimal" = "full";
-  let reducerState: ReducerState = createInitialReducerState();
-  let attempts = 0;
-
-  while (attempts < args.maxAttempts && !reducerState.exhausted) {
-    // Abort check at the top of every iteration. When the caller aborts
-    // externally, this check lets us bail out BETWEEN iterations rather
-    // than letting another round of compaction / re-injection mutate
-    // `ctx.messages` after the turn has already failed. Individual
-    // `reduceContextOverflow` calls also honor the signal, but without this
-    // gate a fresh iteration could still start after the signal fires,
-    // since the previous one returned normally before the abort propagated.
-    args.abortSignal?.throwIfAborted();
-
-    attempts++;
-    args.emitActivityState();
-
-    const basisMessages = messages;
-    const step = await reduceContextOverflow(
-      basisMessages,
-      {
-        providerName: args.providerName,
-        systemPrompt: args.systemPrompt,
-        contextWindow: args.contextWindow,
-        targetTokens: args.preflightBudget,
-        toolTokenBudget: args.toolTokenBudget,
-      },
-      reducerState,
-      (msgs, signal, opts: ContextWindowCompactOptions) =>
-        args.compactFn(msgs, signal, opts),
-      args.abortSignal,
-    );
-
-    reducerState = step.state;
-    messages = step.messages;
-    injectionMode = step.state.injectionMode;
-
-    // Let the orchestrator apply compaction side effects (circuit-breaker
-    // tracking, event emission, ctx mutation) before we re-inject.
-    if (step.compactionResult) {
-      await args.onCompactionResult(step.compactionResult, basisMessages);
-    }
-
-    // Second abort gate — if the side effects or the step itself took us
-    // past the deadline, don't rebuild runMessages or iterate again.
-    args.abortSignal?.throwIfAborted();
-
-    // Rebuild runMessages via the orchestrator-supplied helper (which
-    // re-runs `applyRuntimeInjections` with potentially downgraded mode
-    // and freshly re-hydrated PKB/NOW blocks after compaction). We pass
-    // the current reduced `messages` explicitly so the orchestrator never
-    // has to read from mutable shared state to rebuild runMessages — a
-    // tier that doesn't trigger compaction (tool-result truncation, media
-    // stubbing) won't update `ctx.messages` on its own.
-    runMessages = await args.reinjectForMode(messages, injectionMode);
-
-    // Re-estimate with injections included — `step.estimatedTokens` was
-    // computed on bare history and doesn't account for tokens added by
-    // runtime injections.
-    const postInjectionTokens = args.estimatePostInjection(runMessages);
-    if (postInjectionTokens <= args.preflightBudget) break;
-  }
-
-  return {
-    messages,
-    runMessages,
-    injectionMode,
-    reducerState,
-    attempts,
-  };
-}