@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/__tests__/config-schema.test.ts

@@ -952,11 +952,7 @@ describe("AssistantConfigSchema", () => {
         enabled: true,
         text: 'At the very beginning of the call, introduce yourself as an assistant calling on behalf of the person you represent. Do not say "AI assistant".',
       },
-      safety: {
-        denyCategories: [],
-      },
       voice: {
-        interruptSensitivity: "low",
         telephonyStreaming: true,
         utteranceEndMs: 1000,
       },
@@ -978,7 +974,6 @@ describe("AssistantConfigSchema", () => {
         maxDurationSeconds: 1800,
         userConsultTimeoutSeconds: 60,
         disclosure: { enabled: false, text: "Custom disclosure" },
-        safety: { denyCategories: ["spam"] },
       },
     });
     expect(result.calls.enabled).toBe(false);
@@ -986,7 +981,6 @@ describe("AssistantConfigSchema", () => {
     expect(result.calls.userConsultTimeoutSeconds).toBe(60);
     expect(result.calls.disclosure.enabled).toBe(false);
     expect(result.calls.disclosure.text).toBe("Custom disclosure");
-    expect(result.calls.safety.denyCategories).toEqual(["spam"]);
   });
 
   // ── Live voice config ───────────────────────────────────────────────
@@ -994,7 +988,6 @@ describe("AssistantConfigSchema", () => {
   test("applies liveVoice defaults", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.liveVoice).toEqual({
-      mode: "open-mic",
       vad: {
         speechEnergyThreshold: 800,
         noiseFloorMargin: 3,
@@ -1005,6 +998,18 @@ describe("AssistantConfigSchema", () => {
         echoEmaHalfLifeMs: 400,
         echoDrainSlackMs: 300,
       },
+      flux: {
+        turnEnd: { enabled: true },
+        eotThreshold: 0.7,
+        eotTimeoutMs: 5000,
+      },
+      archiveAudio: false,
+    });
+  });
+
+  test("applies voice defaults", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.voice).toEqual({
       frontModel: {
         endpointDecisionTimeoutMs: 1200,
         endpointExtensionMs: 1500,
@@ -1019,35 +1024,24 @@ describe("AssistantConfigSchema", () => {
           generationTimeoutMs: 1500,
         },
       },
-      flux: {
-        turnEnd: { enabled: true },
-        eotThreshold: 0.7,
-        eotTimeoutMs: 5000,
-      },
-      maxSessionDurationSeconds: 1800,
-      archiveAudio: false,
     });
   });
 
   test("accepts valid liveVoice config overrides", () => {
     const result = AssistantConfigSchema.parse({
       liveVoice: {
-        mode: "ptt",
         vad: {
           speechEnergyThreshold: 1500,
           silenceThresholdMs: 1000,
           bargeInMinSpeechMs: 120,
         },
-        maxSessionDurationSeconds: 900,
       },
     });
-    expect(result.liveVoice.mode).toBe("ptt");
     expect(result.liveVoice.vad.speechEnergyThreshold).toBe(1500);
     expect(result.liveVoice.vad.silenceThresholdMs).toBe(1000);
     expect(result.liveVoice.vad.bargeInMinSpeechMs).toBe(120);
     // Unspecified vad fields still get defaults
     expect(result.liveVoice.vad.maxTurnDurationMs).toBe(30000);
-    expect(result.liveVoice.maxSessionDurationSeconds).toBe(900);
     // A partial liveVoice override leaves Flux turn-end disabled by default.
     expect(result.liveVoice.flux.turnEnd.enabled).toBe(true);
   });
@@ -1136,18 +1130,10 @@ describe("AssistantConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
-  test("rejects non-array calls.safety.denyCategories", () => {
-    const result = AssistantConfigSchema.safeParse({
-      calls: { safety: { denyCategories: "spam" } },
-    });
-    expect(result.success).toBe(false);
-  });
-
   // ── Calls voice config ──────────────────────────────────────────────
 
   test("config without calls.voice parses correctly and produces defaults", () => {
     const result = AssistantConfigSchema.parse({});
-    expect(result.calls.voice.interruptSensitivity).toBe("low");
     expect(result.calls.voice.telephonyStreaming).toBe(true);
     expect(result.calls.voice.utteranceEndMs).toBe(1000);
   });
@@ -1165,9 +1151,23 @@ describe("AssistantConfigSchema", () => {
     expect(result.calls.voice.utteranceEndMs).toBe(2500);
   });
 
+  test("persisted calls configs carrying retired keys keep parsing", () => {
+    // Zod strips unrecognized keys, so a persisted config that still carries
+    // `calls.safety.denyCategories` or `calls.voice.interruptSensitivity`
+    // parses.
+    const result = AssistantConfigSchema.parse({
+      calls: {
+        safety: { denyCategories: ["spam"] },
+        voice: { interruptSensitivity: "high" },
+      },
+    });
+    expect(result.calls).not.toHaveProperty("safety");
+    expect(result.calls.voice).not.toHaveProperty("interruptSensitivity");
+  });
+
   test("language is no longer part of the voice config schema", () => {
-    // The retired knob was read by nothing; Zod strips the unrecognized key
-    // so persisted configs that still carry it keep parsing.
+    // Zod strips the unrecognized key, so persisted configs that still carry
+    // it parse.
     const result = AssistantConfigSchema.parse({
       calls: { voice: { language: "es-ES" } },
     });
@@ -2633,7 +2633,6 @@ describe("loadConfig with schema validation", () => {
     expect(config.calls.maxDurationSeconds).toBe(3600);
     expect(config.calls.userConsultTimeoutSeconds).toBe(120);
     expect(config.calls.disclosure.enabled).toBe(true);
-    expect(config.calls.safety.denyCategories).toEqual([]);
     expect(
       (config.calls.voice as Record<string, unknown>).language,
     ).toBeUndefined();

package/src/__tests__/config-watcher.test.ts

@@ -113,8 +113,11 @@ mock.module("../providers/registry.js", () => ({
   resolveProviderFromConnection: async () => null,
 }));
 
+let mcpReloadCallCount = 0;
 mock.module("../daemon/mcp-reload-service.js", () => ({
-  reloadMcpServers: async () => {},
+  reloadMcpServers: async () => {
+    mcpReloadCallCount += 1;
+  },
 }));
 
 mock.module("../signals/conversation-undo.js", () => ({
@@ -154,10 +157,6 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
   },
 }));
 
-mock.module("../daemon/skill-memory-refresh.js", () => ({
-  refreshSkillCapabilityMemories: () => {},
-}));
-
 mock.module("../platform/sync-identity.js", () => ({
   syncIdentityNameToPlatform: () => {},
 }));
@@ -183,6 +182,7 @@ function findFileWatch(filePath: string): CapturedFileWatch | undefined {
 
 const WORKSPACE_FILES = new Set([
   "config.json",
+  "mcp.json",
   "SOUL.md",
   "IDENTITY.md",
   "ui/theme.json",
@@ -239,6 +239,7 @@ beforeEach(() => {
   evictCallCount = 0;
   identityCallCount = 0;
   themeCallCount = 0;
+  mcpReloadCallCount = 0;
   watcher = new ConfigWatcher(undefined, TEST_DEBOUNCE_MS);
 });
 
@@ -270,9 +271,9 @@ describe("ConfigWatcher workspace file handlers", () => {
 
   test("unregistered workspace files are not subscribed (only the registered handler set is)", () => {
     watcher.start();
-    // Per-file watching only registers config.json, SOUL.md, IDENTITY.md,
-    // and ui/theme.json. The whole workspace dir must not be watched
-    // either — that was the ENXIO-on-Unix-sockets bug.
+    // Per-file watching only registers config.json, mcp.json, SOUL.md,
+    // IDENTITY.md, and ui/theme.json. The whole workspace dir must not
+    // be watched either: that was the ENXIO-on-Unix-sockets bug.
     expect(findFileWatch(join(WORKSPACE_DIR, "OTHER.md"))).toBeUndefined();
     expect(findWatcher(WORKSPACE_DIR)).toBeUndefined();
   });
@@ -285,6 +286,14 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(0);
   });
 
+  test("mcp.json change reloads MCP servers without evicting conversations", async () => {
+    watcher.start();
+    simulateFileChange(WORKSPACE_DIR, "mcp.json");
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(mcpReloadCallCount).toBe(1);
+    expect(evictCallCount).toBe(0);
+  });
+
   test("config.json change calls refreshConfigFromSources", async () => {
     let refreshCalled = false;
     watcher.refreshConfigFromSources = async () => {
@@ -332,6 +341,12 @@ describe("ConfigWatcher watcher lifecycle", () => {
     expect(findFileWatch(join(WORKSPACE_DIR, "IDENTITY.md"))).toBeDefined();
   });
 
+  test("start does not watch the skills directory", () => {
+    mkdirSync(join(WORKSPACE_DIR, "skills"), { recursive: true });
+    watcher.start();
+    expect(findWatcher(join(WORKSPACE_DIR, "skills"))).toBeUndefined();
+  });
+
   test("stop cancels pending debounce work, no eviction fires after", async () => {
     watcher.start();
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");

package/src/__tests__/connection-model-compat.test.ts

@@ -19,7 +19,7 @@ describe("isConnectionCompatibleWithModel", () => {
     expect(
       isConnectionCompatibleWithModel(
         { auth: { type: "oauth_subscription" } as never },
-        "gpt-5.4",
+        "gpt-5.5",
       ),
     ).toBe(true);
   });
@@ -79,7 +79,7 @@ describe("describeSubscriptionModelIncompatibility", () => {
 
   test("returns null when model is Codex-compatible", () => {
     expect(
-      describeSubscriptionModelIncompatibility([subscriptionConn], "gpt-5.4"),
+      describeSubscriptionModelIncompatibility([subscriptionConn], "gpt-5.5"),
     ).toBeNull();
   });
 });

package/src/__tests__/conversation-key-store-disk-view.test.ts

@@ -59,7 +59,7 @@ describe("conversation-key-store disk view", () => {
 
     const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
     expect(meta.id).toBe(first.conversationId);
-    expect(meta.title).toBe("Generating title...");
+    expect(meta.title).toBe("conversation.title.generating");
     expect(meta.type).toBe("standard");
     expect(meta.channel).toBeNull();
     expect(readdirSync(conversationsDir)).toEqual([expectedDirName]);

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

@@ -901,6 +901,32 @@ describe("pairDeliveryWithConversation", () => {
   // body has to land there for that button to open something that contains
   // the notification the user tapped.
 
+  test("assistant reply keeps the source conversation without appending its preview", async () => {
+    mockExistingConversations["conv-user-chat"] = {
+      id: "conv-user-chat",
+      source: "user",
+      title: "An ordinary chat",
+    };
+    const signal = makeSignal({
+      requiresConversation: undefined,
+      sourceContextId: "conv-user-chat",
+      sourceEventName: "chat.assistant_reply",
+    });
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "vellum" as NotificationChannel,
+      makeCopy({ body: "A short push preview…" }),
+    );
+
+    expect(result.conversationId).toBe("conv-user-chat");
+    expect(result.messageId).toBeNull();
+    expect(result.createdNewConversation).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).not.toHaveBeenCalled();
+    expect(messagesInvalidated).toEqual([]);
+  });
+
   test("passive vellum signal appends the body to the producing conversation", async () => {
     mockExistingConversations["conv-producer"] = {
       id: "conv-producer",

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -161,12 +161,6 @@ function makeFakeContext(opts: {
       trustClass: "guardian" as const,
       guardianPrincipalId: "user-1",
     },
-    setTrustContext(
-      this: { trustContext?: TrustContext },
-      trustContext: TrustContext | null,
-    ) {
-      this.trustContext = trustContext ?? undefined;
-    },
     setTransportHints() {},
     applyHostEnvFromTransport() {},
     ensureHostProxiesForTurn() {},
@@ -415,10 +409,10 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       "U-contact",
     );
     expect(ctx.currentTurnTrustContext?.sourceChannel).toBe("slack");
-    // The drain is where a queued message commits to a run, so the resting
-    // slot names the sender too: history is scoped from it, and a slot still
-    // naming the guardian would hand the contact's turn the guardian's rows.
-    expect(ctx.trustContext).toBe(contactTrust);
+    // The slot itself is left alone; only the turn's view is corrected. A
+    // drain stamping it would attribute the conversation to a sender whose
+    // turn can still lose the processing lock at persist time.
+    expect(ctx.trustContext?.trustClass).toBe("guardian");
   });
 
   test("buildPassthroughBatch refuses to coalesce two channel senders", async () => {

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

@@ -450,17 +450,6 @@ async function waitForCondition(
   }
 }
 
-/** Count the history reloads a conversation performs from this point on. */
-function countHistoryReloads(conversation: Conversation): () => number {
-  const originalLoad = conversation.loadFromDb.bind(conversation);
-  let reloads = 0;
-  conversation.loadFromDb = async () => {
-    reloads++;
-    return originalLoad();
-  };
-  return () => reloads;
-}
-
 /**
  * Resolve the Nth pending AgentLoop.run() call. Fires the minimal events
  * that `runAgentLoop` expects (usage + message_complete) so the conversation
@@ -726,22 +715,21 @@ describe("Conversation message queue", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("a drained turn commits its sender as the resting actor and re-scopes history", async () => {
-    // A contact's channel turn leaves the resting slot, and the resident
-    // history scoped from it, naming the contact. The guardian's message
-    // queued behind that turn must run as the guardian everywhere the slot is
-    // read, not only in the per-turn snapshot: the `<turn_context>` actor
-    // section is derived at turn start and history is scoped from the slot,
-    // so a drain that stamped only the snapshot rendered the guardian's own
-    // web turn as a trusted contact's and hid the guardian's rows from it.
+  test("the turn-context actor section describes the turn's actor, not the conversation's resting actor", async () => {
+    // The drain carries its sender on the per-turn field and leaves the
+    // resting slot naming the previous actor. The actor section is frozen at
+    // turn start, so it has to read the turn's actor: reading the slot is what
+    // told the guardian's own drained turn it was talking to a trusted
+    // contact.
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.setTrustContext({
-      trustClass: "trusted_contact",
-      sourceChannel: "slack",
+    const contact = {
+      trustClass: "trusted_contact" as const,
+      sourceChannel: "slack" as const,
       requesterExternalUserId: "U-contact",
-    });
+    };
+    conversation.setTrustContext(contact);
 
     const p1 = conversation.processMessage({
       content: "msg-1",
@@ -756,7 +744,6 @@ describe("Conversation message queue", () => {
       sourceChannel: "vellum" as const,
       requesterExternalUserId: "guardian-principal",
     };
-    const reloads = countHistoryReloads(conversation);
     conversation.enqueueMessage({
       content: "msg-2",
       requestId: "req-2",
@@ -767,83 +754,30 @@ describe("Conversation message queue", () => {
     await p1;
     await waitForPendingRun(2);
 
-    // Read while run 2 is in flight: the slot, the snapshot, and the frozen
-    // actor section all describe the guardian, and the history was reloaded
-    // for that scope exactly once.
-    expect(conversation.getTrustContext()).toBe(guardian);
+    // Guard the test itself: the slot must disagree with the turn, or the
+    // assertion below passes for the wrong reason.
+    expect(conversation.getTrustContext()).toBe(contact);
     expect(conversation.currentTurnTrustContext).toBe(guardian);
+    // A guardian turn renders no actor section, whatever the slot says.
     expect(conversation.currentTurnInboundActorContext).toBeNull();
-    expect(reloads()).toBe(1);
 
     await resolveRun(1);
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("a batched drain commits the head's sender as the resting actor", async () => {
-    // Same commitment on the batched path, which coalesces only messages that
-    // share a trust identity, so the head's sender is the batch's actor.
+  test("the actor section names the drained contact while the slot holds the guardian", async () => {
+    // The inverse direction, so the assertion above cannot pass merely because
+    // the section is always absent: a contact's message drained behind the
+    // guardian's turn must be described as that contact.
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.setTrustContext({
-      trustClass: "trusted_contact",
-      sourceChannel: "slack",
-      requesterExternalUserId: "U-contact",
-    });
-
-    const p1 = conversation.processMessage({
-      content: "msg-1",
-      attachments: [],
-      onEvent: () => {},
-      requestId: "req-1",
-    });
-    await waitForPendingRun(1);
-
     const guardian = {
       trustClass: "guardian" as const,
       sourceChannel: "vellum" as const,
       requesterExternalUserId: "guardian-principal",
     };
-    const reloads = countHistoryReloads(conversation);
-    conversation.enqueueMessage({
-      content: "msg-2",
-      requestId: "req-2",
-      trustContext: guardian,
-    });
-    conversation.enqueueMessage({
-      content: "msg-3",
-      requestId: "req-3",
-      trustContext: guardian,
-    });
-
-    await resolveRun(0);
-    await p1;
-    await waitForPendingRun(2);
-
-    // One batched run for both siblings, committed as the guardian.
-    expect(pendingRuns.length).toBe(2);
-    expect(conversation.getTrustContext()).toBe(guardian);
-    expect(conversation.currentTurnTrustContext).toBe(guardian);
-    expect(conversation.currentTurnInboundActorContext).toBeNull();
-    expect(reloads()).toBe(1);
-
-    await resolveRun(1);
-    await new Promise((r) => setTimeout(r, 10));
-  });
-
-  test("a drained turn keeps its sender when the slot moves during the history reload", async () => {
-    // The commit captures the sender before the reload awaits. A writer that
-    // moves the slot inside that await (a wake's stamp, a pointer elevation)
-    // must not become the turn's actor: the history was reloaded for the
-    // sender, and running someone else's trust over it is the escalation.
-    const conversation = makeConversation();
-    await conversation.loadFromDb();
-
-    conversation.setTrustContext({
-      trustClass: "trusted_contact",
-      sourceChannel: "slack",
-      requesterExternalUserId: "U-contact",
-    });
+    conversation.setTrustContext(guardian);
 
     const p1 = conversation.processMessage({
       content: "msg-1",
@@ -853,49 +787,39 @@ describe("Conversation message queue", () => {
     });
     await waitForPendingRun(1);
 
-    const guardian = {
-      trustClass: "guardian" as const,
-      sourceChannel: "vellum" as const,
-      requesterExternalUserId: "guardian-principal",
-    };
-    const intruder = {
-      trustClass: "unknown" as const,
-      sourceChannel: "telegram" as const,
-      requesterExternalUserId: "T-stranger",
+    const contact = {
+      trustClass: "trusted_contact" as const,
+      sourceChannel: "slack" as const,
+      requesterExternalUserId: "U-contact",
     };
     conversation.enqueueMessage({
       content: "msg-2",
       requestId: "req-2",
-      trustContext: guardian,
+      trustContext: contact,
     });
 
-    // The drain's reload is the await the writer lands inside.
-    const originalLoad = conversation.loadFromDb.bind(conversation);
-    let movedDuringReload = false;
-    conversation.loadFromDb = async () => {
-      const result = await originalLoad();
-      conversation.setTrustContext(intruder);
-      movedDuringReload = true;
-      return result;
-    };
-
     await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
-    expect(movedDuringReload).toBe(true);
-    expect(conversation.getTrustContext()).toBe(intruder);
-    expect(conversation.currentTurnTrustContext).toBe(guardian);
-    expect(conversation.currentTurnInboundActorContext).toBeNull();
+    expect(conversation.getTrustContext()).toBe(guardian);
+    expect(conversation.currentTurnTrustContext).toBe(contact);
+    expect(conversation.currentTurnInboundActorContext).toMatchObject({
+      trustClass: "trusted_contact",
+      sourceChannel: "slack",
+      canonicalActorIdentity: "U-contact",
+    });
 
     await resolveRun(1);
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("a drain whose history reload fails puts the resting actor back", async () => {
-    // A reload that fails starts no turn: the message is requeued for the
-    // next drain, so the slot must not keep naming a sender whose turn never
-    // began, or conversation-level readers report an owner that is not there.
+  test("a processMessage turn whose history reload fails puts the resting actor back", async () => {
+    // `processMessage` is the commitment point, so it stamps the slot before
+    // scoping history. A reload that throws starts no turn, and leaving the
+    // stamp would attribute the conversation to a sender that never ran: an
+    // actorless dispatch afterwards (a deferred wake) resolves the resting
+    // slot and would inherit it.
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
@@ -906,110 +830,27 @@ describe("Conversation message queue", () => {
     };
     conversation.setTrustContext(contact);
 
-    const p1 = conversation.processMessage({
-      content: "msg-1",
-      attachments: [],
-      onEvent: () => {},
-      requestId: "req-1",
-    });
-    await waitForPendingRun(1);
-
-    const guardian = {
-      trustClass: "guardian" as const,
-      sourceChannel: "vellum" as const,
-      requesterExternalUserId: "guardian-principal",
-    };
-    conversation.enqueueMessage({
-      content: "msg-2",
-      requestId: "req-2",
-      trustContext: guardian,
-    });
-
-    let reloadAttempts = 0;
     conversation.loadFromDb = async () => {
-      reloadAttempts++;
       throw new Error("history store exploded");
     };
 
-    // Finish the first turn; the drain (and its one retry) fail on the reload.
-    await resolveRun(0);
-    await p1;
-    await waitForCondition(() => reloadAttempts >= 2);
-    await new Promise((r) => setTimeout(r, 20));
-
-    expect(pendingRuns.length).toBe(1);
-    expect(conversation.getQueueDepth()).toBe(1);
-    expect(conversation.getTrustContext()).toBe(contact);
-  });
-
-  test("the turn-context actor section follows the turn's actor when the slot moves before the loop opens", async () => {
-    // The actor section is frozen at turn start from the turn's own actor,
-    // not from the resting slot. The drain stamps the slot and then awaits
-    // (persist) before the loop opens; an out-of-band writer landing in that
-    // window (pointer elevation restore, a wake's restore) moves the slot
-    // without owning the turn, and a read of the slot there would describe
-    // that writer's actor to the model.
-    const conversation = makeConversation();
-    await conversation.loadFromDb();
-
-    const contact = {
-      trustClass: "trusted_contact" as const,
-      sourceChannel: "slack" as const,
-      requesterExternalUserId: "U-contact",
-    };
-    conversation.setTrustContext(contact);
-
-    const p1 = conversation.processMessage({
-      content: "msg-1",
-      attachments: [],
-      onEvent: () => {},
-      requestId: "req-1",
-    });
-    await waitForPendingRun(1);
-
     const guardian = {
       trustClass: "guardian" as const,
       sourceChannel: "vellum" as const,
       requesterExternalUserId: "guardian-principal",
     };
-    conversation.enqueueMessage({
-      content: "msg-2",
-      requestId: "req-2",
-      trustContext: guardian,
-    });
-
-    // Land the out-of-band slot write inside the drain's window, after its
-    // stamp and before the loop opens: the drain awaits persistUserMessage
-    // there. The resting slot alone is moved; the per-turn snapshot is the
-    // drain's to carry into the run.
-    const originalPersist = conversation.persistUserMessage.bind(conversation);
-    let slotMoved = false;
-    (
-      conversation as unknown as {
-        persistUserMessage: typeof conversation.persistUserMessage;
-      }
-    ).persistUserMessage = async (opts) => {
-      const result = await originalPersist(opts);
-      conversation.setTrustContext(contact);
-      slotMoved = true;
-      return result;
-    };
-
-    await resolveRun(0);
-    await p1;
-    await waitForPendingRun(2);
+    await expect(
+      conversation.processMessage({
+        content: "msg-1",
+        attachments: [],
+        onEvent: () => {},
+        requestId: "req-1",
+        trustContext: guardian,
+      }),
+    ).rejects.toThrow("history store exploded");
 
-    // Guard the test itself: the injection must have run, and the slot must
-    // disagree with the turn, or the assertion below passes for the wrong
-    // reason.
-    expect(slotMoved).toBe(true);
     expect(conversation.getTrustContext()).toBe(contact);
-    expect(conversation.currentTurnTrustContext).toBe(guardian);
-    // The guardian's turn renders no actor section, whatever the slot says.
-    expect(conversation.currentTurnInboundActorContext).toBeNull();
-
-    await resolveRun(1);
-    await new Promise((r) => setTimeout(r, 10));
+    expect(pendingRuns.length).toBe(0);
   });
 
   test("a processMessage turn keeps its turn-start trust when the slot moves before the loop opens", async () => {