@vellumai/assistant 0.8.7-dev.202606052232.2ddc989 → 0.8.8

package/src/__tests__/compaction-timeout-recovery.test.ts

@@ -0,0 +1,251 @@
+/**
+ * Tests for the compaction call-site recovery path added in JARVIS-587.
+ *
+ * When the `compaction` pipeline exceeds its 30s budget (manifest-wide
+ * `DEFAULT_TIMEOUTS.compaction`), the pipeline runner throws
+ * `PluginTimeoutError`. The three compaction call sites in
+ * `conversation-agent-loop.ts` (start-of-turn, mid-loop, emergency) catch
+ * that error, record the failure on the loop-held `CompactionCircuit`
+ * (`recordOutcome(turn, true, ...)`) so the circuit breaker counts it, and degrade
+ * gracefully.
+ *
+ * This file asserts the tight coupling between:
+ *  (1) a `PluginTimeoutError`-driven failure and
+ *  (2) the compaction circuit breaker's 3-strike threshold.
+ *
+ * The existing `circuit-breaker-pipeline.test.ts` already exercises the
+ * breaker's transitions end-to-end. These tests verify that our new
+ * catch-blocks feed the breaker the same `"failure"` outcome a normal
+ * summary-LLM throw would, and that repeated timeouts therefore trip the
+ * same 3-strike trip.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  type CircuitTurnInfo,
+  CompactionCircuit,
+} from "../agent/compaction-circuit.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+import { COMPACTION_CIRCUIT_FAILURE_THRESHOLD } from "../plugins/defaults/circuit-breaker/middlewares/circuitBreaker.js";
+import { defaultCircuitBreakerPlugin } from "../plugins/defaults/circuit-breaker/register.js";
+import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
+import {
+  getMiddlewaresFor,
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import {
+  type CompactionArgs,
+  type CompactionResult,
+  type Middleware,
+  PluginTimeoutError,
+  type TurnContext,
+} from "../plugins/types.js";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+function makeCircuit(conversationId = "conv-timeout-test"): CompactionCircuit {
+  return new CompactionCircuit(conversationId);
+}
+
+const turn: CircuitTurnInfo = {
+  turnCount: 0,
+  trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
+};
+
+const trust: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+};
+
+function makeTurnCtx(conversationId: string): TurnContext {
+  return {
+    requestId: "req-timeout-test",
+    conversationId,
+    turnIndex: 0,
+    trust,
+  };
+}
+
+function collectEvents(): {
+  events: ServerMessage[];
+  onEvent: (msg: ServerMessage) => void;
+} {
+  const events: ServerMessage[] = [];
+  return { events, onEvent: (msg) => events.push(msg) };
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe("compaction timeout recovery (JARVIS-587)", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultCircuitBreakerPlugin);
+  });
+
+  afterEach(() => {
+    resetPluginRegistryForTests();
+  });
+
+  test("runPipeline('compaction', ...) throws PluginTimeoutError on budget breach", async () => {
+    // Baseline: the compaction pipeline still surfaces PluginTimeoutError when
+    // its timer fires. This guards the outer race from silently swallowing
+    // the timeout when the inner call is aborted by our Part A wiring.
+    const hang: Middleware<CompactionArgs, CompactionResult> = async (
+      _args,
+      _next,
+    ) =>
+      new Promise<CompactionResult>(() => {
+        // intentionally never resolves
+      });
+
+    let caught: unknown;
+    try {
+      await runPipeline<CompactionArgs, CompactionResult>(
+        "compaction",
+        [hang],
+        async () => ({ compacted: false }) as unknown as CompactionResult,
+        { messages: [] as unknown, signal: undefined, options: undefined },
+        makeTurnCtx("conv-budget-breach"),
+        // Override the manifest timeout to keep the test fast.
+        20,
+      );
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(PluginTimeoutError);
+    expect((caught as PluginTimeoutError).pipeline).toBe("compaction");
+  });
+
+  test("recordOutcome(failed=true) driven by PluginTimeoutError trips the breaker at the 3rd strike", async () => {
+    // Simulates the production sequence: each mid-loop compaction hits the
+    // pipeline's 30s ceiling, the catch path calls
+    // `circuit.recordOutcome(turn, true, onEvent)`. After three such catches
+    // the circuit breaker must be open — matching the same invariant the
+    // existing breaker test file exercises for normal summary-LLM throws.
+    const circuit = makeCircuit();
+    const { onEvent, events } = collectEvents();
+
+    // First two timeouts — circuit still closed.
+    await circuit.recordOutcome(turn, true, onEvent);
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(0);
+
+    // Third timeout — breaker trips and emits the canonical transition event.
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(
+      COMPACTION_CIRCUIT_FAILURE_THRESHOLD,
+    );
+    expect(circuit.compactionCircuitOpenUntil).not.toBeNull();
+    expect(events).toHaveLength(1);
+    expect(events[0]).toEqual({
+      type: "compaction_circuit_open",
+      conversationId: circuit.conversationId,
+      reason: "3_consecutive_failures",
+      openUntil: circuit.compactionCircuitOpenUntil as number,
+    });
+  });
+
+  test("a successful compaction after two timeouts resets the counter", async () => {
+    // The recovery path doesn't interfere with the breaker's normal reset —
+    // once a compaction call eventually succeeds, the streak is broken and
+    // the next failure starts counting from 1.
+    const circuit = makeCircuit();
+    const { onEvent } = collectEvents();
+
+    await circuit.recordOutcome(turn, true, onEvent);
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
+
+    await circuit.recordOutcome(turn, false, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(0);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(1);
+  });
+
+  test("compaction call-site recovery remains defense-in-depth even when DEFAULT_TIMEOUTS.compaction is null", () => {
+    // At the time this PR landed, `DEFAULT_TIMEOUTS.compaction` was null
+    // (pipeline timeouts globally disabled — see #27608). That makes the
+    // call-site catch blocks unreachable in production right now, but the
+    // catch blocks still matter: any future reintroduction of a per-pipeline
+    // compaction timeout immediately benefits from circuit-breaker recording
+    // and graceful-degradation without needing to re-touch every call site.
+    //
+    // This test just documents the current value so a future change that
+    // reintroduces a timeout must also decide (intentionally) whether the
+    // recovery path should continue to fire.
+    const value = DEFAULT_TIMEOUTS.compaction;
+    expect(value === null || typeof value === "number").toBe(true);
+  });
+});
+
+describe("abort propagation end-to-end (Part A + updateSummary fallback)", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultCircuitBreakerPlugin);
+  });
+
+  afterEach(() => {
+    resetPluginRegistryForTests();
+  });
+
+  test("caller-provided signal is replaced with a linked signal that fires on timeout", async () => {
+    // Minimal proof that Part A actually wires the signal through the
+    // compaction pipeline: when the pipeline runner's timer fires, the
+    // signal seen by the inner terminal is aborted — allowing
+    // `updateSummary`'s try/catch around `provider.sendMessage` to trigger
+    // the local-fallback path instead of the call hanging indefinitely.
+    let observedSignal: AbortSignal | undefined;
+    const waitForAbort: Middleware<CompactionArgs, CompactionResult> = async (
+      args,
+      _next,
+    ) => {
+      observedSignal = args.signal;
+      return new Promise<CompactionResult>((_resolve, reject) => {
+        args.signal?.addEventListener("abort", () => {
+          reject(
+            Object.assign(new Error("aborted by signal"), {
+              name: "AbortError",
+            }),
+          );
+        });
+      });
+    };
+
+    const callerController = new AbortController();
+
+    let caught: unknown;
+    try {
+      await runPipeline<CompactionArgs, CompactionResult>(
+        "compaction",
+        [waitForAbort, ...getMiddlewaresFor("compaction")],
+        async () => ({ compacted: false }) as unknown as CompactionResult,
+        {
+          messages: [] as unknown,
+          signal: callerController.signal,
+          options: undefined,
+        },
+        makeTurnCtx("conv-abort-test"),
+        20,
+      );
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(PluginTimeoutError);
+    expect(observedSignal).toBeDefined();
+    // The runner swaps the caller's signal for a linked signal — the two are
+    // distinct objects but both should end up aborted once the timer fires.
+    expect(observedSignal).not.toBe(callerController.signal);
+    expect(observedSignal!.aborted).toBe(true);
+    // Caller's own signal is untouched — pipeline timeout does not cascade
+    // outward onto the caller's controller.
+    expect(callerController.signal.aborted).toBe(false);
+  });
+});

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

@@ -145,6 +145,8 @@ function makeCtx(
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     workingDir: "/tmp",
+    workspaceTopLevelContext: null,
+    workspaceTopLevelDirty: false,
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
@@ -170,6 +172,7 @@ function makeCtx(
     hasNoClient: false,
     prompter: {} as Context["prompter"],
     queue: {} as Context["queue"],
+    refreshWorkspaceTopLevelContextIfNeeded: () => {},
     markWorkspaceTopLevelDirty: () => {},
     emitActivityState: () => {},
     getQueueDepth: () => 0,

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

@@ -435,6 +435,8 @@ function makeCtx(
     currentTurnSurfaces: [],
 
     workingDir: "/tmp",
+    workspaceTopLevelContext: null,
+    workspaceTopLevelDirty: false,
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
@@ -471,6 +473,7 @@ function makeCtx(
     getWorkspaceGitService: () => ({ ensureInitialized: async () => {} }),
     commitTurnChanges: async () => {},
 
+    refreshWorkspaceTopLevelContextIfNeeded: () => {},
     markWorkspaceTopLevelDirty: () => {},
     emitActivityState: () => {},
     getQueueDepth: () => 0,

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

@@ -515,6 +515,8 @@ function makeCtx(
     currentTurnSurfaces: [],
 
     workingDir: "/tmp",
+    workspaceTopLevelContext: null,
+    workspaceTopLevelDirty: false,
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
@@ -551,6 +553,7 @@ function makeCtx(
     getWorkspaceGitService: () => ({ ensureInitialized: async () => {} }),
     commitTurnChanges: async () => {},
 
+    refreshWorkspaceTopLevelContextIfNeeded: () => {},
     markWorkspaceTopLevelDirty: () => {},
     emitActivityState: () => {},
     getQueueDepth: () => 0,
@@ -648,9 +651,10 @@ beforeEach(() => {
   recordUsageMock.mockClear();
   setAgentLoopExitReasonOnLatestLogMock.mockClear();
   addMessageMock.mockClear();
-  // Reset the plugin registry and re-register every default so the compaction
-  // pipeline dispatches to the default middleware, which in turn hits the
-  // mocked collaborators (`syncMessageToDisk`, …) these tests install.
+  // Reset the plugin registry and re-register every default so the
+  // orchestrator's pipelines (`overflowReduce`, `persistence`, …) dispatch to
+  // the default middleware, which in turn hits the mocked collaborators
+  // (`reduceContextOverflow`, `syncMessageToDisk`, …) these tests install.
   resetPluginRegistryAndRegisterDefaults();
 });
 

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

@@ -316,14 +316,12 @@ const buildUnifiedTurnContextBlockMock = mock(
   (options: Record<string, unknown>) =>
     `<turn_context>\ncurrent_time: ${String(options.timestamp)}\n</turn_context>`,
 );
-const defaultApplyRuntimeInjectionsImpl = async (
-  msgs: Message[],
-  _options?: unknown,
-) => ({
-  messages: msgs,
-  blocks: { ...mockInjectionBlocks },
-});
-const applyRuntimeInjectionsMock = mock(defaultApplyRuntimeInjectionsImpl);
+const applyRuntimeInjectionsMock = mock(
+  async (msgs: Message[], _options?: unknown) => ({
+    messages: msgs,
+    blocks: { ...mockInjectionBlocks },
+  }),
+);
 let mockSlackChronologicalContext: {
   renderedMessages: Array<{
     message: Message;
@@ -638,6 +636,8 @@ function makeCtx(
     currentTurnSurfaces: [],
 
     workingDir: "/tmp",
+    workspaceTopLevelContext: null,
+    workspaceTopLevelDirty: false,
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
@@ -674,6 +674,7 @@ function makeCtx(
     getWorkspaceGitService: () => ({ ensureInitialized: async () => {} }),
     commitTurnChanges: async () => {},
 
+    refreshWorkspaceTopLevelContextIfNeeded: () => {},
     markWorkspaceTopLevelDirty: () => {},
     emitActivityState: () => {},
     getQueueDepth: () => 0,
@@ -743,9 +744,6 @@ beforeEach(() => {
   setConversationHistoryStrippedAtMock.mockClear();
   setConversationHistoryStrippedAtMock.mockImplementation(() => {});
   applyRuntimeInjectionsMock.mockClear();
-  applyRuntimeInjectionsMock.mockImplementation(
-    defaultApplyRuntimeInjectionsImpl,
-  );
   buildUnifiedTurnContextBlockMock.mockClear();
   resolveTurnTimezoneContextMock.mockClear();
   formatTurnTimestampMock.mockClear();
@@ -759,10 +757,11 @@ beforeEach(() => {
   projectAssistantMessageMock.mockClear();
   publishSyncInvalidationMock.mockClear();
   mockMessageById = null;
-  // 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.
+  // 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();
 });
 
@@ -881,23 +880,7 @@ describe("session-agent-loop", () => {
   });
 
   describe("disk pressure injection context", () => {
-    // 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 () => {
+    test("passes cleanup context into runtime injections for cleanup-mode turns", async () => {
       mockDiskPressureDecision = {
         action: "allow-cleanup-mode",
         reason: "guardian",
@@ -920,7 +903,6 @@ describe("session-agent-loop", () => {
           trustClass: "guardian",
         } as AgentLoopConversationContext["trustContext"],
       });
-      const cleanupFlagDuringInjection = captureCleanupFlagDuringInjection(ctx);
 
       await runAgentLoopImpl(ctx, "free up space", "msg-1", () => {});
 
@@ -939,16 +921,21 @@ describe("session-agent-loop", () => {
           },
         }),
       );
-      expect(cleanupFlagDuringInjection()).toEqual([true]);
+      const firstInjectionOptions = applyRuntimeInjectionsMock.mock
+        .calls[0]![1] as {
+        diskPressureContext?: { cleanupModeActive: boolean } | null;
+      };
+      expect(firstInjectionOptions.diskPressureContext).toEqual({
+        cleanupModeActive: true,
+      });
     });
 
-    test("sets the cleanup-mode flag on the conversation for local-owner turns", async () => {
+    test("passes cleanup context into runtime injections 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", () => {});
 
@@ -960,10 +947,16 @@ describe("session-agent-loop", () => {
           trustContext: null,
         }),
       );
-      expect(cleanupFlagDuringInjection()).toEqual([true]);
+      const firstInjectionOptions = applyRuntimeInjectionsMock.mock
+        .calls[0]![1] as {
+        diskPressureContext?: { cleanupModeActive: boolean } | null;
+      };
+      expect(firstInjectionOptions.diskPressureContext).toEqual({
+        cleanupModeActive: true,
+      });
     });
 
-    test("keeps the cleanup-mode flag set across overflow recovery reinjection", async () => {
+    test("keeps cleanup context on overflow recovery reinjection", async () => {
       mockDiskPressureDecision = {
         action: "allow-cleanup-mode",
         reason: "guardian",
@@ -985,14 +978,18 @@ describe("session-agent-loop", () => {
           trustClass: "guardian",
         } as AgentLoopConversationContext["trustContext"],
       });
-      const cleanupFlagDuringInjection = captureCleanupFlagDuringInjection(ctx);
 
       await runAgentLoopImpl(ctx, "free up space", "msg-1", () => {});
 
       expect(applyRuntimeInjectionsMock.mock.calls.length).toBeGreaterThan(1);
-      const flags = cleanupFlagDuringInjection();
-      expect(flags.length).toBeGreaterThan(1);
-      expect(flags.every((flag) => flag === true)).toBe(true);
+      for (const call of applyRuntimeInjectionsMock.mock.calls) {
+        const options = call[1] as {
+          diskPressureContext?: { cleanupModeActive: boolean } | null;
+        };
+        expect(options.diskPressureContext).toEqual({
+          cleanupModeActive: true,
+        });
+      }
     });
 
     test("blocks policy-denied turns before runtime injection or model execution", async () => {

package/src/__tests__/conversation-clean-command.test.ts

@@ -120,7 +120,7 @@ describe("stripInjectionsForCompaction preserves history shape", () => {
     expect(out[3]).toEqual(messages[3]);
   });
 
-  test("strips <workspace> but leaves <turn_context> and <memory __injected> alone", () => {
+  test("leaves <turn_context>, <workspace>, and <memory __injected> alone", () => {
     const messages: Message[] = [
       {
         role: "user",
@@ -132,9 +132,6 @@ describe("stripInjectionsForCompaction preserves history shape", () => {
       },
     ];
     const out = stripInjectionsForCompaction(messages);
-    expect(out[0].content).toEqual([
-      { type: "text", text: "<turn_context>\nnow\n</turn_context>" },
-      { type: "text", text: "<memory __injected>\nrecent\n</memory>" },
-    ]);
+    expect(out[0].content).toEqual(messages[0].content);
   });
 });

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

@@ -486,10 +486,11 @@ describe("provider ordering error retry", () => {
     firstRunErrorMode = "ordering";
     maybeCompactCalls = [];
     forceCompactionEnabled = false;
-    // The compaction pipeline runs through the plugin registry; re-register
-    // every default so it has a middleware to dispatch to. Collaborators are
-    // mocked above, so the default plugins' delegates go through the mocked
-    // implementations.
+    // 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();
   });