@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/__tests__/evict-conversations-for-reload.test.ts

@@ -6,10 +6,10 @@
  * has to hold here: `isProcessing()` reads false in the window between a turn
  * releasing and its queued successor being dispatched.
  *
- * In-flight subagents are the other non-idle case: an async spawn leaves the
- * parent idle between its own tool calls while children are still running.
- * Reload marks that parent stale without aborting the children, then
- * `getOrCreateConversation` rebuilds it once every child is terminal.
+ * In-flight subagents and resident mode-session state are other non-idle
+ * cases. Reload marks the conversation stale without discarding that state,
+ * then `getOrCreateConversation` rebuilds it once every retained lifecycle is
+ * settled.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -26,7 +26,7 @@ mock.module("../subagent/index.js", () => ({
   }),
 }));
 
-import type { Conversation } from "../daemon/conversation.js";
+import { Conversation } from "../daemon/conversation.js";
 import {
   clearConversations,
   conversationIds,
@@ -45,17 +45,29 @@ interface FakeConversation {
 
 function register(
   id: string,
-  state: { processing: boolean; queued: boolean; stale?: boolean },
+  state: {
+    processing: boolean;
+    queued: boolean;
+    modeSessionWork?: boolean;
+    stale?: boolean;
+  },
 ): FakeConversation {
   const fake: FakeConversation & Record<string, unknown> = {
     disposed: false,
     markedStale: false,
     conversationId: id,
+    liveVoiceResidencyLeases: 0,
     isProcessing: () => state.processing,
     hasQueuedMessages: () => state.queued,
+    modeSessions: {
+      hasResidentWork: () => state.modeSessionWork === true,
+    },
     isStale: () => state.stale === true || fake.markedStale,
-    hasInFlightWork: () =>
-      state.processing || state.queued || activeParents.has(id),
+    hasInFlightWork() {
+      return Conversation.prototype.hasInFlightWork.call(
+        fake as unknown as Conversation,
+      );
+    },
     dispose() {
       fake.disposed = true;
     },
@@ -125,6 +137,43 @@ describe("evictConversationsForReload", () => {
     expect(abortedParents).toEqual([]);
   });
 
+  test("keeps resident mode-session ownership usable across reload eviction", () => {
+    const resident = register("reload-mode-active", {
+      processing: false,
+      queued: false,
+      modeSessionWork: true,
+    });
+
+    evictConversationsForReload();
+
+    expect(resident.disposed).toBe(false);
+    expect(resident.markedStale).toBe(true);
+    expect(findConversation("reload-mode-active")).toBeDefined();
+    expect(abortedParents).toEqual([]);
+  });
+
+  test("keeps a Live voice residency lease until the socket releases it", () => {
+    const resident = register("reload-live-voice", {
+      processing: false,
+      queued: false,
+    });
+    const release = Conversation.prototype.acquireLiveVoiceResidency.call(
+      resident as unknown as Conversation,
+    );
+
+    evictConversationsForReload();
+
+    expect(resident.disposed).toBe(false);
+    expect(resident.markedStale).toBe(true);
+    expect(findConversation("reload-live-voice")).toBeDefined();
+
+    release();
+    evictConversationsForReload();
+
+    expect(resident.disposed).toBe(true);
+    expect(findConversation("reload-live-voice")).toBeUndefined();
+  });
+
   test("still evicts other idle conversations when one parent is protected", () => {
     const protectedParent = register("reload-protected", {
       processing: false,

package/src/__tests__/guardian-action-sweep.test.ts

@@ -73,6 +73,22 @@ describe("sendGuardianExpiryNotices", () => {
     expect(deliveredMessages[1].body.chatId).toBe("chat-456");
   });
 
+  test("opens the guardian's DM for a Discord delivery addressed to their user id", async () => {
+    await sendGuardianExpiryNotices(
+      [
+        makeDelivery({
+          destinationChannel: "discord",
+          destinationChatId: "111111111111111111",
+        }),
+      ],
+      "assistant-1",
+    );
+
+    expect(deliveredMessages).toHaveLength(1);
+    expect(deliveredMessages[0].url).toBe("/deliver/discord?dm=1");
+    expect(deliveredMessages[0].body.chatId).toBe("111111111111111111");
+  });
+
   test("skips deliveries that are not sent or pending", async () => {
     await sendGuardianExpiryNotices(
       [

package/src/__tests__/guardian-dispatch.test.ts

@@ -158,6 +158,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -209,6 +210,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -238,6 +240,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -282,6 +285,7 @@ describe("guardian-dispatch", () => {
     };
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -324,6 +328,7 @@ describe("guardian-dispatch", () => {
     };
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -369,6 +374,7 @@ describe("guardian-dispatch", () => {
     };
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -396,6 +402,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -431,6 +438,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -456,6 +464,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -488,6 +497,7 @@ describe("guardian-dispatch", () => {
     const sharedConversationId = "conv-shared-guardian";
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -576,6 +586,7 @@ describe("guardian-dispatch", () => {
     const sharedConversationId = "conv-affinity-guardian";
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -648,6 +659,7 @@ describe("guardian-dispatch", () => {
     const sharedConversationId = "conv-affinity-tool-guardian";
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -727,6 +739,7 @@ describe("guardian-dispatch", () => {
     const sharedConversationId = "conv-affinity-triple";
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",

package/src/__tests__/headless-browser-interactions.test.ts

@@ -163,7 +163,7 @@ function resetMockPage() {
  */
 function defaultCdpHandler(
   method: string,
-  _params: Record<string, unknown> | undefined,
+  params: Record<string, unknown> | undefined,
 ): unknown {
   switch (method) {
     case "DOM.getDocument":
@@ -177,12 +177,28 @@ function defaultCdpHandler(
     case "Runtime.evaluate":
       return { result: { value: { w: 800, h: 600 } } };
     case "Runtime.callFunctionOn":
+      if (
+        params?.returnByValue === true &&
+        String(params.functionDeclaration).includes("isConnected")
+      ) {
+        return {
+          result: { value: { connected: true, matches: true } },
+        };
+      }
+      if (
+        params?.returnByValue === true &&
+        String(params.functionDeclaration).includes("clearFirst")
+      ) {
+        return { result: { value: { needsRefocus: false } } };
+      }
       // executeBrowserSelectOption invokes a function that returns
       // a `matched` boolean — default to true so wrapper-contract
       // tests don't need to know the inner select-option matching
       // shape. Tests that exercise the no-match path override the
       // handler explicitly.
       return { result: { value: true } };
+    case "Input.insertText":
+      return {};
     default:
       return {};
   }
@@ -485,20 +501,21 @@ describe("executeBrowserType", () => {
     expect(result.content).toContain('Typed into element: element_id "e3"');
     expect(result.content).toContain("cleared existing content");
 
-    // Expected CDP sequence when resolving by backendNodeId + clearFirst:
-    //   DOM.focus → DOM.resolveNode → Runtime.callFunctionOn (clear) →
-    //   DOM.focus → Input.insertText
+    // The editor selection precedes insertion, and a live-node read verifies
+    // that the requested text persisted.
     const methods = sendCalls.map((c) => c.method);
     expect(methods).toEqual([
       "DOM.focus",
       "DOM.resolveNode",
       "Runtime.callFunctionOn",
-      "DOM.focus",
       "Input.insertText",
+      "Runtime.callFunctionOn",
     ]);
     const focusCall = sendCalls[0]!;
     expect(focusCall.params).toEqual({ backendNodeId: 555 });
-    const insertCall = sendCalls[sendCalls.length - 1]!;
+    const insertCall = sendCalls.find(
+      (call) => call.method === "Input.insertText",
+    )!;
     expect(insertCall.params).toEqual({ text: "hello" });
   });
 
@@ -524,11 +541,10 @@ describe("executeBrowserType", () => {
     );
     expect(result.isError).toBe(false);
     expect(result.content).not.toContain("cleared");
-    // clear_first=false skips DOM.resolveNode + Runtime.callFunctionOn
-    // and the re-focus call, so we should see focus + insertText only.
+    // Append mode collapses the editor selection at the end before insertion.
     const methods = sendCalls.map((c) => c.method);
-    expect(methods).not.toContain("DOM.resolveNode");
-    expect(methods).not.toContain("Runtime.callFunctionOn");
+    expect(methods).toContain("DOM.resolveNode");
+    expect(methods).toContain("Runtime.callFunctionOn");
     const focusCount = methods.filter((m) => m === "DOM.focus").length;
     expect(focusCount).toBe(1);
     expect(methods).toContain("Input.insertText");
@@ -542,22 +558,22 @@ describe("executeBrowserType", () => {
     expect(result.isError).toBe(false);
     expect(result.content).toContain("pressed Enter");
     const methods = sendCalls.map((c) => c.method);
-    // Input.insertText must come before the Enter keyDown/char/keyUp.
+    // Input.insertText must come before the Enter rawKeyDown/char/keyUp.
     const insertIdx = methods.indexOf("Input.insertText");
     const keyDownIdx = methods.findIndex(
       (m, i) =>
         m === "Input.dispatchKeyEvent" &&
-        (sendCalls[i]!.params as { type: string }).type === "keyDown",
+        (sendCalls[i]!.params as { type: string }).type === "rawKeyDown",
     );
     expect(insertIdx).toBeGreaterThanOrEqual(0);
     expect(keyDownIdx).toBeGreaterThan(insertIdx);
-    // Enter is text-producing → keyDown + char + keyUp.
+    // Enter is text-producing, so it emits rawKeyDown + char + keyUp.
     const keyEvents = sendCalls.filter(
       (c) => c.method === "Input.dispatchKeyEvent",
     );
     expect(keyEvents).toHaveLength(3);
     expect((keyEvents[0]!.params as { key: string }).key).toBe("Enter");
-    expect((keyEvents[0]!.params as { type: string }).type).toBe("keyDown");
+    expect((keyEvents[0]!.params as { type: string }).type).toBe("rawKeyDown");
     expect((keyEvents[1]!.params as { type: string }).type).toBe("char");
     expect((keyEvents[2]!.params as { type: string }).type).toBe("keyUp");
   });
@@ -689,7 +705,7 @@ describe("executeBrowserPressKey", () => {
     expect(result.content).toContain('Pressed "Enter"');
     // No target => no DOM.focus, no selector resolution. Enter is a
     // text-producing key (text "\r") so dispatchKeyPress emits
-    // keyDown + char + keyUp.
+    // rawKeyDown + char + keyUp.
     const methods = sendCalls.map((c) => c.method);
     expect(methods).toEqual([
       "Input.dispatchKeyEvent",
@@ -699,7 +715,7 @@ describe("executeBrowserPressKey", () => {
     const keyDown = sendCalls[0]!.params as Record<string, unknown>;
     const charEvt = sendCalls[1]!.params as Record<string, unknown>;
     const keyUp = sendCalls[2]!.params as Record<string, unknown>;
-    expect(keyDown.type).toBe("keyDown");
+    expect(keyDown.type).toBe("rawKeyDown");
     expect(keyDown.key).toBe("Enter");
     expect(keyDown.windowsVirtualKeyCode).toBe(13);
     expect(charEvt.type).toBe("char");
@@ -707,6 +723,36 @@ describe("executeBrowserPressKey", () => {
     expect(keyUp.key).toBe("Enter");
   });
 
+  test("presses modifier chords on the focused element", async () => {
+    const result = await executeBrowserPressKey({ key: "Meta+v" }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Pressed "Meta+v"');
+
+    const keyEvents = sendCalls.filter(
+      (call) => call.method === "Input.dispatchKeyEvent",
+    );
+    expect(keyEvents).toHaveLength(4);
+    expect(keyEvents[0]!.params).toMatchObject({
+      type: "rawKeyDown",
+      key: "Meta",
+      modifiers: 4,
+    });
+    expect(keyEvents[1]!.params).toMatchObject({
+      type: "rawKeyDown",
+      key: "v",
+      modifiers: 4,
+    });
+    expect(keyEvents[2]!.params).toMatchObject({
+      type: "keyUp",
+      key: "v",
+      modifiers: 4,
+    });
+    expect(keyEvents[3]!.params).toMatchObject({
+      type: "keyUp",
+      key: "Meta",
+    });
+  });
+
   test("presses key on targeted element via element_id", async () => {
     snapshotBackendNodeMaps.set("test-conversation", new Map([["e5", 555]]));
     const result = await executeBrowserPressKey(
@@ -716,14 +762,12 @@ describe("executeBrowserPressKey", () => {
     expect(result.isError).toBe(false);
     expect(result.content).toContain('Pressed "Tab" on element');
     expect(result.content).toContain('element_id "e5"');
-    // Backend-resolved path: focus → dispatchKeyEvent × 3 (Tab is
-    // text-producing so we also dispatch a char event).
+    // Backend-resolved path: focus, then Tab key down and key up.
     const methods = sendCalls.map((c) => c.method);
     expect(methods).toEqual([
       "DOM.focus",
       "Input.dispatchKeyEvent",
       "Input.dispatchKeyEvent",
-      "Input.dispatchKeyEvent",
     ]);
     expect(sendCalls[0]!.params).toEqual({ backendNodeId: 555 });
   });
@@ -767,7 +811,7 @@ describe("executeBrowserPressKey", () => {
 
   test("surfaces CDP failure as a press-key error", async () => {
     sendHandler = () => new Error("Key not recognized");
-    const result = await executeBrowserPressKey({ key: "InvalidKey" }, ctx);
+    const result = await executeBrowserPressKey({ key: "Enter" }, ctx);
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Press key failed");
     expect(result.content).toContain("Key not recognized");

package/src/__tests__/heartbeat-service.test.ts

@@ -334,11 +334,10 @@ const SCAFFOLD_PERSONA = stripCommentLines(GUARDIAN_PERSONA_TEMPLATE).trim();
 const { resolveCallSiteConfig } = await import("../config/llm-resolver.js");
 const { LLMSchema } = await import("../config/schemas/llm.js");
 
-// Capture broadcastMessage so tests can observe the alerts and
-// conversation-created events the heartbeat service emits directly.
+// Capture broadcastMessage so tests can observe the conversation-created
+// events the heartbeat service emits directly.
 type BroadcastedMessage = { type: string; [key: string]: unknown };
 const broadcastedMessages: BroadcastedMessage[] = [];
-let onBroadcast: ((msg: BroadcastedMessage) => void) | null = null;
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
@@ -347,7 +346,6 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   },
   broadcastMessage: (msg: BroadcastedMessage) => {
     broadcastedMessages.push(msg);
-    onBroadcast?.(msg);
   },
 }));
 
@@ -357,7 +355,6 @@ describe("HeartbeatService", () => {
     content: string;
     options?: { callSite?: string };
   }>;
-  let alerterCalls: Array<{ type: string; title: string; body: string }>;
 
   afterEach(() => {
     // Clean up workspace files between tests so file-existence tests don't leak
@@ -368,13 +365,7 @@ describe("HeartbeatService", () => {
 
   beforeEach(() => {
     processMessageCalls = [];
-    alerterCalls = [];
     broadcastedMessages.length = 0;
-    onBroadcast = (msg) => {
-      if (msg.type === "heartbeat_alert") {
-        alerterCalls.push(msg as { type: string; title: string; body: string });
-      }
-    };
     createdConversations.length = 0;
     conversationIdCounter = 0;
     mockStoredMessages.length = 0;
@@ -693,21 +684,6 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls).toHaveLength(1);
   });
 
-  test("alerts on processMessage failure", async () => {
-    const service = createService({
-      processMessage: async () => {
-        throw new Error("LLM timeout");
-      },
-    });
-
-    await service.runOnce();
-
-    expect(alerterCalls).toHaveLength(1);
-    expect(alerterCalls[0].type).toBe("heartbeat_alert");
-    expect(alerterCalls[0].title).toBe("Heartbeat Failed");
-    expect(alerterCalls[0].body).toBe("LLM timeout");
-  });
-
   test("successful run updates lastRunAt and nextRunAt", async () => {
     const service = createService();
     expect(service.lastRunAt).toBeNull();
@@ -724,24 +700,6 @@ describe("HeartbeatService", () => {
     );
   });
 
-  test("alerts on conversation creation failure", async () => {
-    // Override createConversation to throw via a fresh import trick:
-    // Since createConversation is mocked at module level, we simulate
-    // this by having processMessage throw before it's called — but the
-    // real fix is that executeRun wraps createConversation in the try/catch.
-    // We verify by checking that any error in executeRun triggers the alert.
-    const service = createService({
-      processMessage: async () => {
-        throw new Error("DB locked");
-      },
-    });
-
-    await service.runOnce();
-
-    expect(alerterCalls).toHaveLength(1);
-    expect(alerterCalls[0].body).toBe("DB locked");
-  });
-
   test("resetTimer() pushes nextRunAt forward", () => {
     const service = createService();
     service.start();
@@ -1467,21 +1425,6 @@ describe("HeartbeatService", () => {
       });
     });
 
-    test("CAS false suppresses failure alerter and feed event", async () => {
-      mockCompleteHeartbeatRun.mockImplementation(() => false);
-
-      const service = createService({
-        processMessage: async () => {
-          throw new Error("LLM timeout");
-        },
-      });
-
-      await service.runOnce();
-
-      // completeHeartbeatRun returned false, so alerter should NOT be called
-      expect(alerterCalls).toHaveLength(0);
-    });
-
     test("active-hours skip calls skipHeartbeatRun", async () => {
       setHeartbeatConfig({ activeHoursStart: 9, activeHoursEnd: 17 });
 

package/src/__tests__/helpers/mock-conversation.ts

@@ -18,6 +18,26 @@
 import type { Conversation } from "../../daemon/conversation.js";
 import type { ChannelCapabilities } from "../../daemon/conversation-runtime-assembly.js";
 
+/** Build a coordinator double representing a turn with no mode owner. */
+export function mockUnownedModeSessions(): Conversation["modeSessions"] {
+  return {
+    acceptTurn: () => undefined,
+    getTurnOwner: () => undefined,
+    getTerminalDisposition: () => undefined,
+    hasResidentWork: () => false,
+    keepsSessionOpenAfterTurn: () => false,
+    trackPersistedRow: () => false,
+    recordStructuralWait: () => false,
+    invalidateStructuralWait: () => false,
+    settleStructuralWait: () => false,
+    invalidateAllStructuralWaits: () => 0,
+    beginDraining: () => false,
+    finalizeTurn: () => false,
+    releaseTurn: () => {},
+    transferTurn: () => undefined,
+  } as unknown as Conversation["modeSessions"];
+}
+
 /**
  * `TExtra` carries test-only fields a double hangs off the same object
  * (recorded calls, captured messages) through to the return type, so a caller
@@ -38,6 +58,7 @@ export function asConversation<TExtra extends object = object>(
       merged.currentTurnTrustContext ?? merged.trustContext,
     isStale: () => false,
     hasInFlightWork: () => false,
+    modeSessions: mockUnownedModeSessions(),
     ...mock,
   };
   return merged as unknown as Conversation & TExtra;

package/src/__tests__/helpers/native-web-search-harness.ts

@@ -20,6 +20,7 @@ import type {
   EventHandlerState,
 } from "../../daemon/conversation-agent-loop-handlers.js";
 import { dispatchAgentEvent } from "../../daemon/conversation-agent-loop-handlers.js";
+import { mockUnownedModeSessions } from "./mock-conversation.js";
 
 /** A `tool_result` `AssistantEvent` emitted by the handler. */
 export type ToolResultEvent = Extract<AssistantEvent, { type: "tool_result" }>;
@@ -59,6 +60,7 @@ export function createHandlerDeps(reqId = "req-web-search"): HandlerHarness {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (msg: AssistantEvent) => events.push(msg),
     reqId,

package/src/__tests__/helpers/verification-sessions-ipc-sim.ts

@@ -276,6 +276,11 @@ export function createOutboundSessionGuarded(
     }
     source.status = "revoked";
     source.updatedAt = Date.now();
+    // Like the gateway, the replacement keeps the claimed session's purpose.
+    return createOutboundSession({
+      ...createParams,
+      verificationPurpose: source.verificationPurpose,
+    });
   }
 
   return createOutboundSession(createParams);

package/src/__tests__/host-cu-proxy.test.ts

@@ -464,6 +464,43 @@ describe("HostCuProxy", () => {
       const result = await resultPromise;
       expect(result.isError).toBe(false);
     });
+
+    test("runs the lifecycle callback only for a validated dispatch", async () => {
+      setup(0);
+      const rejectedCallback = mock(() => {});
+      proxy.recordAction("computer_use_click", { element_id: 1 });
+      const rejected = await proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        proxy.stepCount,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        rejectedCallback,
+      );
+      expect(rejected.isError).toBe(true);
+      expect(rejectedCallback).not.toHaveBeenCalled();
+
+      setup();
+      const acceptedCallback = mock(() => {});
+      const pending = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        acceptedCallback,
+      );
+      expect(acceptedCallback).toHaveBeenCalledTimes(1);
+      const requestId = (sentMessages[0] as { requestId: string }).requestId;
+      proxy.processObservation(requestId, { executionResult: "Clicked" });
+      await pending;
+    });
   });
 
   // -------------------------------------------------------------------------
@@ -1333,7 +1370,13 @@ describe("HostCuProxy", () => {
       proxy.processObservation(requestId, { axTree: "Button [1]" });
       await resultPromise;
 
-      proxy.endTask("session-1");
+      const sourceId = proxy.sourceId;
+      expect(sourceId).not.toBe("");
+      expect(proxy.resetGeneration).toBe(0);
+
+      expect(proxy.endTask("session-1")).toBe(0);
+      expect(proxy.sourceId).toBe(sourceId);
+      expect(proxy.resetGeneration).toBe(1);
       const cancels = sentMessages.filter(
         (m) => (m as Record<string, unknown>).type === "host_cu_cancel",
       ) as Array<Record<string, unknown>>;
@@ -1341,7 +1384,8 @@ describe("HostCuProxy", () => {
       expect(cancels[0].conversationId).toBe("session-1");
       expect(cancels[0].requestId).not.toBe(requestId);
 
-      proxy.endTask("session-1");
+      expect(proxy.endTask("session-1")).toBe(1);
+      expect(proxy.resetGeneration).toBe(2);
       expect(
         sentMessages.filter(
           (m) => (m as Record<string, unknown>).type === "host_cu_cancel",

package/src/__tests__/http-user-message-parity.test.ts

@@ -161,6 +161,7 @@ mock.module("../runtime/trust-context-resolver.js", () => ({
 import type { AuthContext } from "../runtime/auth/types.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 const _testAuthContext: AuthContext = {
   subject: "actor:self:test-actor",
@@ -194,6 +195,7 @@ function makeConversation(overrides: Record<string, unknown> = {}) {
     setHostCuProxy: () => {},
     setHostAppControlProxy: () => {},
     addPreactivatedSkillId: () => {},
+    modeSessions: mockUnownedModeSessions(),
     emitConfirmationStateChanged: () => {},
     emitActivityState: () => {},
     setTurnChannelContext: () => {},