@vellumai/assistant 0.8.8 → 0.8.9-staging.2

package/src/__tests__/agent-wake-disk-pressure-callsite.test.ts

@@ -22,7 +22,6 @@ import type { Message } from "../providers/types.js";
 
 mock.module("../memory/conversation-crud.js", () => ({
   getConversationOverrideProfile: () => undefined,
-  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -62,36 +61,37 @@ mock.module("../daemon/disk-pressure-guard.js", () => ({
   }),
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
 import {
   __resetWakeChainForTests,
   wakeAgentForOpportunity,
-  type WakeTarget,
 } from "../runtime/agent-wake.js";
 
-function makeTarget(): WakeTarget {
-  const history: Message[] = [];
+function makeTarget(): Conversation {
+  const messages: Message[] = [];
   let processing = false;
-  return {
+  const target = {
     conversationId: "conv-wake-callsite",
     agentLoop: {
-      run: (async (messages: Message[]) => ({
+      run: async ({ messages }: { messages: Message[] }) => ({
         history: messages,
         exitReason: null,
         appendedNewMessages: false,
         newMessages: [],
-      })) as WakeTarget["agentLoop"]["run"],
+      }),
     },
-    getMessages: () => history,
-    pushMessage: (msg) => {
-      history.push(msg);
-    },
-    emitAgentEvent: () => {},
+    messages,
+    getMessages: () => messages,
     isProcessing: () => processing,
-    markProcessing: (on) => {
+    setProcessing: (on: boolean) => {
       processing = on;
     },
-    persistTailMessage: async () => {},
+    setTrustContext: () => {},
+    getTurnChannelContext: () => null,
+    getTurnInterfaceContext: () => null,
+    drainQueue: async () => {},
   };
+  return target as unknown as Conversation;
 }
 
 beforeEach(() => {

package/src/__tests__/agent-wake-override-profile.test.ts

@@ -48,8 +48,9 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
-import type { AgentEvent, AgentLoopRunOptions } from "../agent/loop.js";
+import type { AgentLoopRunOptions } from "../agent/loop.js";
 import { LLMSchema } from "../config/schemas/llm.js";
+import type { Conversation } from "../daemon/conversation.js";
 import { RetryProvider } from "../providers/retry.js";
 import type {
   Message,
@@ -60,7 +61,6 @@ import type {
 import {
   __resetWakeChainForTests,
   wakeAgentForOpportunity,
-  type WakeTarget,
 } from "../runtime/agent-wake.js";
 
 interface RunArgs {
@@ -69,44 +69,40 @@ interface RunArgs {
 }
 
 function makeTarget(): {
-  target: WakeTarget;
+  target: Conversation;
   runArgs: RunArgs[];
 } {
   const runArgs: RunArgs[] = [];
-  const history: Message[] = [
+  const messages: Message[] = [
     { role: "user", content: [{ type: "text", text: "hi" }] },
   ];
   let processing = false;
 
-  const target: WakeTarget = {
+  const target = {
     conversationId: "conv-wake-override",
     agentLoop: {
-      run: (async (
-        messages: Message[],
-        _onEvent: (event: AgentEvent) => void | Promise<void>,
-        options?: AgentLoopRunOptions,
-      ) => {
+      run: async (options: AgentLoopRunOptions) => {
         runArgs.push({
-          messages: [...messages],
+          messages: [...options.messages],
           options,
         });
         // Return the input verbatim → silent no-op (no assistant tail).
         // Wake never yields at a checkpoint, so the pause-reason is null.
-        return { history: messages, exitReason: null };
-      }) as WakeTarget["agentLoop"]["run"],
-    },
-    getMessages: () => history,
-    pushMessage: (msg) => {
-      history.push(msg);
+        return { history: options.messages, exitReason: null };
+      },
     },
-    emitAgentEvent: () => {},
+    messages,
+    getMessages: () => messages,
     isProcessing: () => processing,
-    markProcessing: (on) => {
+    setProcessing: (on: boolean) => {
       processing = on;
     },
-    persistTailMessage: async () => {},
+    setTrustContext: () => {},
+    getTurnChannelContext: () => null,
+    getTurnInterfaceContext: () => null,
+    drainQueue: async () => {},
   };
-  return { target, runArgs };
+  return { target: target as unknown as Conversation, runArgs };
 }
 
 beforeEach(() => {

package/src/__tests__/anthropic-provider.test.ts

@@ -102,7 +102,7 @@ mock.module("@anthropic-ai/sdk", () => ({
 }));
 
 // Import after mocking
-import { cachedTextBlock } from "../memory/v3/provider-blocks.js";
+import { cachedTextBlock } from "../plugins/defaults/memory-v3-shadow/provider-blocks.js";
 import { AnthropicProvider } from "../providers/anthropic/client.js";
 import {
   isPlaceholderSentinelText,

package/src/__tests__/app-builder-tool-scripts.test.ts

@@ -81,6 +81,7 @@ mock.module("../bundler/app-compiler.js", () => ({
 import * as appCreateScript from "../config/bundled-skills/app-builder/tools/app-create.js";
 import * as appDeleteScript from "../config/bundled-skills/app-builder/tools/app-delete.js";
 import * as appRefreshScript from "../config/bundled-skills/app-builder/tools/app-refresh.js";
+import * as appUpdateScript from "../config/bundled-skills/app-builder/tools/app-update.js";
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -171,4 +172,24 @@ describe("app-builder skill tool scripts", () => {
       expect(parsed.appId).toBe("app-1");
     });
   });
+
+  // ---- app-update --------------------------------------------------------
+
+  describe("app-update", () => {
+    test("exports a run function", () => {
+      expect(typeof appUpdateScript.run).toBe("function");
+    });
+
+    test("delegates to executeAppUpdate and returns result", async () => {
+      const result = await appUpdateScript.run(
+        { app_id: "app-1", name: "Renamed" },
+        makeContext(),
+      );
+      expect(result.isError).toBe(false);
+      const parsed = JSON.parse(result.content);
+      expect(parsed.updated).toBe(true);
+      expect(parsed.appId).toBe("app-1");
+      expect(parsed.name).toBe("Renamed");
+    });
+  });
 });

package/src/__tests__/app-control-flow.test.ts

@@ -103,7 +103,7 @@ const { ROUTES } = await import("../runtime/routes/host-app-control-routes.js");
 const { surfaceProxyResolver } =
   await import("../daemon/conversation-surfaces.js");
 const { setConversation, clearConversations } =
-  await import("../daemon/conversation-store.js");
+  await import("../daemon/conversation-registry.js");
 type SurfaceConversationContext =
   import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
 

package/src/__tests__/app-dir-path-guard.test.ts

@@ -19,6 +19,7 @@ const ALLOWLIST = new Set([
   "assistant/src/memory/app-store.ts", // defines getAppsDir
   "assistant/src/memory/app-git-service.ts", // uses getAppsDir for git repo root, not per-app paths
   "assistant/src/daemon/app-source-watcher.ts", // uses getAppsDir for recursive fs.watch root, not per-app paths
+  "assistant/src/tools/filesystem/write.ts", // uses getAppsDir as an exemption root for the artifact-HTML guard, not per-app paths
 ]);
 
 function isTestFile(filePath: string): boolean {

package/src/__tests__/app-executors.test.ts

@@ -32,6 +32,7 @@ import type { AppStore } from "../tools/apps/executors.js";
 import {
   executeAppCreate,
   executeAppRefresh,
+  executeAppUpdate,
 } from "../tools/apps/executors.js";
 
 // ---------------------------------------------------------------------------
@@ -89,6 +90,46 @@ function mockStore(
 // ---------------------------------------------------------------------------
 
 describe("executeAppCreate", () => {
+  test("falls back to the preview title when the name is omitted or blank", async () => {
+    let createdParams: Record<string, unknown> | undefined;
+    const app = makeMultifileApp({ name: "Coffee Tracker" });
+    const store: AppStore = {
+      ...mockStore(app, {}),
+      createApp: (params) => {
+        createdParams = params as unknown as Record<string, unknown>;
+        return app;
+      },
+    };
+
+    const result = await executeAppCreate(
+      { name: "   ", preview: { title: "Coffee Tracker" } },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(createdParams?.name).toBe("Coffee Tracker");
+  });
+
+  test("defaults the name to 'New App' when neither name nor preview title is given", async () => {
+    let createdParams: Record<string, unknown> | undefined;
+    const app = makeMultifileApp({ name: "New App" });
+    const store: AppStore = {
+      ...mockStore(app, {}),
+      createApp: (params) => {
+        createdParams = params as unknown as Record<string, unknown>;
+        return app;
+      },
+    };
+
+    const result = await executeAppCreate(
+      {} as unknown as Parameters<typeof executeAppCreate>[0],
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(createdParams?.name).toBe("New App");
+  });
+
   test("creates multifile app with src/ scaffold", async () => {
     const files: Record<string, string> = {};
     let createdParams: Record<string, unknown> | undefined;
@@ -408,3 +449,94 @@ describe("executeAppRefresh", () => {
     expect(parsed.error).toContain("not found");
   });
 });
+
+// ---------------------------------------------------------------------------
+// executeAppUpdate
+// ---------------------------------------------------------------------------
+
+describe("executeAppUpdate", () => {
+  test("updates metadata and recompiles a multifile app", async () => {
+    const app = makeMultifileApp({ name: "Old", description: "old desc" });
+    let updateArgs: unknown;
+    const store: AppStore = {
+      ...mockStore(app),
+      updateApp: (_id, updates) => {
+        updateArgs = updates;
+        return { ...app, ...updates };
+      },
+    };
+
+    const result = await executeAppUpdate(
+      { app_id: app.id, name: "New Name", description: "new desc" },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(updateArgs).toEqual({ name: "New Name", description: "new desc" });
+    const parsed = JSON.parse(result.content);
+    expect(parsed.updated).toBe(true);
+    expect(parsed.name).toBe("New Name");
+    expect(parsed.description).toBe("new desc");
+    expect(parsed.compiled).toBe(true);
+  });
+
+  test("writes source_files before recompiling", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp();
+    const store: AppStore = {
+      ...mockStore(app, files),
+      updateApp: (_id, updates) => ({ ...app, ...updates }),
+    };
+
+    const result = await executeAppUpdate(
+      { app_id: app.id, source_files: { "src/App.tsx": "// new code" } },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(files["src/App.tsx"]).toBe("// new code");
+    expect(JSON.parse(result.content).compiled).toBe(true);
+  });
+
+  test("legacy app: updates without compiling", async () => {
+    const app = makeLegacyApp({ name: "Legacy" });
+    const store: AppStore = {
+      ...mockStore(app),
+      updateApp: (_id, updates) => ({ ...app, ...updates }),
+    };
+
+    const result = await executeAppUpdate(
+      { app_id: app.id, name: "Renamed" },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.updated).toBe(true);
+    expect(parsed.name).toBe("Renamed");
+    expect(parsed.compiled).toBeUndefined();
+  });
+
+  test("returns error for unknown app", async () => {
+    const store = mockStore(makeMultifileApp());
+    const result = await executeAppUpdate({ app_id: "nope" }, store);
+
+    expect(result.isError).toBe(true);
+    expect(JSON.parse(result.content).error).toContain("not found");
+  });
+
+  test("rejects invalid source_files", async () => {
+    const app = makeMultifileApp();
+    const store = mockStore(app);
+    const result = await executeAppUpdate(
+      {
+        app_id: app.id,
+        source_files: { "src/App.tsx": 123 as unknown as string },
+      },
+      store,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(JSON.parse(result.content).error).toContain("must be a string");
+  });
+});

package/src/__tests__/approval-cascade.test.ts

@@ -176,6 +176,7 @@ mock.module("../memory/retriever.js", () => ({
 mock.module("../context/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -208,10 +209,10 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      _messages: Message[],
-      _onEvent: (event: AgentEvent) => void,
-    ): Promise<Message[]> {
+    async run(_options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
       return [];
     }
   },

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

@@ -119,12 +119,15 @@ mock.module("../permissions/trust-store.js", () => ({
 // ---------------------------------------------------------------------------
 let _conversationFactory: (() => Conversation) | undefined;
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: () => {
     // Return the current test session for any conversation ID lookup.
     if (!_conversationFactory) return undefined;
     return _conversationFactory();
   },
+}));
+
+mock.module("../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async () => {
     if (!_conversationFactory)
       throw new Error("_conversationFactory not set in test");

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

@@ -117,7 +117,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   findMostRecentRetrospectiveFor: mock(() => null),
   forkConversation: mock(() => ({ id: "conv-fork" })),
   getConversationOverrideProfile: () => undefined,
-  getConversationOverrideProfileFromRow: () => undefined,
+  resolveOverrideProfile: () => undefined,
   getConversationMemoryScopeId: () => "default",
   getConversationOriginChannel: () => null,
   getConversationOriginInterface: () => null,

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__/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);
+  });
+});