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

package/src/__tests__/conversation-app-control-lifecycle.test.ts

@@ -13,7 +13,7 @@
  * without bringing up the full daemon stack.
  */
 
-import { describe, expect, mock, test } from "bun:test";
+import { describe, expect, mock, spyOn, test } from "bun:test";
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
@@ -70,6 +70,7 @@ mock.module("../runtime/services/auto-analysis-guard.js", () => ({
 
 import { Conversation } from "../daemon/conversation.js";
 import type { HostAppControlProxy } from "../daemon/host-app-control-proxy.js";
+import { HostCuProxy } from "../daemon/host-cu-proxy.js";
 
 /**
  * Minimal stand-in for HostAppControlProxy that records dispose() calls.
@@ -111,6 +112,57 @@ function makeConversation(): Conversation {
   return conv;
 }
 
+describe("Conversation HostCuProxy lifecycle", () => {
+  test.each(["replace", "remove"] as const)(
+    "%s disposes the prior proxy even when mode-session retirement fails",
+    async (operation) => {
+      const conversation = makeConversation();
+      const previous = new HostCuProxy();
+      const replacement =
+        operation === "replace" ? new HostCuProxy() : undefined;
+      conversation.setHostCuProxy(previous);
+      const dispose = spyOn(previous, "dispose");
+      const endTask = spyOn(
+        conversation.computerUseModeSessions,
+        "endTask",
+      ).mockImplementation(() => {
+        throw new Error("session retirement unavailable");
+      });
+      const pending = previous
+        .request(
+          "computer_use_click",
+          { element_id: 1 },
+          conversation.conversationId,
+          1,
+          "Clicking the button",
+        )
+        .catch((error: unknown) => error);
+      try {
+        expect(() => conversation.setHostCuProxy(previous)).not.toThrow();
+        expect(endTask).not.toHaveBeenCalled();
+        expect(() => conversation.setHostCuProxy(replacement)).not.toThrow();
+        expect(await pending).toMatchObject({
+          message: "Host CU proxy disposed",
+        });
+        expect(endTask).toHaveBeenCalledWith({
+          turnId: conversation.currentRequestId,
+          source: {
+            sourceId: previous.sourceId,
+            generation: previous.resetGeneration,
+          },
+        });
+        expect(dispose).toHaveBeenCalledTimes(1);
+        expect(conversation.hostCuProxy).toBe(replacement);
+      } finally {
+        endTask.mockRestore();
+        dispose.mockRestore();
+        previous.dispose();
+        replacement?.dispose();
+      }
+    },
+  );
+});
+
 describe("Conversation — HostAppControlProxy lifecycle", () => {
   test("setHostAppControlProxy stores the proxy", () => {
     const conversation = makeConversation();

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

@@ -4,18 +4,9 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // Stub it so eviction tests run without a real manager: no protected children
 // by default, and abortAllForParent records the conversations it was called for.
 const abortedParents: string[] = [];
-let protectedChildren: Array<{ status: string }> = [];
 mock.module("../subagent/index.js", () => ({
   getSubagentManager: () => ({
     abortAllForParent: (id: string) => abortedParents.push(id),
-    getChildrenOf: () => protectedChildren,
-    hasActiveChildren: () =>
-      protectedChildren.some(
-        (c) =>
-          c.status === "running" ||
-          c.status === "pending" ||
-          c.status === "awaiting_input",
-      ),
   }),
 }));
 
@@ -30,11 +21,8 @@ function createMockSession(
 ): EvictableConversation & { disposed: boolean } {
   return {
     disposed: false,
-    isProcessing() {
-      return processing;
-    },
-    hasQueuedMessages() {
-      return queued;
+    hasInFlightWork() {
+      return processing || queued;
     },
     dispose() {
       this.disposed = true;
@@ -48,7 +36,6 @@ describe("ConversationEvictor", () => {
 
   beforeEach(() => {
     abortedParents.length = 0;
-    protectedChildren = [];
     sessions = new Map();
     evictor = new ConversationEvictor(
       sessions as Map<string, EvictableConversation>,
@@ -124,6 +111,19 @@ describe("ConversationEvictor", () => {
       expect(sessions.has("a")).toBe(true);
       expect(s1.disposed).toBe(false);
     });
+
+    test("skips conversations with resident mode-session work", () => {
+      const session = createMockSession();
+      session.hasInFlightWork = () => true;
+      sessions.set("mode-active", session);
+
+      const result = evictor.sweep();
+
+      expect(result.ttlEvicted).toBe(0);
+      expect(result.skipped).toBe(1);
+      expect(sessions.has("mode-active")).toBe(true);
+      expect(session.disposed).toBe(false);
+    });
   });
 
   describe("LRU eviction", () => {
@@ -217,43 +217,68 @@ describe("ConversationEvictor", () => {
       expect(s0.disposed).toBe(false);
       expect(s1.disposed).toBe(true);
     });
-  });
 
-  describe("onEvict", () => {
-    test("aborts subagents for each evicted session", () => {
-      const s1 = createMockSession();
-      sessions.set("a", s1);
-      // Never touched — will be TTL evicted
+    test("skips resident mode-session work during LRU eviction", () => {
+      const protectedSession = createMockSession();
+      protectedSession.hasInFlightWork = () => true;
+      const evictable = createMockSession();
+      const fresh1 = createMockSession();
+      const fresh2 = createMockSession();
+      sessions.set("mode-active", protectedSession);
+      sessions.set("evictable", evictable);
+      sessions.set("fresh-1", fresh1);
+      sessions.set("fresh-2", fresh2);
 
-      evictor.sweep();
+      const lastAccess = (
+        evictor as unknown as { lastAccess: Map<string, number> }
+      ).lastAccess;
+      const now = Date.now();
+      lastAccess.set("mode-active", now - 50);
+      lastAccess.set("evictable", now - 40);
+      lastAccess.set("fresh-1", now);
+      lastAccess.set("fresh-2", now);
 
-      expect(abortedParents).toEqual(["a"]);
+      const result = evictor.sweep();
+
+      expect(result.lruEvicted).toBe(1);
+      expect(sessions.has("mode-active")).toBe(true);
+      expect(sessions.has("evictable")).toBe(false);
+      expect(protectedSession.disposed).toBe(false);
     });
   });
 
-  describe("shouldProtect", () => {
-    test("skips conversations with running or pending subagents", () => {
-      protectedChildren = [{ status: "running" }];
-      const s1 = createMockSession();
-      sessions.set("a", s1);
+  describe("memory-pressure eviction", () => {
+    test("keeps resident mode-session work while evicting idle conversations", () => {
+      const resident = createMockSession();
+      resident.hasInFlightWork = () => true;
+      const idle = createMockSession();
+      sessions.set("mode-active", resident);
+      sessions.set("idle", idle);
+      evictor = new ConversationEvictor(sessions, {
+        ttlMs: Number.MAX_SAFE_INTEGER,
+        maxConversations: Number.MAX_SAFE_INTEGER,
+        memoryThresholdBytes: 0,
+      });
 
       const result = evictor.sweep();
 
-      expect(result.skipped).toBe(1);
-      expect(sessions.has("a")).toBe(true);
-      expect(s1.disposed).toBe(false);
+      expect(result.memoryEvicted).toBe(1);
+      expect(sessions.has("mode-active")).toBe(true);
+      expect(sessions.has("idle")).toBe(false);
+      expect(resident.disposed).toBe(false);
+      expect(idle.disposed).toBe(true);
     });
+  });
 
-    test("skips conversations with awaiting_input subagents", () => {
-      protectedChildren = [{ status: "awaiting_input" }];
+  describe("onEvict", () => {
+    test("aborts subagents for each evicted session", () => {
       const s1 = createMockSession();
       sessions.set("a", s1);
+      // Never touched, so it will be TTL evicted.
 
-      const result = evictor.sweep();
+      evictor.sweep();
 
-      expect(result.skipped).toBe(1);
-      expect(sessions.has("a")).toBe(true);
-      expect(s1.disposed).toBe(false);
+      expect(abortedParents).toEqual(["a"]);
     });
   });
 

package/src/__tests__/conversation-history-boundary-repair-failure.test.ts

@@ -0,0 +1,174 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../plugins/defaults/memory/indexer.js", () => ({
+  MIN_SEGMENT_CHARS: 50,
+  indexMessageNow: async () => ({ indexedSegments: 0, enqueuedJobs: 0 }),
+  enqueueBackfillJob: () => "",
+  enqueueRebuildIndexJob: () => "",
+}));
+
+import { consolidateAssistantMessages } from "../daemon/conversation-history.js";
+import {
+  addMessage,
+  createConversation,
+  deleteLastExchange,
+  getMessages,
+} from "../persistence/conversation-crud.js";
+import {
+  beginConversationModeSession,
+  updateConversationModeSessionBoundaries,
+} from "../persistence/conversation-mode-sessions.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+
+await initializeDb();
+
+const FAIL_REPAIR_TRIGGER = "fail_mode_session_boundary_repair";
+
+function installFailingBoundaryRepairTrigger(): void {
+  getDb().run(/* sql */ `
+    CREATE TRIGGER ${FAIL_REPAIR_TRIGGER}
+    BEFORE UPDATE ON conversation_mode_sessions
+    BEGIN
+      SELECT RAISE(ABORT, 'injected boundary repair failure');
+    END
+  `);
+}
+
+afterEach(() => {
+  getDb().run(`DROP TRIGGER IF EXISTS ${FAIL_REPAIR_TRIGGER}`);
+});
+
+describe("message deletion mode-session boundary repair failures", () => {
+  test("consolidation deletes every donor without duplicating copied content", async () => {
+    const conversation = createConversation("Boundary repair consolidation");
+    const sessionId = `session-${conversation.id}`;
+    const owner = { id: sessionId, mode: "browser" as const };
+    const sourceStartedAt = Date.now() - 10_000;
+    expect(
+      beginConversationModeSession({
+        id: sessionId,
+        conversationId: conversation.id,
+        mode: owner.mode,
+        sourceStartedAt,
+      }),
+    ).toMatchObject({ ok: true });
+
+    const user = await addMessage(conversation.id, "user", "Run the tool");
+    const retained = await addMessage(
+      conversation.id,
+      "assistant",
+      JSON.stringify([
+        { type: "tool_use", id: "tool-1", name: "example", input: {} },
+      ]),
+      { metadata: { modeSession: owner } },
+    );
+    const toolResult = await addMessage(
+      conversation.id,
+      "user",
+      JSON.stringify([
+        { type: "tool_result", tool_use_id: "tool-1", content: "done" },
+      ]),
+      { metadata: { modeSession: owner } },
+    );
+    const donor = await addMessage(
+      conversation.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Finished once." }]),
+      { metadata: { modeSession: owner } },
+    );
+    expect(
+      updateConversationModeSessionBoundaries({
+        id: sessionId,
+        conversationId: conversation.id,
+        expectedRevision: 1,
+        firstIncluded: {
+          at: retained.createdAt,
+          messageId: retained.id,
+        },
+        lastActivityAt: donor.createdAt,
+        lastOwnedMessageId: donor.id,
+      }),
+    ).toMatchObject({ ok: true });
+    installFailingBoundaryRepairTrigger();
+
+    expect(consolidateAssistantMessages(conversation.id, user.id)).toBe(true);
+    const rows = getMessages(conversation.id);
+    expect(rows.map((row) => row.id)).toEqual([user.id, retained.id]);
+    const retainedContent = rows[1]!.content;
+    expect(retainedContent).toEqual([
+      { type: "tool_use", id: "tool-1", name: "example", input: {} },
+      { type: "text", text: "Finished once." },
+      { type: "tool_result", tool_use_id: "tool-1", content: "done" },
+    ]);
+
+    expect(consolidateAssistantMessages(conversation.id, user.id)).toBe(false);
+    expect(getMessages(conversation.id)[1]!.content).toEqual(retainedContent);
+    expect(
+      getMessages(conversation.id).some((row) => row.id === donor.id),
+    ).toBe(false);
+    expect(
+      getMessages(conversation.id).some((row) => row.id === toolResult.id),
+    ).toBe(false);
+  });
+
+  test("tail deletion returns its committed count when boundary repair fails", async () => {
+    const conversation = createConversation("Boundary repair tail delete");
+    const sessionId = `session-${conversation.id}`;
+    const owner = { id: sessionId, mode: "browser" as const };
+    expect(
+      beginConversationModeSession({
+        id: sessionId,
+        conversationId: conversation.id,
+        mode: owner.mode,
+        sourceStartedAt: Date.now() - 10_000,
+      }),
+    ).toMatchObject({ ok: true });
+    const keptUser = await addMessage(conversation.id, "user", "Keep this");
+    const keptAssistant = await addMessage(
+      conversation.id,
+      "assistant",
+      "Kept reply",
+    );
+    const deletedUser = await addMessage(
+      conversation.id,
+      "user",
+      "Delete this",
+      { metadata: { modeSession: owner } },
+    );
+    const deletedAssistant = await addMessage(
+      conversation.id,
+      "assistant",
+      "Deleted reply",
+      { metadata: { modeSession: owner } },
+    );
+    expect(
+      updateConversationModeSessionBoundaries({
+        id: sessionId,
+        conversationId: conversation.id,
+        expectedRevision: 1,
+        firstIncluded: {
+          at: deletedAssistant.createdAt,
+          messageId: deletedAssistant.id,
+        },
+        lastActivityAt: deletedAssistant.createdAt,
+        lastOwnedMessageId: deletedAssistant.id,
+      }),
+    ).toMatchObject({ ok: true });
+    installFailingBoundaryRepairTrigger();
+
+    expect(deleteLastExchange(conversation.id)).toBe(2);
+    expect(getMessages(conversation.id).map((row) => row.id)).toEqual([
+      keptUser.id,
+      keptAssistant.id,
+    ]);
+    expect(
+      getMessages(conversation.id).some((row) => row.id === deletedUser.id),
+    ).toBe(false);
+    expect(
+      getMessages(conversation.id).some(
+        (row) => row.id === deletedAssistant.id,
+      ),
+    ).toBe(false);
+  });
+});

package/src/__tests__/conversation-loop-db-lock-resilience.test.ts

@@ -89,6 +89,7 @@ import {
   handleMessageComplete,
 } from "../daemon/conversation-agent-loop-handlers.js";
 import { getConversationPersistedSeq } from "../persistence/conversation-crud.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 const CONVERSATION_ID = "test-session-id";
 
@@ -101,6 +102,7 @@ function createMockDeps(): EventHandlerDeps {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (_msg: AssistantEvent) => {},
     reqId: "test-req-id",

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

@@ -87,6 +87,7 @@ import {
   type QueuedMessage,
 } from "../daemon/conversation-queue-manager.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 // ---------------------------------------------------------------------------
 // Fake context — captures preactivation calls, satisfies the bare minimum
@@ -117,6 +118,7 @@ function makeFakeContext(opts: {
     abortController: null,
     queue: opts.queue,
     surfaceActionRequestIds: new Set<string>(),
+    modeSessions: mockUnownedModeSessions(),
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     get preactivatedSkillIds(): string[] | undefined {
       return preactivatedSkillIds;

package/src/__tests__/conversation-retry-route.test.ts

@@ -197,6 +197,7 @@ function makeConversation(opts: { processing?: boolean } = {}) {
   const emitActivityState = mock(
     (_phase: string, _reason: string, _options?: unknown) => {},
   );
+  const invalidateAllStructuralWaits = mock(() => 0);
   const conversation = {
     conversationId: "conv-retry-test",
     trustContext: undefined,
@@ -209,6 +210,7 @@ function makeConversation(opts: { processing?: boolean } = {}) {
     loadFromDb,
     runAgentLoop,
     emitActivityState,
+    modeSessions: { invalidateAllStructuralWaits },
   };
   return {
     conversation,
@@ -217,6 +219,7 @@ function makeConversation(opts: { processing?: boolean } = {}) {
     loadFromDb,
     runAgentLoop,
     emitActivityState,
+    invalidateAllStructuralWaits,
   };
 }
 
@@ -264,6 +267,24 @@ beforeEach(() => {
 });
 
 describe("POST /v1/conversations/:id/retry", () => {
+  test("tracking invalidation failure does not prevent retry", async () => {
+    const ctx = makeConversation();
+    activeConversation = ctx.conversation;
+    ctx.invalidateAllStructuralWaits.mockImplementation(() => {
+      throw new Error("session tracking unavailable");
+    });
+    const res = await callHandler(
+      retryHandler,
+      makeRequest(),
+      { id: "conv-retry-test" },
+      202,
+    );
+    expect(res.status).toBe(202);
+    await settle();
+    expect(discardMock).toHaveBeenCalledTimes(1);
+    expect(ctx.runAgentLoop).toHaveBeenCalledTimes(1);
+  });
+
   test("202s, discards the tail, and re-runs the loop from the anchor", async () => {
     const ctx = makeConversation();
     activeConversation = ctx.conversation;
@@ -299,6 +320,7 @@ describe("POST /v1/conversations/:id/retry", () => {
     expect(ctx.conversation.isProcessing()).toBe(true);
     expect(ctx.conversation.abortController).not.toBeNull();
     expect(discardMock).toHaveBeenCalledWith("conv-retry-test");
+    expect(ctx.invalidateAllStructuralWaits).toHaveBeenCalledTimes(1);
 
     // Origin-less invalidation: the initiating client reconciles too.
     expect(publishConversationMessagesChangedMock).toHaveBeenCalledTimes(1);

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -32,6 +32,7 @@ import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 import { setConfig } from "./helpers/set-config.js";
 
 const testDir = process.env.VELLUM_WORKSPACE_DIR!;
@@ -88,6 +89,7 @@ function createFakeConversation(conversationId: string): Conversation {
     conversationId,
     processing: false,
     currentRequestId: undefined as string | undefined,
+    modeSessions: mockUnownedModeSessions(),
     abortController: null as AbortController | null,
     trustContext: undefined as unknown,
     turnChannelContext: null as {

package/src/__tests__/conversation-routes-enabled-plugins.test.ts

@@ -135,6 +135,7 @@ mock.module("../ipc/gateway-client.js", () => ({
 import { getEffectiveEnabledPluginSet } from "../daemon/conversation-tool-setup.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 function makeConversation() {
   const runAgentLoop = mock(async () => undefined);
@@ -156,6 +157,7 @@ function makeConversation() {
     },
     abortController: null,
     currentRequestId: undefined,
+    modeSessions: mockUnownedModeSessions(),
     queue: { length: 0 },
     setTrustContext: () => {},
     replayActivityState: () => {},

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -113,6 +113,7 @@ mock.module("../contacts/guardian-delivery-reader.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-guardian",
@@ -185,6 +186,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -275,6 +277,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -353,6 +356,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -442,6 +446,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -529,6 +534,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -612,6 +618,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -689,6 +696,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -768,6 +776,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -848,6 +857,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {

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

@@ -126,6 +126,7 @@ import {
 import * as pendingInteractions from "../runtime/pending-interactions.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 CONV_ID = "conv-hidden-queue";
 
@@ -159,6 +160,7 @@ function makeConversationWithPendingConfirmation(
       },
     },
     currentRequestId: undefined,
+    modeSessions: mockUnownedModeSessions(),
     queue: {
       length: 0,
       promoteToHead: (requestId: string) => ({ requestId }),

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -166,6 +166,7 @@ import { CONVERSATION_BUSY_MESSAGE } from "../daemon/conversation-messaging.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-guardian",
@@ -233,6 +234,7 @@ function makeConversation() {
     messages,
     abortController: null,
     currentRequestId: undefined,
+    modeSessions: mockUnownedModeSessions(),
     queue: { length: 0 },
     setTrustContext: () => {},
     replayActivityState: () => {},

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -673,6 +673,35 @@ describe("injectChannelCapabilityContext", () => {
     const text = (result.content[0] as { type: "text"; text: string }).text;
     expect(text).not.toContain("Do NOT use markdown tables");
   });
+
+  test("injects email send CLI constraint for email channel", () => {
+    const caps: ChannelCapabilities = {
+      channel: "email",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+
+    const result = injectChannelCapabilityContext(baseUserMessage, caps);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("Conversation text is not emailed");
+    expect(text).toContain("assistant email send");
+    expect(text).toContain("--reply-to");
+  });
+
+  test("does NOT inject email send CLI constraint for non-email channels", () => {
+    const caps: ChannelCapabilities = {
+      channel: "telegram",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+
+    const result = injectChannelCapabilityContext(baseUserMessage, caps);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).not.toContain("Conversation text is not emailed");
+    expect(text).not.toContain("assistant email send");
+  });
 });
 
 // ---------------------------------------------------------------------------