@vellumai/assistant 0.11.4 → 0.11.5-staging.1

package/src/runtime/routes/__tests__/pending-interactions-route.test.ts

@@ -0,0 +1,175 @@
+/**
+ * Tests for the conversation-scoped shape of `GET /v1/pending-interactions`.
+ *
+ * The registry is the authority clients project their prompt UI from, so what
+ * this route says about a kind matters as much when nothing is outstanding as
+ * when something is. Covers:
+ *   - an outstanding question is reported with its full batch,
+ *   - no question reports `null` (the value that authorizes a client to retire
+ *     a card), not an omitted key,
+ *   - every conversation-scoped path names the key, including the early return
+ *     for a conversation that cannot be resolved,
+ *   - the newest question wins while a superseded one is still settling,
+ *   - a question registered without entries is not reportable,
+ *   - the diagnostic (unfiltered) mode is unchanged.
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import type { QuestionEntry } from "../../../api/events/question-request.js";
+import * as pendingInteractions from "../../pending-interactions.js";
+import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
+
+// The conversation-key lookup is the only path into the unresolvable-conversation
+// early return, and it reads SQLite. Stub it so this stays a unit test of the
+// response shape. Imported dynamically below so the stub is in place first.
+mock.module("../../../persistence/conversation-key-store.js", () => ({
+  getConversationByKey: () => undefined,
+}));
+
+const { ROUTES: APPROVAL_ROUTES } = await import("../approval-routes.js");
+
+function findHandler(operationId: string): RouteDefinition["handler"] {
+  const route = APPROVAL_ROUTES.find((r) => r.operationId === operationId);
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
+  return route.handler;
+}
+
+const handler = findHandler("pending_interactions");
+
+interface ScopedResponse {
+  pendingConfirmation: unknown;
+  pendingSecret: unknown;
+  pendingQuestion: { requestId: string; entries: QuestionEntry[] } | null;
+}
+
+async function listForConversation(
+  conversationId: string,
+): Promise<ScopedResponse> {
+  const result = await handler({
+    queryParams: { conversationId },
+  } as unknown as RouteHandlerArgs);
+  return result as ScopedResponse;
+}
+
+const ENTRIES: QuestionEntry[] = [
+  {
+    id: "q1",
+    question: "Which draft should I send?",
+    options: [
+      { id: "a", label: "The short one" },
+      { id: "b", label: "The long one" },
+    ],
+  },
+];
+
+function registerQuestion(requestId: string, entries = ENTRIES): void {
+  pendingInteractions.register(requestId, {
+    conversationId: "conv-1",
+    kind: "question",
+    toolUseId: `tool-${requestId}`,
+    questionDetails: { entries },
+  });
+}
+
+/** A question interaction that never got its batch attached. */
+function registerQuestionWithoutDetails(requestId: string): void {
+  pendingInteractions.register(requestId, {
+    conversationId: "conv-1",
+    kind: "question",
+    toolUseId: `tool-${requestId}`,
+  });
+}
+
+afterEach(() => {
+  pendingInteractions.clear();
+});
+
+describe("pending-interactions, conversation-scoped", () => {
+  test("reports an outstanding question with its full batch", async () => {
+    // GIVEN a question interaction awaiting an answer in the conversation
+    registerQuestion("req-1");
+
+    // WHEN the conversation's pending interactions are read
+    const result = await listForConversation("conv-1");
+
+    // THEN the prompt is reported with everything the card needs to render
+    expect(result.pendingQuestion).toEqual({
+      requestId: "req-1",
+      entries: ENTRIES,
+    });
+  });
+
+  test("reports null once the question is resolved", async () => {
+    // GIVEN a question that has since been answered (registry entry consumed)
+    registerQuestion("req-1");
+    pendingInteractions.resolve("req-1", "answered");
+
+    // WHEN the conversation's pending interactions are read
+    const result = await listForConversation("conv-1");
+
+    // THEN the answer is a positive "nothing outstanding", which is what lets a
+    // client retire a card it is still showing. An omitted key would instead
+    // read as "this assistant has no opinion" and strand the card.
+    expect(result.pendingQuestion).toBeNull();
+    expect("pendingQuestion" in result).toBe(true);
+  });
+
+  test("names the key even when the conversation cannot be resolved", async () => {
+    // GIVEN a conversationKey that maps to no conversation
+    const result = (await handler({
+      queryParams: { conversationKey: "no-such-key" },
+    } as unknown as RouteHandlerArgs)) as ScopedResponse;
+
+    // THEN the early return still states all three kinds, so this path is not
+    // mistaken for an assistant that predates the field
+    expect("pendingQuestion" in result).toBe(true);
+    expect(result.pendingQuestion).toBeNull();
+  });
+
+  test("reports the newest question while a superseded one settles", async () => {
+    // GIVEN a superseded prompt that has not finished settling through its
+    // abort signal, so both entries sit in the registry at once
+    const newerEntries: QuestionEntry[] = [
+      { id: "q1", question: "Actually, which account?", options: [] },
+    ];
+    registerQuestion("req-old");
+    registerQuestion("req-new", newerEntries);
+
+    // WHEN the conversation's pending interactions are read
+    const result = await listForConversation("conv-1");
+
+    // THEN the prompt the user is actually being asked is the one reported
+    expect(result.pendingQuestion?.requestId).toBe("req-new");
+  });
+
+  test("does not report a question registered without its entries", async () => {
+    // GIVEN a question interaction carrying no renderable batch
+    registerQuestionWithoutDetails("req-1");
+
+    // WHEN the conversation's pending interactions are read
+    const result = await listForConversation("conv-1");
+
+    // THEN there is nothing a client could raise
+    expect(result.pendingQuestion).toBeNull();
+  });
+
+  test("leaves the unfiltered diagnostic listing unchanged", async () => {
+    // GIVEN pending interactions across the daemon
+    registerQuestion("req-1");
+
+    // WHEN the route is called with no conversation filter
+    const result = (await handler({
+      queryParams: {},
+    } as unknown as RouteHandlerArgs)) as {
+      interactions: Array<{ requestId: string; kind: string }>;
+    };
+
+    // THEN it still answers with the flat cross-conversation list
+    expect(result.interactions).toEqual([
+      expect.objectContaining({ requestId: "req-1", kind: "question" }),
+    ]);
+  });
+});

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -38,9 +38,12 @@
  *     `plugins:list` tag via the canonical resource-sync publisher (enable and
  *     disable emit the SAME invalidation)
  *   - Threads `x-vellum-client-id` into the published event's `originClientId`
- *   - Pokes the plugin-declared schedule reconcile on a successful toggle (and
- *     not on a failed one), so the plugin's rows disarm / re-arm immediately
- *     instead of at the reconciler's next backstop sweep
+ *   - Enable pokes the imperative plugin source reconcile, which activates a
+ *     plugin the boot scan skipped for its sentinel and converges its
+ *     schedules and MCP servers
+ *   - Disable pokes the plugin-declared schedule reconcile on a successful
+ *     toggle (and not on a failed one), so the plugin's rows disarm
+ *     immediately instead of at the reconciler's next backstop sweep
  *   - A broadcast failure does not fail a successful toggle (the publisher
  *     swallows hub errors)
  *   - Maps `InvalidPluginNameError` → BadRequestError (400)
@@ -316,8 +319,8 @@ mock.module("../../../cli/lib/toggle-plugin.js", () => ({
   enablePlugin: enablePluginSpy,
 }));
 
-// Spy on the plugin-schedule reconcile the toggle handlers poke. The handlers
-// import it lazily at call time, so this mock intercepts the dynamic import
+// Spy on the plugin-schedule reconcile the disable handler pokes. The handler
+// imports it lazily at call time, so this mock intercepts the dynamic import
 // and keeps the reconciler's persistence graph out of the test.
 const reconcilePluginSchedulesSpy = mock(() => Promise.resolve());
 
@@ -325,6 +328,21 @@ mock.module("../../../schedule/plugin-schedule-reconciler.js", () => ({
   reconcilePluginSchedules: reconcilePluginSchedulesSpy,
 }));
 
+// Spy on the imperative plugin source reconcile so the enable route's
+// activation poke is assertable without scanning a real plugins tree. Only
+// that one export is swapped; the rest of the module passes through real,
+// because other modules in this route's graph import their own bindings from
+// it.
+const reconcilePluginSourcesNowSpy = mock(() => Promise.resolve());
+
+const actualMtimeCache: typeof import("../../../plugins/mtime-cache.js") =
+  await import("../../../plugins/mtime-cache.js");
+
+mock.module("../../../plugins/mtime-cache.js", () => ({
+  ...actualMtimeCache,
+  reconcilePluginSourcesNow: reconcilePluginSourcesNowSpy,
+}));
+
 // Spy on broadcastMessage so we can assert the sync_changed invalidation the
 // enable/disable handlers emit. The handlers publish through the canonical
 // `publishPluginsChanged` → `publishSyncInvalidation` path (both left real), so
@@ -2573,8 +2591,10 @@ function toggleResult(
   };
 }
 
-function invokeEnable(args: RouteHandlerArgs = {}): { ok: boolean } {
-  return enableHandler(args) as { ok: boolean };
+async function invokeEnable(
+  args: RouteHandlerArgs = {},
+): Promise<{ ok: boolean }> {
+  return (await enableHandler(args)) as { ok: boolean };
 }
 
 function invokeDisable(args: RouteHandlerArgs = {}): { ok: boolean } {
@@ -2582,18 +2602,22 @@ function invokeDisable(args: RouteHandlerArgs = {}): { ok: boolean } {
 }
 
 /**
- * Wait for the toggle handlers' fire-and-forget reconcile poke to land. The
- * lazy `import()` resolves off the microtask queue, so the assertion cannot
- * run on the handler's synchronous return.
+ * Wait for a toggle handler's fire-and-forget reconcile poke to land. The poke
+ * runs off the microtask queue (the disable path also resolves a lazy
+ * `import()` first), so the assertion cannot run on the handler's synchronous
+ * return.
  */
-async function waitForScheduleReconcile(): Promise<void> {
+async function waitForReconcile(
+  spy: { mock: { calls: unknown[] } },
+  label: string,
+): Promise<void> {
   for (let i = 0; i < 50; i++) {
-    if (reconcilePluginSchedulesSpy.mock.calls.length > 0) {
+    if (spy.mock.calls.length > 0) {
       return;
     }
     await new Promise((resolve) => setTimeout(resolve, 2));
   }
-  throw new Error("plugin schedule reconcile was never triggered");
+  throw new Error(`${label} was never triggered`);
 }
 
 /** Assert the spy received exactly one sync_changed carrying `plugins:list`. */
@@ -2609,30 +2633,50 @@ describe("POST /v1/plugins/:name/enable", () => {
     enablePluginSpy.mockReset();
     broadcastMessageSpy.mockReset();
     reconcilePluginSchedulesSpy.mockClear();
+    reconcilePluginSourcesNowSpy.mockClear();
   });
 
-  test("reconciles plugin-declared schedules so the plugin's rows re-arm now", async () => {
+  test("awaits the source reconcile so a boot-disabled plugin activates before the route returns", async () => {
     enablePluginSpy.mockImplementation((name) => toggleResult(name, "enable"));
 
-    invokeEnable({ pathParams: { name: "simple-memory" } });
+    await invokeEnable({ pathParams: { name: "simple-memory" } });
+
+    // The boot scan skipped this plugin for its sentinel, so clearing the
+    // sentinel only brings its hooks, tools, MCP servers and schedules up if
+    // the source reconcile runs. The route awaits it, so by the time the
+    // response lands the reconcile has completed; it converges the schedules
+    // itself, so the route does not poke them separately.
+    expect(reconcilePluginSourcesNowSpy).toHaveBeenCalledTimes(1);
+    expect(reconcilePluginSchedulesSpy).not.toHaveBeenCalled();
+  });
+
+  test("a failed toggle does not run the source reconcile", async () => {
+    enablePluginSpy.mockImplementation((name) => {
+      throw new PluginDirectoryNotFoundError(name);
+    });
 
-    await waitForScheduleReconcile();
+    await expect(
+      invokeEnable({ pathParams: { name: "ghost" } }),
+    ).rejects.toThrow(NotFoundError);
+    expect(reconcilePluginSourcesNowSpy).not.toHaveBeenCalled();
   });
 
-  test("enables the plugin and broadcasts sync_changed(plugins:list)", () => {
+  test("enables the plugin and broadcasts sync_changed(plugins:list)", async () => {
     enablePluginSpy.mockImplementation((name) => toggleResult(name, "enable"));
 
-    const result = invokeEnable({ pathParams: { name: "simple-memory" } });
+    const result = await invokeEnable({
+      pathParams: { name: "simple-memory" },
+    });
 
     expect(result).toEqual({ ok: true });
     expect(enablePluginSpy.mock.calls[0]?.[0]).toBe("simple-memory");
     expectPluginsListBroadcast();
   });
 
-  test("threads x-vellum-client-id into the published event's originClientId", () => {
+  test("threads x-vellum-client-id into the published event's originClientId", async () => {
     enablePluginSpy.mockImplementation((name) => toggleResult(name, "enable"));
 
-    invokeEnable({
+    await invokeEnable({
       pathParams: { name: "simple-memory" },
       headers: { "x-vellum-client-id": "client-abc" },
     });
@@ -2646,7 +2690,7 @@ describe("POST /v1/plugins/:name/enable", () => {
     });
   });
 
-  test("a broadcast failure does not fail a successful toggle", () => {
+  test("a broadcast failure does not fail a successful toggle", async () => {
     enablePluginSpy.mockImplementation((name) => toggleResult(name, "enable"));
     // The sentinel was already flipped; a hub throw AFTER that must not surface
     // as a 500 — the canonical publisher swallows broadcast errors.
@@ -2654,40 +2698,42 @@ describe("POST /v1/plugins/:name/enable", () => {
       throw new Error("hub unavailable");
     });
 
-    const result = invokeEnable({ pathParams: { name: "simple-memory" } });
+    const result = await invokeEnable({
+      pathParams: { name: "simple-memory" },
+    });
     expect(result).toEqual({ ok: true });
   });
 
-  test("PluginAlreadyInStateException → ConflictError (409), no broadcast", () => {
+  test("PluginAlreadyInStateException → ConflictError (409), no broadcast", async () => {
     enablePluginSpy.mockImplementation((name) => {
       throw new PluginAlreadyInStateException(name, "enable");
     });
 
-    expect(() =>
+    await expect(
       invokeEnable({ pathParams: { name: "simple-memory" } }),
-    ).toThrow(ConflictError);
+    ).rejects.toThrow(ConflictError);
     // A no-op toggle must not fan out a spurious invalidation.
     expect(broadcastMessageSpy).not.toHaveBeenCalled();
   });
 
-  test("PluginDirectoryNotFoundError → NotFoundError (404)", () => {
+  test("PluginDirectoryNotFoundError → NotFoundError (404)", async () => {
     enablePluginSpy.mockImplementation((name) => {
       throw new PluginDirectoryNotFoundError(name);
     });
 
-    expect(() => invokeEnable({ pathParams: { name: "ghost" } })).toThrow(
-      NotFoundError,
-    );
+    await expect(
+      invokeEnable({ pathParams: { name: "ghost" } }),
+    ).rejects.toThrow(NotFoundError);
   });
 
-  test("InvalidPluginNameError → BadRequestError (400)", () => {
+  test("InvalidPluginNameError → BadRequestError (400)", async () => {
     enablePluginSpy.mockImplementation(() => {
       throw new ToggleInvalidPluginNameError("../escape");
     });
 
-    expect(() => invokeEnable({ pathParams: { name: "../escape" } })).toThrow(
-      BadRequestError,
-    );
+    await expect(
+      invokeEnable({ pathParams: { name: "../escape" } }),
+    ).rejects.toThrow(BadRequestError);
   });
 });
 
@@ -2696,6 +2742,7 @@ describe("POST /v1/plugins/:name/disable", () => {
     disablePluginSpy.mockReset();
     broadcastMessageSpy.mockReset();
     reconcilePluginSchedulesSpy.mockClear();
+    reconcilePluginSourcesNowSpy.mockClear();
   });
 
   test("reconciles plugin-declared schedules so the plugin's rows disarm now", async () => {
@@ -2706,8 +2753,14 @@ describe("POST /v1/plugins/:name/disable", () => {
     invokeDisable({ pathParams: { name: "simple-memory" } });
 
     // Without this poke the rows stay armed until the reconciler's next
-    // backstop sweep.
-    await waitForScheduleReconcile();
+    // backstop sweep. Disable stays on the schedule poke: the sentinel filters
+    // the plugin out at read time, and a source reconcile here would run its
+    // shutdown hooks.
+    await waitForReconcile(
+      reconcilePluginSchedulesSpy,
+      "plugin schedule reconcile",
+    );
+    expect(reconcilePluginSourcesNowSpy).not.toHaveBeenCalled();
   });
 
   test("a failed toggle does not poke the schedule reconcile", async () => {

package/src/runtime/routes/__tests__/surface-action-routes.test.ts

@@ -26,6 +26,10 @@ interface StubConversation {
   handleSurfaceUndoCalled?: boolean;
   handleSurfaceUndoThrows?: Error;
   trustContext?: { trustClass: string; sourceChannel: string };
+  /** Drives `isProcessing()`; the route must not stamp trust either way. */
+  processing?: boolean;
+  /** Trust the route threaded into `handleSurfaceAction`. */
+  lastRequesterTrustContext?: { trustClass: string; sourceChannel: string };
   surfaceActionCalls: Array<{
     surfaceId: string;
     actionId: string;
@@ -160,7 +164,9 @@ function makeStub(id: string): StubConversation {
       actionId: string,
       data: unknown,
       sourceActorPrincipalId?: string,
+      requesterTrustContext?: { trustClass: string; sourceChannel: string },
     ) => {
+      stub.lastRequesterTrustContext = requesterTrustContext;
       stub.surfaceActionCalls.push({
         surfaceId,
         actionId,
@@ -181,6 +187,7 @@ function makeStub(id: string): StubConversation {
     setTrustContext: (ctx: { trustClass: string; sourceChannel: string }) => {
       stub.trustContext = ctx;
     },
+    isProcessing: () => stub.processing === true,
   });
   return stub;
 }
@@ -487,8 +494,8 @@ describe("triggerSurfaceAction trust context", () => {
       headers: { "x-vellum-actor-principal-id": GUARDIAN_PRINCIPAL },
     });
 
-    expect(live.trustContext?.trustClass).toBe("guardian");
-    expect(live.trustContext?.sourceChannel).toBe("vellum");
+    expect(live.lastRequesterTrustContext?.trustClass).toBe("guardian");
+    expect(live.lastRequesterTrustContext?.sourceChannel).toBe("vellum");
     // First-pass resolve already granted guardian, so the drift helper is skipped.
     expect(reResolveCalls).toEqual([]);
   });
@@ -506,7 +513,7 @@ describe("triggerSurfaceAction trust context", () => {
     });
 
     expect(reResolveCalls).toEqual([VELLUM_PRINCIPAL_OLD]);
-    expect(live.trustContext?.trustClass).toBe("unknown");
+    expect(live.lastRequesterTrustContext?.trustClass).toBe("unknown");
   });
 
   test("reset drift: helper returns guardian → route adopts it", async () => {
@@ -522,7 +529,7 @@ describe("triggerSurfaceAction trust context", () => {
     });
 
     expect(reResolveCalls).toEqual([VELLUM_PRINCIPAL_OLD]);
-    expect(live.trustContext?.trustClass).toBe("guardian");
+    expect(live.lastRequesterTrustContext?.trustClass).toBe("guardian");
   });
 
   test("dev-bypass resolves the real guardian principal from the gateway, helper not called", async () => {
@@ -539,7 +546,7 @@ describe("triggerSurfaceAction trust context", () => {
 
     // The synthetic dev-bypass principal is translated to the real guardian,
     // yielding a guardian trust context without consulting the drift helper.
-    expect(live.trustContext?.trustClass).toBe("guardian");
+    expect(live.lastRequesterTrustContext?.trustClass).toBe("guardian");
     expect(reResolveCalls).toEqual([]);
   });
 
@@ -559,7 +566,49 @@ describe("triggerSurfaceAction trust context", () => {
       headers: { "x-vellum-actor-principal-id": "dev-bypass" },
     });
 
-    expect(live.trustContext?.trustClass).toBe("unknown");
+    expect(live.lastRequesterTrustContext?.trustClass).toBe("unknown");
+  });
+
+  test("idle conversation: the requester is threaded to the action and the slot is left to the dispatch", async () => {
+    mockGuardianList = [guardianDelivery(GUARDIAN_PRINCIPAL)];
+    const live = makeStub("conv-idle");
+    live.processing = false;
+    memoryBySurface = live;
+
+    const handler = findHandler("triggerSurfaceAction");
+    await handler({
+      body: { surfaceId: "surf-idle", actionId: "act-idle" },
+      headers: { "x-vellum-actor-principal-id": GUARDIAN_PRINCIPAL },
+    });
+
+    expect(live.lastRequesterTrustContext?.trustClass).toBe("guardian");
+    // The route resolves; `handleSurfaceAction` stamps, and only where it
+    // commits to running the turn. Stamping here would repoint the actor of a
+    // turn that starts between this call and the dispatch.
+    expect(live.trustContext).toBeUndefined();
+  });
+
+  test("busy conversation: the running turn's actor is left alone and the click still travels as its own actor", async () => {
+    mockGuardianList = [guardianDelivery(GUARDIAN_PRINCIPAL)];
+    const live = makeStub("conv-busy");
+    // A turn is already running under a different actor.
+    const runningTurnActor = {
+      trustClass: "untrusted",
+      sourceChannel: "sms",
+    };
+    live.trustContext = runningTurnActor;
+    live.processing = true;
+    memoryBySurface = live;
+
+    const handler = findHandler("triggerSurfaceAction");
+    await handler({
+      body: { surfaceId: "surf-busy", actionId: "act-busy" },
+      headers: { "x-vellum-actor-principal-id": GUARDIAN_PRINCIPAL },
+    });
+
+    // Identical object, so a re-write of an equal value still fails this.
+    expect(live.trustContext).toBe(runningTurnActor);
+    expect(live.lastRequesterTrustContext?.trustClass).toBe("guardian");
   });
 });
 

package/src/runtime/routes/__tests__/system-card-turn-termination.test.ts

@@ -0,0 +1,107 @@
+/**
+ * Tests which system cards terminate a turn.
+ *
+ * Clients treat `message_complete` as terminal: it clears the processing state
+ * and closes the turn. A card that is itself the reply (a slash-command
+ * result) must emit it; a card a plugin posts while a turn is still running
+ * must not, or the client ends a turn that is still streaming.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { setConfig } from "../../../__tests__/helpers/set-config.js";
+import type { AssistantEvent } from "../../../api/index.js";
+
+// Keep the memory system off so addMessage skips indexing side effects.
+setConfig("memory", { enabled: false });
+
+// Capture what reaches connected clients, keeping the rest of the hub's
+// surface intact for the module graph's other importers.
+const eventHub = await import("../../assistant-event-hub.js");
+const broadcastEvents: AssistantEvent[] = [];
+
+/** The terminal turn events among everything broadcast so far. */
+function completions(): AssistantEvent[] {
+  return broadcastEvents.filter((e) => e.type === "message_complete");
+}
+
+mock.module("../../assistant-event-hub.js", () => ({
+  ...eventHub,
+  broadcastMessage: (event: AssistantEvent) => {
+    broadcastEvents.push(event);
+  },
+}));
+
+const { createConversation } =
+  await import("../../../persistence/conversation-crud.js");
+const { initializeDb } = await import("../../../persistence/db-init.js");
+const { persistSystemCard } = await import("../canned-message-complete.js");
+
+await initializeDb();
+
+describe("persistSystemCard turn termination", () => {
+  beforeEach(() => {
+    broadcastEvents.length = 0;
+  });
+
+  test("announces a card that is the reply as a completed turn", async () => {
+    /**
+     * Tests that a card standing in for the assistant's reply closes the turn
+     * so the client stops showing it as processing.
+     */
+
+    // GIVEN a conversation
+    const conv = createConversation();
+
+    // WHEN a card that ends the turn is persisted
+    const card = await persistSystemCard({
+      conversationId: conv.id,
+      text: "Compacted 12 messages.",
+      metadata: {},
+      endsTurn: true,
+    });
+
+    // THEN clients are told the turn completed, pointing at the card row
+    expect(completions()).toEqual([
+      {
+        type: "message_complete",
+        conversationId: conv.id,
+        messageId: card.id,
+      },
+    ]);
+  });
+
+  test("leaves an in-flight turn running when a card is posted mid-turn", async () => {
+    /**
+     * Tests that a card written while the model is still working does not end
+     * the turn in the client, which would clear processing state and let a
+     * second message start while the first turn is still streaming.
+     */
+
+    // GIVEN a conversation
+    const conv = createConversation();
+
+    // WHEN a non-terminal card is persisted
+    const card = await persistSystemCard({
+      conversationId: conv.id,
+      text: "The image you attached was not sent to the model.",
+      metadata: { plugin: "image-fallback" },
+      endsTurn: false,
+    });
+
+    // THEN the card is persisted
+    expect(card.id).toBeTruthy();
+
+    // AND no terminal turn event reaches clients
+    expect(completions()).toEqual([]);
+
+    // AND clients are still told to refetch the transcript so the card shows
+    expect(
+      broadcastEvents.some(
+        (e) =>
+          e.type === "sync_changed" &&
+          e.tags.includes(`conversation:${conv.id}:messages`),
+      ),
+    ).toBe(true);
+  });
+});