@vellumai/assistant 0.6.5 → 0.6.6

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

@@ -6,6 +6,7 @@ import type {
   CheckpointInfo,
 } from "../agent/loop.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
 // ── Module mocks (must precede imports of the module under test) ─────
@@ -57,10 +58,19 @@ mock.module("../config/loader.js", () => ({
 // ── Overflow recovery mocks ──────────────────────────────────────────
 
 // Token estimator returns a small value by default (well within budget)
-// so preflight does not trigger unless the test overrides it.
+// so preflight does not trigger unless the test overrides it. Both the
+// calibrated entry point (`estimatePromptTokens`, used in the convergence
+// path) and the raw entry point (`estimatePromptTokensRaw`, used by the
+// default `tokenEstimate` plugin pipeline for preflight/mid-loop) are
+// stubbed so either call site can drive the test.
 let mockEstimateTokens = 1000;
 mock.module("../context/token-estimator.js", () => ({
   estimatePromptTokens: () => mockEstimateTokens,
+  estimatePromptTokensRaw: () => mockEstimateTokens,
+  // Pass-through: the default plugin computes `toolTokenBudget` via this
+  // helper before delegating to the raw estimator. Return 0 so the mocked
+  // raw estimate is not perturbed.
+  estimateToolsTokens: () => 0,
 }));
 
 // Reducer: by default returns the input untouched and marks exhausted
@@ -103,31 +113,10 @@ mock.module("../daemon/context-overflow-policy.js", () => ({
   resolveOverflowAction: () => mockOverflowAction,
 }));
 
-// Approval: default to denied
-let mockApprovalResult = { approved: false };
-mock.module("../daemon/context-overflow-approval.js", () => ({
-  requestCompressionApproval: async () => mockApprovalResult,
-  CONTEXT_OVERFLOW_TOOL_NAME: "context_overflow_compression",
-}));
-
-let hookBlocked = false;
-let hookBlockedBy = "";
-
-mock.module("../hooks/manager.js", () => ({
-  getHookManager: () => ({
-    trigger: async (hookName: string) => {
-      if (hookName === "pre-message" && hookBlocked) {
-        return { blocked: true, blockedBy: hookBlockedBy };
-      }
-      return { blocked: false };
-    },
-  }),
-}));
-
 const updateMessageMetadataMock = mock(
   (_id: string, _updates: Record<string, unknown>) => {},
 );
-const clearPkbSystemReminderMetadataForConversationMock = mock(
+const clearStrippedInjectionMetadataForConversationMock = mock(
   (_conversationId: string) => {},
 );
 mock.module("../memory/conversation-crud.js", () => ({
@@ -135,8 +124,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationUsage: () => {},
   updateMessageMetadata: updateMessageMetadataMock,
-  clearPkbSystemReminderMetadataForConversation:
-    clearPkbSystemReminderMetadataForConversationMock,
+  clearStrippedInjectionMetadataForConversation:
+    clearStrippedInjectionMetadataForConversationMock,
   getMessages: () => [],
   getConversation: () => ({
     id: "conv-1",
@@ -374,7 +363,9 @@ type AgentLoopRun = (
   onEvent: (event: AgentEvent) => void,
   signal?: AbortSignal,
   requestId?: string,
-  onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision,
+  onCheckpoint?: (
+    checkpoint: CheckpointInfo,
+  ) => CheckpointDecision | Promise<CheckpointDecision>,
 ) => Promise<Message[]>;
 
 function makeCtx(
@@ -404,6 +395,7 @@ function makeCtx(
     agentLoop: {
       run: agentLoopRun,
       getToolTokenBudget: () => 0,
+      getResolvedTools: () => [],
       // Tests here don't exercise calibration; returning undefined makes
       // the estimator use the per-provider aggregate key.
       getActiveModel: () => undefined,
@@ -509,12 +501,9 @@ function makeCtx(
 // ── Tests ────────────────────────────────────────────────────────────
 
 beforeEach(() => {
-  hookBlocked = false;
-  hookBlockedBy = "";
   mockEstimateTokens = 1000;
   mockReducerStepFn = null;
   mockOverflowAction = "fail_gracefully";
-  mockApprovalResult = { approved: false };
   mockInjectionBlocks = {};
   recordUsageMock.mockClear();
   recordRequestLogMock.mockClear();
@@ -522,11 +511,17 @@ beforeEach(() => {
   rebuildConversationDiskViewFromDbStateMock.mockClear();
   updateMessageMetadataMock.mockClear();
   updateMessageMetadataMock.mockImplementation(() => {});
-  clearPkbSystemReminderMetadataForConversationMock.mockClear();
-  clearPkbSystemReminderMetadataForConversationMock.mockImplementation(
+  clearStrippedInjectionMetadataForConversationMock.mockClear();
+  clearStrippedInjectionMetadataForConversationMock.mockImplementation(
     () => {},
   );
   applyRuntimeInjectionsMock.mockClear();
+  // 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.
+  resetPluginRegistryAndRegisterDefaults();
 });
 
 describe("session-agent-loop", () => {
@@ -540,47 +535,6 @@ describe("session-agent-loop", () => {
     });
   });
 
-  describe("pre-message hook blocking", () => {
-    test("emits error and returns early when pre-message hook blocks", async () => {
-      hookBlocked = true;
-      hookBlockedBy = "test-hook";
-      const events: ServerMessage[] = [];
-      const ctx = makeCtx();
-
-      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
-
-      const errorEvent = events.find((e) => e.type === "error");
-      expect(errorEvent).toBeDefined();
-      expect((errorEvent as { message: string }).message).toContain(
-        "test-hook",
-      );
-    });
-
-    test("removes user message when hook blocks without skipPreMessageRollback", async () => {
-      hookBlocked = true;
-      hookBlockedBy = "guard";
-      const ctx = makeCtx();
-      const originalLength = ctx.messages.length;
-
-      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
-
-      expect(ctx.messages.length).toBe(originalLength - 1);
-    });
-
-    test("keeps user message when hook blocks with skipPreMessageRollback", async () => {
-      hookBlocked = true;
-      hookBlockedBy = "guard";
-      const ctx = makeCtx();
-      const originalLength = ctx.messages.length;
-
-      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {}, {
-        skipPreMessageRollback: true,
-      });
-
-      expect(ctx.messages.length).toBe(originalLength);
-    });
-  });
-
   describe("tool execution errors via agent loop", () => {
     test("error events from agent loop are classified and emitted", async () => {
       const events: ServerMessage[] = [];
@@ -1308,71 +1262,6 @@ describe("session-agent-loop", () => {
       expect(complete).toBeDefined();
     });
 
-    test("interactive deny produces graceful assistant response instead of conversation_error", async () => {
-      const events: ServerMessage[] = [];
-
-      // Reducer exhausts all tiers but context is still too large
-      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,
-      });
-
-      mockOverflowAction = "request_user_approval";
-      mockApprovalResult = { approved: false };
-
-      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
-        onEvent({
-          type: "error",
-          error: new Error("context_length_exceeded"),
-        });
-        onEvent({
-          type: "usage",
-          inputTokens: 100,
-          outputTokens: 0,
-          model: "test-model",
-          providerDurationMs: 50,
-        });
-        return messages;
-      };
-
-      const ctx = makeCtx({
-        agentLoopRun,
-        contextWindowManager: {
-          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-          maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
-      });
-
-      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
-
-      // Should NOT emit conversation_error
-      const conversationError = events.find(
-        (e) => e.type === "conversation_error",
-      );
-      expect(conversationError).toBeUndefined();
-
-      // Should emit a graceful assistant text delta instead
-      const textDeltas = events.filter(
-        (e) => e.type === "assistant_text_delta",
-      );
-      expect(textDeltas.length).toBeGreaterThanOrEqual(1);
-      const lastDelta = textDeltas[textDeltas.length - 1] as {
-        text: string;
-      };
-      expect(lastDelta.text).toContain("compression was declined");
-    });
-
     test("non-interactive auto-compress continues without approval prompt", async () => {
       const events: ServerMessage[] = [];
       let callCount = 0;
@@ -1701,7 +1590,7 @@ describe("session-agent-loop", () => {
           providerDurationMs: 100,
         });
         if (onCheckpoint) {
-          const decision = onCheckpoint({
+          const decision = await onCheckpoint({
             turnIndex: 0,
             toolCount: 1,
             hasToolUse: true,
@@ -1769,7 +1658,7 @@ describe("session-agent-loop", () => {
           providerDurationMs: 100,
         });
         if (onCheckpoint) {
-          onCheckpoint({
+          await onCheckpoint({
             turnIndex: 0,
             toolCount: 1,
             hasToolUse: true,
@@ -2441,14 +2330,14 @@ describe("session-agent-loop", () => {
       // The bulk-clear helper must have been called with the conversation id
       // at least once (one of the three strip sites fired).
       const clearCalls =
-        clearPkbSystemReminderMetadataForConversationMock.mock.calls.filter(
+        clearStrippedInjectionMetadataForConversationMock.mock.calls.filter(
           (call) => call[0] === "test-conv",
         );
       expect(clearCalls.length).toBeGreaterThanOrEqual(1);
     });
 
     test("strip-site clear is non-fatal when the helper throws", async () => {
-      clearPkbSystemReminderMetadataForConversationMock.mockImplementation(
+      clearStrippedInjectionMetadataForConversationMock.mockImplementation(
         () => {
           throw new Error("db write failed");
         },

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -195,6 +195,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
     getActiveModel() {
       return undefined;
     }
@@ -203,7 +206,9 @@ mock.module("../agent/loop.js", () => ({
       _onEvent: (event: AgentEvent) => void,
       _signal?: AbortSignal,
       _requestId?: string,
-      _onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision,
+      _onCheckpoint?: (
+        checkpoint: CheckpointInfo,
+      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       return [];
     }

package/src/__tests__/conversation-history-web-search.test.ts

@@ -72,6 +72,7 @@ mock.module("../memory/qdrant-client.js", () => ({
   getQdrantClient: () => {
     throw new Error("Qdrant not initialized");
   },
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
 }));
 
 // Import after mocking

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -202,7 +202,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getTurnTimeBounds: () => null,
   PRIVATE_CONVERSATION_FORK_ERROR: "Cannot fork a private conversation",
   countConversationsByScheduleJobId: () => 0,
-  countMessagesWithSlackMeta: () => 0,
+  selectSlackMetaCandidateMetadata: () => [],
   forkConversation: () => null,
   wipeConversation: () => ({
     conversations: 0,
@@ -219,7 +219,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getLastAssistantTimestampBefore: () => null,
   archiveConversation: () => false,
   unarchiveConversation: () => false,
-  clearPkbSystemReminderMetadataForConversation: () => {},
+  clearStrippedInjectionMetadataForConversation: () => {},
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -233,13 +233,6 @@ mock.module("../memory/conversation-queries.js", () => ({
   buildExcerpt: () => "",
 }));
 
-mock.module("../hooks/manager.js", () => ({
-  getHookManager: () => ({
-    trigger: () => Promise.resolve(),
-    initialize: () => {},
-  }),
-}));
-
 mock.module("../tools/watch/watch-state.js", () => ({
   watchSessions: new Map(),
   registerWatchStartNotifier: () => {},
@@ -292,13 +285,6 @@ mock.module("../calls/call-store.js", () => ({
   finalizeCallbackClaim: () => true,
 }));
 
-mock.module("../daemon/watch-handler.js", () => ({
-  lastCommentaryByConversation: new Map(),
-  lastSummaryByConversation: new Map(),
-  handleWatchObservation: () => Promise.resolve(),
-  generateSummary: () => Promise.resolve(),
-}));
-
 mock.module("../tools/browser/browser-screencast.js", () => ({
   registerConversationSender: () => {},
   unregisterConversationSender: () => {},

package/src/__tests__/conversation-pairing.test.ts

@@ -358,8 +358,11 @@ describe("pairDeliveryWithConversation", () => {
     expect(upsertOutboundBindingMock).toHaveBeenCalledTimes(1);
   });
 
-  test("reuses pre-namespace binding when namespaced binding is absent", async () => {
-    // Simulate a binding created before the notification: prefix was introduced
+  test("reuses pre-namespace binding via inbound path when namespaced binding is absent", async () => {
+    // Simulate a binding created before the notification: prefix was introduced.
+    // Un-prefixed bindings are resolved by step 1 (inbound path) which skips
+    // the source check and does not upsert a notification-prefixed binding —
+    // the conversation is still reused.
     mockExistingConversations["conv-legacy"] = {
       id: "conv-legacy",
       source: "notification",
@@ -390,16 +393,11 @@ describe("pairDeliveryWithConversation", () => {
     expect(result.conversationId).toBe("conv-legacy");
     expect(result.createdNewConversation).toBe(false);
     expect(createConversationMock).not.toHaveBeenCalled();
-    // The upsert should write with the new namespaced sourceChannel
-    expect(upsertOutboundBindingMock).toHaveBeenCalledTimes(1);
-    const upsertArgs = upsertOutboundBindingMock.mock.calls[0]![0] as Record<
-      string,
-      unknown
-    >;
-    expect(upsertArgs.sourceChannel).toBe("notification:telegram");
+    // Inbound path does not touch outbound bindings — it only reads.
+    expect(upsertOutboundBindingMock).not.toHaveBeenCalled();
   });
 
-  test("falls back to new conversation when bound conversation is stale (wrong source)", async () => {
+  test("falls back to new conversation when notification-bound conversation is stale (wrong source) and no inbound binding exists", async () => {
     mockExistingConversations["conv-user-owned"] = {
       id: "conv-user-owned",
       source: "user",
@@ -410,6 +408,8 @@ describe("pairDeliveryWithConversation", () => {
       sourceChannel: "notification:slack",
       externalChatId: "C0123ABCDEF",
     };
+    // No inbound (un-prefixed) binding — step 1 finds nothing, step 2
+    // finds the notification binding but the source check rejects it.
 
     const signal = makeSignal();
     const copy = makeCopy();
@@ -468,6 +468,170 @@ describe("pairDeliveryWithConversation", () => {
     expect(upsertOutboundBindingMock).toHaveBeenCalledTimes(1);
   });
 
+  // ── Inbound conversation continuity ──────────────────────────────
+
+  test("prefers inbound conversation over notification-scoped conversation for reply continuity", async () => {
+    // An inbound conversation exists (un-prefixed binding, source: null)
+    // AND a notification conversation exists (prefixed binding, source: "notification").
+    // The inbound conversation should win so that the user's replies
+    // include the notification in their conversation history.
+    mockExistingConversations["conv-inbound"] = {
+      id: "conv-inbound",
+      source: null as unknown as string,
+      title: "Slack DM",
+    };
+    mockBindings["slack:D0ASABGUTQR"] = {
+      conversationId: "conv-inbound",
+      sourceChannel: "slack",
+      externalChatId: "D0ASABGUTQR",
+    };
+    mockExistingConversations["conv-notification"] = {
+      id: "conv-notification",
+      source: "notification",
+      title: "Notification Thread",
+    };
+    mockBindings["notification:slack:D0ASABGUTQR"] = {
+      conversationId: "conv-notification",
+      sourceChannel: "notification:slack",
+      externalChatId: "D0ASABGUTQR",
+    };
+
+    const signal = makeSignal();
+    const copy = makeCopy({
+      conversationSeedMessage: "New tweet from @alice - draft reply attached",
+    });
+    const bindingContext: DestinationBindingContext = {
+      sourceChannel: "slack" as NotificationChannel,
+      externalChatId: "D0ASABGUTQR",
+    };
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "slack" as NotificationChannel,
+      copy,
+      { bindingContext },
+    );
+
+    // Should use the inbound conversation, not the notification one
+    expect(result.conversationId).toBe("conv-inbound");
+    expect(result.messageId).toBe("msg-001");
+    expect(result.createdNewConversation).toBe(false);
+    expect(result.conversationFallbackUsed).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).toHaveBeenCalledTimes(1);
+    expect(addMessageMock.mock.calls[0]![0]).toBe("conv-inbound");
+    // Should NOT touch the notification binding — we only read the inbound one
+    expect(upsertOutboundBindingMock).not.toHaveBeenCalled();
+  });
+
+  test("uses inbound conversation regardless of source field for reply continuity", async () => {
+    // The inbound conversation has source: null (typical for conversations
+    // created by the inbound handler). The notification would normally
+    // skip this because effectiveSource is "notification". But the inbound
+    // path intentionally skips the source check.
+    mockExistingConversations["conv-inbound-null-source"] = {
+      id: "conv-inbound-null-source",
+      source: null as unknown as string,
+      title: "Slack DM",
+    };
+    mockBindings["slack:D0CHATID123"] = {
+      conversationId: "conv-inbound-null-source",
+      sourceChannel: "slack",
+      externalChatId: "D0CHATID123",
+    };
+
+    const signal = makeSignal();
+    const copy = makeCopy({
+      conversationSeedMessage: "Your daily briefing is ready",
+    });
+    const bindingContext: DestinationBindingContext = {
+      sourceChannel: "slack" as NotificationChannel,
+      externalChatId: "D0CHATID123",
+    };
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "slack" as NotificationChannel,
+      copy,
+      { bindingContext },
+    );
+
+    expect(result.conversationId).toBe("conv-inbound-null-source");
+    expect(result.createdNewConversation).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock.mock.calls[0]![0]).toBe("conv-inbound-null-source");
+  });
+
+  test("falls back to notification binding when inbound binding points to deleted conversation", async () => {
+    // Inbound binding exists but conversation was deleted.
+    // Should fall through to notification binding.
+    mockBindings["slack:D0STALE"] = {
+      conversationId: "conv-deleted-inbound",
+      sourceChannel: "slack",
+      externalChatId: "D0STALE",
+    };
+    // conv-deleted-inbound is NOT in mockExistingConversations — getConversation returns null
+
+    mockExistingConversations["conv-notification-fallback"] = {
+      id: "conv-notification-fallback",
+      source: "notification",
+      title: "Notification Thread",
+    };
+    mockBindings["notification:slack:D0STALE"] = {
+      conversationId: "conv-notification-fallback",
+      sourceChannel: "notification:slack",
+      externalChatId: "D0STALE",
+    };
+
+    const signal = makeSignal();
+    const copy = makeCopy();
+    const bindingContext: DestinationBindingContext = {
+      sourceChannel: "slack" as NotificationChannel,
+      externalChatId: "D0STALE",
+    };
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "slack" as NotificationChannel,
+      copy,
+      { bindingContext },
+    );
+
+    // Inbound conversation is gone — should fall back to notification conversation
+    expect(result.conversationId).toBe("conv-notification-fallback");
+    expect(result.createdNewConversation).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+  });
+
+  test("falls through to create new conversation when no inbound and no notification binding exists", async () => {
+    // First notification to a channel where user has never messaged.
+    // No bindings at all — should create a new conversation.
+    const signal = makeSignal();
+    const copy = makeCopy();
+    const bindingContext: DestinationBindingContext = {
+      sourceChannel: "slack" as NotificationChannel,
+      externalChatId: "D0BRANDNEW",
+    };
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "slack" as NotificationChannel,
+      copy,
+      { bindingContext },
+    );
+
+    expect(result.conversationId).toBe("conv-001");
+    expect(result.createdNewConversation).toBe(true);
+    expect(createConversationMock).toHaveBeenCalledTimes(1);
+    expect(upsertOutboundBindingMock).toHaveBeenCalledTimes(1);
+    const upsertArgs = upsertOutboundBindingMock.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >;
+    expect(upsertArgs.sourceChannel).toBe("notification:slack");
+    expect(upsertArgs.externalChatId).toBe("D0BRANDNEW");
+  });
+
   test("creates new conversation and upserts binding when no prior binding exists", async () => {
     const signal = makeSignal();
     const copy = makeCopy();

package/src/__tests__/conversation-pre-run-repair.test.ts

@@ -23,7 +23,7 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    
+
     llm: {
       default: {
         provider: "mock-provider",
@@ -141,6 +141,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
     getActiveModel() {
       return undefined;
     }

package/src/__tests__/conversation-process-callsite.test.ts

@@ -170,6 +170,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
     async run(
       messages: Message[],
       onEvent: (event: Record<string, unknown>) => void,

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
 import type { UserMessageAttachment } from "../daemon/message-protocol.js";
+import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 import { ProviderError } from "../util/errors.js";
 
@@ -26,7 +27,7 @@ mock.module("../config/loader.js", () => ({
     daemon: {
       titleGenerationMaxTokens: 30,
     },
-    
+
     llm: {
       default: {
         provider: "mock-provider",
@@ -76,9 +77,13 @@ mock.module("../config/loader.js", () => ({
 }));
 
 // Token estimator: return a small value (well within budget) so preflight
-// does not trigger in existing tests.
+// does not trigger in existing tests. Stub both the calibrated and raw
+// entry points — the latter backs the default `tokenEstimate` plugin
+// pipeline now used by the orchestrator's preflight / mid-loop checkpoints.
 mock.module("../context/token-estimator.js", () => ({
   estimatePromptTokens: () => 1000,
+  estimatePromptTokensRaw: () => 1000,
+  estimateToolsTokens: () => 0,
 }));
 
 // Overflow recovery module mocks — the convergence loop delegates to these
@@ -140,11 +145,6 @@ mock.module("../daemon/context-overflow-policy.js", () => ({
   resolveOverflowAction: () => "fail_gracefully",
 }));
 
-mock.module("../daemon/context-overflow-approval.js", () => ({
-  requestCompressionApproval: async () => ({ approved: false }),
-  CONTEXT_OVERFLOW_TOOL_NAME: "context_overflow_compression",
-}));
-
 mock.module("../prompts/system-prompt.js", () => ({
   buildSystemPrompt: () => "system prompt",
 }));
@@ -261,6 +261,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
     getActiveModel() {
       return undefined;
     }
@@ -445,6 +448,12 @@ describe("provider ordering error retry", () => {
     firstRunErrorMode = "ordering";
     maybeCompactCalls = [];
     forceCompactionEnabled = false;
+    // Orchestrator pipelines (`overflowReduce`, `persistence`, …) run through
+    // the plugin registry; re-register every default so each pipeline has a
+    // middleware to dispatch to. The `context-overflow-reducer` module itself
+    // (and other collaborators) are mocked above, so the default plugins'
+    // delegates go through the mocked implementations.
+    resetPluginRegistryAndRegisterDefaults();
   });
 
   test("simulated strict provider error triggers exactly one retry", async () => {