@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -167,6 +167,7 @@ const mockFailStalledJobs = mock(() => 0);
 const mockClaimMemoryJobs = mock(() => []);
 mock.module("../memory/jobs-store.js", () => ({
   claimMemoryJobs: mockClaimMemoryJobs,
+  cancelPendingAutomaticConsolidationJobs: mock(() => 0),
   completeMemoryJob: mock(() => {}),
   deferMemoryJob: mock(() => "deferred"),
   EMBED_JOB_TYPES: [],
@@ -178,7 +179,12 @@ mock.module("../memory/jobs-store.js", () => ({
   failStalledJobs: mockFailStalledJobs,
   getMemoryJobCounts: mock(() => ({})),
   hasActiveJobOfType: mock(() => false),
+  isAutomaticConsolidationJob: mock(() => true),
   isMemoryEnabled: () => true,
+  MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS: {
+    automatic: "automatic",
+    manual: "manual",
+  },
   resetRunningJobsToPending: mock(() => 0),
   SLOW_LLM_JOB_TYPES: [],
   upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),

package/src/__tests__/btw-routes.test.ts

@@ -6,7 +6,9 @@
  * and no session.processing mutation.
  */
 
-import { describe, expect, mock, test } from "bun:test";
+import { rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mocks — must be defined before importing the module under test
@@ -76,7 +78,13 @@ mock.module("../runtime/routes/identity-intro-cache.js", () => ({
   getCachedIntro: () => null,
   readWorkspaceIdentityIntro: () => null,
   setCachedIntro: () => {},
-  computeIdentityContentHash: () => "test-hash",
+}));
+
+const assistantFeatureFlags: Record<string, boolean> = {};
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) =>
+    assistantFeatureFlags[key] ?? false,
 }));
 
 // Mock getOrCreateConversation from conversation-store so the handler
@@ -123,6 +131,7 @@ import {
   ServiceUnavailableError,
 } from "../runtime/routes/errors.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+import { getWorkspaceDir } from "../util/platform.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -177,6 +186,12 @@ function makeMockSession(
 const route = ROUTES.find((r) => r.endpoint === "btw" && r.method === "POST");
 if (!route) throw new Error("btw route not found in ROUTES");
 
+beforeEach(() => {
+  for (const key of Object.keys(assistantFeatureFlags)) {
+    delete assistantFeatureFlags[key];
+  }
+});
+
 async function callHandler(
   body: Record<string, unknown>,
 ): Promise<{ result: unknown; error?: unknown }> {
@@ -324,7 +339,25 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.modelIntent).toBeUndefined();
   });
 
-  test("greeting requests pass callSite: 'emptyStateGreeting'", async () => {
+  test("greeting requests return static fallback when the dynamic greetings flag is off", async () => {
+    mockGetOrCreateConversation.mockClear();
+
+    const { result } = await callHandler({
+      conversationKey: "greeting",
+      content: "Generate a greeting",
+    });
+    const text = await readStream(result as ReadableStream<Uint8Array>);
+
+    expect(text).toContain(
+      `event: btw_text_delta\ndata: {"text":"What are we working on?"}`,
+    );
+    expect(text).toContain("event: btw_complete\ndata: {}");
+    expect(mockGetOrCreateConversation).not.toHaveBeenCalled();
+  });
+
+  test("greeting requests pass callSite: 'emptyStateGreeting' when the dynamic greetings flag is on", async () => {
+    assistantFeatureFlags["empty-state-dynamic-greetings"] = true;
+
     const provider = makeMockProvider();
     const session = makeMockSession(provider);
     mockGetOrCreateConversation.mockImplementationOnce(async () => session);
@@ -356,6 +389,32 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.callSite).toBe("identityIntro");
   });
 
+  test("identity intro requests do not synthesize a static name greeting", async () => {
+    const identityPath = join(getWorkspaceDir(), "IDENTITY.md");
+    writeFileSync(
+      identityPath,
+      "# Identity\n\n- **Name:** Example Assistant\n",
+      "utf-8",
+    );
+
+    try {
+      const provider = makeMockProvider();
+      const session = makeMockSession(provider);
+      mockGetOrCreateConversation.mockImplementationOnce(async () => session);
+
+      const { result } = await callHandler({
+        conversationKey: "identity-intro",
+        content: "Generate an intro",
+      });
+      const text = await readStream(result as ReadableStream<Uint8Array>);
+
+      expect(provider.sendMessage).toHaveBeenCalledTimes(1);
+      expect(text).not.toContain("Hi, I'm Example Assistant!");
+    } finally {
+      rmSync(identityPath, { force: true });
+    }
+  });
+
   // -- No persistence --
 
   test("does not persist any messages (addMessage never called)", async () => {

package/src/__tests__/build-persisted-content.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Tests for `buildPersistedAssistantContent` stamping native web-search
+ * activity (`_activityMetadata`) onto `server_tool_use` blocks at persist time.
+ *
+ * Native Anthropic web_search resolves mid-stream — `server_tool_complete`
+ * fires before `message_complete` — so the captured activity is available when
+ * the content is persisted. Unlike external provider tools, a pure-native turn
+ * has no `tool_result` and never runs `annotatePersistedAssistantMessage`, so
+ * stamping must happen here or the WebSearchProgressCard is lost on a history
+ * reopen. Read-side coverage lives in server-history-render.test.ts.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ─────────────────────────
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: false, watchDebounceMs: 0 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: () => ({ id: "mock-msg-id" }),
+  getMessageById: () => null,
+  updateMessageContent: () => {},
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+// ── Imports (after mocks) ─────────────────────────────────────────────────────
+import { buildPersistedAssistantContent } from "../daemon/conversation-agent-loop-handlers.js";
+import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+import type { ContentBlock } from "../providers/types.js";
+
+const webSearchActivity: ToolActivityMetadata = {
+  webSearch: {
+    query: "vellum docs",
+    provider: "anthropic-native",
+    resultCount: 1,
+    durationMs: 88,
+    results: [
+      {
+        rank: 1,
+        title: "Vellum",
+        url: "https://vellum.ai",
+        domain: "vellum.ai",
+      },
+    ],
+  },
+};
+
+function findBlockById(
+  blocks: ContentBlock[],
+  id: string,
+): Record<string, unknown> {
+  const block = (blocks as unknown as Array<Record<string, unknown>>).find(
+    (b) => b.id === id,
+  );
+  if (!block) throw new Error(`block ${id} not found`);
+  return block;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("buildPersistedAssistantContent — native activityMetadata", () => {
+  let activity: Map<string, ToolActivityMetadata>;
+
+  beforeEach(() => {
+    activity = new Map();
+  });
+
+  test("stamps captured activity onto a pure-native server_tool_use block", () => {
+    // GIVEN a turn whose only tool is a native server_tool_use whose activity
+    // was captured at server_tool_complete (no external tool_result, so the
+    // annotate pass never runs for this turn)
+    const nativeId = "srvtu_native_search";
+    activity.set(nativeId, webSearchActivity);
+    const rawBlocks = [
+      { type: "text", text: "Let me search." },
+      {
+        type: "server_tool_use",
+        id: nativeId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence
+    const built = buildPersistedAssistantContent(rawBlocks, [], activity);
+
+    // THEN the server_tool_use block carries the native activity verbatim so it
+    // survives a history reopen
+    const block = findBlockById(built, nativeId);
+    expect(block._activityMetadata).toEqual(webSearchActivity);
+  });
+
+  test("leaves a server_tool_use block untouched when no activity was captured", () => {
+    // GIVEN a native server_tool_use with no entry in the activity map
+    const nativeId = "srvtu_no_activity";
+    const rawBlocks = [
+      {
+        type: "server_tool_use",
+        id: nativeId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence
+    const built = buildPersistedAssistantContent(rawBlocks, [], activity);
+
+    // THEN no _activityMetadata is written
+    const block = findBlockById(built, nativeId);
+    expect(block._activityMetadata).toBeUndefined();
+  });
+
+  test("does not stamp external tool_use blocks (handled by the annotate pass)", () => {
+    // GIVEN an external tool_use block whose id happens to have captured
+    // activity (external activity is stamped later in handleToolResult, not here)
+    const externalId = "tu_external_search";
+    activity.set(externalId, webSearchActivity);
+    const rawBlocks = [
+      {
+        type: "tool_use",
+        id: externalId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence
+    const built = buildPersistedAssistantContent(rawBlocks, [], activity);
+
+    // THEN the tool_use block is left untouched by this function
+    const block = findBlockById(built, externalId);
+    expect(block._activityMetadata).toBeUndefined();
+  });
+
+  test("does not stamp when no activity map is provided", () => {
+    // GIVEN a native server_tool_use block AND no activity map argument
+    const nativeId = "srvtu_no_map";
+    const rawBlocks = [
+      {
+        type: "server_tool_use",
+        id: nativeId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence without the optional map
+    const built = buildPersistedAssistantContent(rawBlocks, []);
+
+    // THEN no _activityMetadata is written
+    const block = findBlockById(built, nativeId);
+    expect(block._activityMetadata).toBeUndefined();
+  });
+});

package/src/__tests__/catalog-files.test.ts

@@ -963,7 +963,7 @@ describe("createVellumCatalogProvider", () => {
     expect(slim!.kind).toBe("catalog");
     expect(slim!.origin).toBe("vellum");
     expect(slim!.status).toBe("available");
-    expect(slim!.category).toBe("knowledge");
+    expect(slim!.category).toBe("system");
   });
 
   test("toSlimSkill returns null for unknown skill", async () => {

package/src/__tests__/channel-approval-routes.test.ts

@@ -16,7 +16,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 

package/src/__tests__/channel-approvals.test.ts

@@ -11,7 +11,7 @@ mock.module("../util/logger.js", () => ({
 
 // Map conversationId → mock session so findConversation returns the right mock.
 const conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => conversationMocks.get(id),
 }));
 

package/src/__tests__/clawhub-files.test.ts

@@ -291,7 +291,7 @@ describe("toSlimSkill", () => {
     expect(slim!.kind).toBe("catalog");
     expect(slim!.status).toBe("available");
     expect(slim!.origin).toBe("clawhub");
-    expect(slim!.category).toBe("knowledge");
+    expect(slim!.category).toBe("integrations");
 
     // Clawhub-specific fields
     const clawhub = slim as unknown as Record<string, unknown>;

package/src/__tests__/compaction-circuit.test.ts

@@ -0,0 +1,258 @@
+/**
+ * Tests for the `CompactionCircuit` class.
+ *
+ * The breaker logic lives as direct methods on the per-conversation
+ * `CompactionCircuit` state container (`agent/compaction-circuit.ts`). These
+ * tests assert the threshold (3 consecutive failures) and cooldown (1 hour)
+ * exactly match the user-visible behavior:
+ *   (a) counter increments on each failure outcome
+ *   (b) circuit opens after exactly 3 consecutive failures
+ *   (c) successful compaction resets counter and clears the circuit
+ *   (d) isOpen() reflects state and cooldown expiry
+ *   (e) circuit re-opens after cooldown expiry when 3 more failures
+ *       accumulate (guards the stale-timestamp regression)
+ *   (f) isOpen() is query-only and never mutates the counter
+ *   (g) open→closed transition emits `compaction_circuit_closed` exactly once
+ *   (h) closed→closed transition emits nothing
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  COMPACTION_CIRCUIT_COOLDOWN_MS,
+  COMPACTION_CIRCUIT_FAILURE_THRESHOLD,
+  CompactionCircuit,
+} from "../agent/compaction-circuit.js";
+import type { CompactionCircuitEvent } from "../plugins/types.js";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+const CONVERSATION_ID = "conv-breaker-test";
+
+function collectEvents(): {
+  events: CompactionCircuitEvent[];
+  onEvent: (msg: CompactionCircuitEvent) => void;
+} {
+  const events: CompactionCircuitEvent[] = [];
+  return { events, onEvent: (msg) => events.push(msg) };
+}
+
+describe("CompactionCircuit", () => {
+  let originalDateNow: () => number;
+
+  beforeEach(() => {
+    originalDateNow = Date.now;
+  });
+
+  afterEach(() => {
+    Date.now = originalDateNow;
+  });
+
+  test("threshold and cooldown constants match the user-visible contract", () => {
+    expect(COMPACTION_CIRCUIT_FAILURE_THRESHOLD).toBe(3);
+    expect(COMPACTION_CIRCUIT_COOLDOWN_MS).toBe(60 * 60 * 1000);
+  });
+
+  test("(a) counter increments on each failure outcome", async () => {
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent, events } = collectEvents();
+
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(1);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(0);
+
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(0);
+  });
+
+  test("(b) circuit opens after exactly 3 consecutive failures", async () => {
+    const fixedNow = 1_700_000_000_000;
+    Date.now = () => fixedNow;
+
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent, events } = collectEvents();
+
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    // Two failures — circuit still closed.
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(0);
+
+    await circuit.recordOutcome(true, onEvent);
+    // Third failure — circuit trips and fires the event exactly once.
+    expect(circuit.consecutiveCompactionFailures).toBe(3);
+    expect(circuit.compactionCircuitOpenUntil).toBe(fixedNow + 60 * 60 * 1000);
+    expect(await circuit.isOpen()).toBe(true);
+    expect(events).toHaveLength(1);
+    expect(events[0]).toEqual({
+      type: "compaction_circuit_open",
+      conversationId: CONVERSATION_ID,
+      reason: "3_consecutive_failures",
+      openUntil: fixedNow + 60 * 60 * 1000,
+    });
+
+    // Further failures do not re-fire the event while the circuit is open.
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(4);
+    expect(events).toHaveLength(1);
+  });
+
+  test("(c) successful outcome resets counter and clears circuit", async () => {
+    const fixedNow = 1_700_000_000_000;
+    Date.now = () => fixedNow;
+
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent } = collectEvents();
+
+    // Trip the breaker.
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.compactionCircuitOpenUntil).not.toBeNull();
+
+    // Success resets state.
+    await circuit.recordOutcome(false, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(0);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+  });
+
+  test("(d) isOpen() reflects state and expiry", async () => {
+    const fixedNow = 1_700_000_000_000;
+    Date.now = () => fixedNow;
+
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent } = collectEvents();
+
+    // Fresh state: closed.
+    expect(await circuit.isOpen()).toBe(false);
+
+    // Trip the breaker.
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+
+    // While open.
+    expect(await circuit.isOpen()).toBe(true);
+
+    // After cooldown expires the breaker reports closed again, even without
+    // an explicit reset — the open-until timestamp is the only source of
+    // truth for the gate.
+    Date.now = () => fixedNow + 60 * 60 * 1000 + 1;
+    expect(await circuit.isOpen()).toBe(false);
+  });
+
+  test("(e) circuit re-opens after cooldown expiry when 3 more failures accumulate", async () => {
+    // Regression: opening the breaker a second time must not require
+    // `compactionCircuitOpenUntil === null`. Once a cooldown expires, the
+    // gate correctly reports "closed" but a stale past-timestamp stays on the
+    // state, so the next 3-strike window must still trip a new cooldown. Any
+    // expired timestamp is treated the same as null.
+    const t0 = 1_700_000_000_000;
+    Date.now = () => t0;
+
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent, events } = collectEvents();
+
+    // Trip the breaker the first time.
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.compactionCircuitOpenUntil).toBe(t0 + 60 * 60 * 1000);
+    expect(events).toHaveLength(1);
+
+    // Advance past the cooldown window. Reset the counter — in production this
+    // happens when a subsequent `maybeCompact` call succeeds after the
+    // cooldown elapses, but the bug manifests even when the counter is reset:
+    // the stale `compactionCircuitOpenUntil` is what breaks re-opening.
+    const t1 = t0 + 60 * 60 * 1000 + 1;
+    Date.now = () => t1;
+    expect(await circuit.isOpen()).toBe(false);
+    circuit.consecutiveCompactionFailures = 0;
+    // `compactionCircuitOpenUntil` is deliberately left as the old timestamp
+    // to reproduce the bug condition.
+    expect(circuit.compactionCircuitOpenUntil).toBe(t0 + 60 * 60 * 1000);
+
+    // Three more failures must trip a fresh cooldown even though the old
+    // timestamp is still set.
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(3);
+    expect(circuit.compactionCircuitOpenUntil).toBe(t1 + 60 * 60 * 1000);
+    expect(events).toHaveLength(2);
+    expect(events[1]).toEqual({
+      type: "compaction_circuit_open",
+      conversationId: CONVERSATION_ID,
+      reason: "3_consecutive_failures",
+      openUntil: t1 + 60 * 60 * 1000,
+    });
+  });
+
+  test("(f) isOpen() is query-only and never mutates the counter", async () => {
+    // `maybeCompact()` early-return paths skip `recordOutcome` entirely and
+    // only gate on `isOpen()`. The query must never touch the 3-strike
+    // counter so those early returns can't silently reset it.
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent } = collectEvents();
+
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
+
+    // Query-only — must NOT touch the counter.
+    expect(await circuit.isOpen()).toBe(false);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
+
+    // A third real failure then trips the breaker as expected.
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(3);
+    expect(circuit.compactionCircuitOpenUntil).not.toBeNull();
+  });
+
+  test("(g) open→closed transition emits compaction_circuit_closed exactly once", async () => {
+    // Regression: the reset branch must notify the client on open→closed.
+    // Otherwise the Swift banner set from `compaction_circuit_open` stays
+    // visible until the original `openUntil` deadline (up to 1h),
+    // misrepresenting the live state.
+    const fixedNow = 1_700_000_000_000;
+    Date.now = () => fixedNow;
+
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent, events } = collectEvents();
+
+    // Force the circuit into the open state directly — the emitted-event
+    // transition logic is what we're testing, not the tripping path.
+    circuit.compactionCircuitOpenUntil = fixedNow + 60 * 60 * 1000;
+    circuit.consecutiveCompactionFailures = 3;
+
+    await circuit.recordOutcome(false, onEvent);
+
+    expect(circuit.consecutiveCompactionFailures).toBe(0);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(1);
+    expect(events[0]).toEqual({
+      type: "compaction_circuit_closed",
+      conversationId: CONVERSATION_ID,
+    });
+  });
+
+  test("(h) successful outcome against an already-closed circuit emits no event", async () => {
+    // Emitting `compaction_circuit_closed` on every successful compaction
+    // would spam the client (the breaker is closed in the common case).
+    // Only the open→closed transition is meaningful.
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent, events } = collectEvents();
+
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    await circuit.recordOutcome(false, onEvent);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(0);
+
+    // A second successful outcome while still closed — still no event.
+    await circuit.recordOutcome(false, onEvent);
+    expect(events).toHaveLength(0);
+  });
+});