@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

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

@@ -103,6 +103,7 @@ mock.module("../daemon/date-context.js", () => ({
   formatTurnTimestamp: () => FIXED_TURN_TIMESTAMP,
 }));
 
+import type { SurfaceDataByType } from "../api/surfaces.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { LLMSchema } from "../config/schemas/llm.js";
 import { REFUSAL_FALLBACK_TEXT } from "../context/refusal-quarantine.js";
@@ -136,7 +137,7 @@ import {
   stripInjectionsForCompaction,
   stripNowScratchpad,
 } from "../daemon/conversation-runtime-assembly.js";
-import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
+import type { SurfaceStateEntry } from "../daemon/conversation-surface-state.js";
 import { buildPkbReminder } from "../daemon/pkb-reminder-builder.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import {
@@ -161,6 +162,7 @@ import { wrapUntrustedContent } from "../security/untrusted-content.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { SubagentState } from "../subagent/types.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block by
 // reading the live conversation's persisted message rows, so the schema must
@@ -215,27 +217,30 @@ function seedActiveSurfaceConversation(
   conversationId: string,
   workspaceText: string,
   surfaceId: string,
-  data: SurfaceData,
+  data: SurfaceDataByType["dynamic_page"],
   channelCapabilities?: ChannelCapabilities,
   commandIntent?: { type: string; payload?: string; languageCode?: string },
   currentTurnTemporalSnapshot?: {
     clientTimezone: string | null;
+    timeSinceLastMessage: string | null;
   },
 ): void {
-  setConversation(conversationId, {
+  setConversation(
     conversationId,
-    workingDir: "/sandbox",
-    workspaceTopLevelContext: workspaceText,
-    workspaceTopLevelDirty: false,
-    currentActiveSurfaceId: surfaceId,
-    surfaceState: new Map<
-      string,
-      { surfaceType: SurfaceType; data: SurfaceData }
-    >([[surfaceId, { surfaceType: "dynamic_page", data }]]),
-    channelCapabilities: channelCapabilities ?? undefined,
-    commandIntent,
-    currentTurnTemporalSnapshot,
-  } as never);
+    asConversation({
+      conversationId,
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: workspaceText,
+      workspaceTopLevelDirty: false,
+      currentActiveSurfaceId: surfaceId,
+      surfaceState: new Map<string, SurfaceStateEntry>([
+        [surfaceId, { surfaceType: "dynamic_page", data }],
+      ]),
+      channelCapabilities: channelCapabilities ?? undefined,
+      commandIntent,
+      currentTurnTemporalSnapshot,
+    }),
+  );
 }
 
 function clearWorkspaceContext(): void {
@@ -252,15 +257,18 @@ function seedChannelCapabilitiesConversation(
   caps: ChannelCapabilities | null,
   transportHints?: string[],
 ): void {
-  setConversation("runtime-assembly-fallback", {
-    conversationId: "runtime-assembly-fallback",
-    workingDir: "/sandbox",
-    workspaceTopLevelContext: "",
-    workspaceTopLevelDirty: false,
-    surfaceState: new Map(),
-    channelCapabilities: caps ?? undefined,
-    transportHints,
-  } as never);
+  setConversation(
+    "runtime-assembly-fallback",
+    asConversation({
+      conversationId: "runtime-assembly-fallback",
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      surfaceState: new Map(),
+      channelCapabilities: caps ?? undefined,
+      transportHints,
+    }),
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -986,6 +994,7 @@ describe("applyRuntimeInjections — injection mode", () => {
       { type: "start" },
       {
         clientTimezone: null,
+        timeSinceLastMessage: null,
       },
     );
   });
@@ -1023,15 +1032,18 @@ describe("applyRuntimeInjections — injection mode", () => {
     // rehydration-order tests in conversation-lifecycle.test.ts). background-turn
     // fires only for a background/scheduled live conversation, so register one
     // under the turn's conversation id.
-    setConversation("injection-mode-conv", {
-      conversationId: "injection-mode-conv",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      channelCapabilities,
-      conversationType: "background",
-    } as never);
+    setConversation(
+      "injection-mode-conv",
+      asConversation({
+        conversationId: "injection-mode-conv",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        channelCapabilities,
+        conversationType: "background",
+      }),
+    );
 
     const { blocks } = await applyRuntimeInjections(baseMessages, fullOptions);
 
@@ -2227,20 +2239,24 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
   // context (so the injector sources the interface label to match
   // `sampleOptions.interfaceName`).
   function seedTemporalSnapshot(): void {
-    setConversation("runtime-assembly-fallback", {
-      conversationId: "runtime-assembly-fallback",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      currentTurnTemporalSnapshot: {
-        clientTimezone: null,
-      },
-      currentTurnInterfaceContext: {
-        userMessageInterface: "macos",
-        assistantMessageInterface: "macos",
-      },
-    } as never);
+    setConversation(
+      "runtime-assembly-fallback",
+      asConversation({
+        conversationId: "runtime-assembly-fallback",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        currentTurnTemporalSnapshot: {
+          clientTimezone: null,
+          timeSinceLastMessage: null,
+        },
+        currentTurnInterfaceContext: {
+          userMessageInterface: "macos",
+          assistantMessageInterface: "macos",
+        },
+      }),
+    );
   }
 
   test("injects the turn-context block when the inputs are provided", async () => {
@@ -2327,17 +2343,20 @@ describe("applyRuntimeInjections timezone resolution", () => {
     clientTimezone: string | null,
     timeSinceLastMessage: string | null = null,
   ): void {
-    setConversation("runtime-assembly-fallback", {
-      conversationId: "runtime-assembly-fallback",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      currentTurnTemporalSnapshot: {
-        clientTimezone,
-        timeSinceLastMessage,
-      },
-    } as never);
+    setConversation(
+      "runtime-assembly-fallback",
+      asConversation({
+        conversationId: "runtime-assembly-fallback",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        currentTurnTemporalSnapshot: {
+          clientTimezone,
+          timeSinceLastMessage,
+        },
+      }),
+    );
   }
 
   function injectedText(result: { messages: Message[] }): string {
@@ -2491,20 +2510,24 @@ describe("applyRuntimeInjections blocks.unifiedTurnContext", () => {
   // context (so the injector sources the interface label to match
   // `sampleOptions.interfaceName`).
   function seedTemporalSnapshot(): void {
-    setConversation("runtime-assembly-fallback", {
-      conversationId: "runtime-assembly-fallback",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      currentTurnTemporalSnapshot: {
-        clientTimezone: null,
-      },
-      currentTurnInterfaceContext: {
-        userMessageInterface: "macos",
-        assistantMessageInterface: "macos",
-      },
-    } as never);
+    setConversation(
+      "runtime-assembly-fallback",
+      asConversation({
+        conversationId: "runtime-assembly-fallback",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        currentTurnTemporalSnapshot: {
+          clientTimezone: null,
+          timeSinceLastMessage: null,
+        },
+        currentTurnInterfaceContext: {
+          userMessageInterface: "macos",
+          assistantMessageInterface: "macos",
+        },
+      }),
+    );
   }
 
   test("captures unifiedTurnContext when tail is a user message", async () => {
@@ -2688,15 +2711,18 @@ describe("applyRuntimeInjections — subagent status", () => {
   // a fallback fake carrying that delegation for the seeded children to
   // surface.
   beforeEach(() => {
-    setConversation(FALLBACK_CONVERSATION_ID, {
-      conversationId: FALLBACK_CONVERSATION_ID,
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      getSubagentChildren: () =>
-        getSubagentManager().getChildrenOf(FALLBACK_CONVERSATION_ID),
-    } as never);
+    setConversation(
+      FALLBACK_CONVERSATION_ID,
+      asConversation({
+        conversationId: FALLBACK_CONVERSATION_ID,
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        getSubagentChildren: () =>
+          getSubagentManager().getChildrenOf(FALLBACK_CONVERSATION_ID),
+      }),
+    );
   });
 
   afterEach(() => {
@@ -2750,14 +2776,17 @@ describe("applyRuntimeInjections — subagent status", () => {
 
   test("skips subagent status when the conversation is itself a subagent", async () => {
     // GIVEN the live conversation is itself a subagent (no nesting)
-    setConversation("runtime-assembly-fallback", {
-      conversationId: "runtime-assembly-fallback",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      isSubagent: true,
-    } as never);
+    setConversation(
+      "runtime-assembly-fallback",
+      asConversation({
+        conversationId: "runtime-assembly-fallback",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        isSubagent: true,
+      }),
+    );
     // AND a child is registered under its id
     seedSubagentChild(
       "runtime-assembly-fallback",
@@ -3995,6 +4024,59 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     expect(allText).not.toContain("private guardian-only context");
   });
 
+  // Slack builds provider history from rows rather than `this.messages`, so a
+  // guardian card dropped only at `Conversation.loadFromDb` would still reach
+  // the model here -- the channel the incident happened on.
+  test("loadSlackChronologicalContext drops guardian card rows", () => {
+    const caps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const cardRow: MessageRow = {
+      id: "m-card",
+      conversationId: "conv-1",
+      role: "assistant",
+      content: [
+        {
+          type: "ui_surface",
+          surfaceId: "tool-approval-req-1",
+          surfaceType: "card",
+          title: "Tool Approval",
+          data: {},
+          display: "inline",
+        },
+        { type: "text", text: "Tool Approval card body" },
+      ],
+      createdAt: 1700000035_000,
+      metadata: null,
+      clientMessageId: null,
+      finalized: 1,
+    } as MessageRow;
+    const rows: MessageRow[] = [
+      userRow({
+        id: "asked",
+        createdAt: 1700000030_000,
+        text: "please run it",
+        slackMeta: buildSlackMeta({ channelTs: T2, displayName: "carol" }),
+      }),
+      cardRow,
+    ];
+
+    const result = loadSlackChronologicalContext("conv-1", caps, {
+      loader: () => rows,
+      trustClass: "guardian",
+    });
+
+    expect(result).not.toBeNull();
+    const renderedText = JSON.stringify(result!.messages);
+    expect(renderedText).toContain("please run it");
+    expect(renderedText).not.toContain("Tool Approval card body");
+    expect(renderedText).not.toContain("tool-approval-req-1");
+  });
+
   test("loadSlackChronologicalContext preserves summary and filters by Slack watermark", () => {
     const caps: ChannelCapabilities = {
       channel: "slack",
@@ -4317,19 +4399,22 @@ describe("Slack channel chronological rendering — multi-thread", () => {
         )
         .run();
     }
-    setConversation("runtime-assembly-fallback", {
-      conversationId: "runtime-assembly-fallback",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      channelCapabilities: caps,
-      trustContext: { trustClass: "guardian" },
-      slackContextCompactionWatermarkTs:
-        compaction.slackContextCompactionWatermarkTs ?? null,
-      contextCompactedMessageCount:
-        compaction.contextCompactedMessageCount ?? 0,
-    } as never);
+    setConversation(
+      "runtime-assembly-fallback",
+      asConversation({
+        conversationId: "runtime-assembly-fallback",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        channelCapabilities: caps,
+        trustContext: { trustClass: "guardian", sourceChannel: "vellum" },
+        slackContextCompactionWatermarkTs:
+          compaction.slackContextCompactionWatermarkTs ?? null,
+        contextCompactedMessageCount:
+          compaction.contextCompactedMessageCount ?? 0,
+      }),
+    );
   }
 
   // Re-run a Slack-channel turn through the public assembly path. The

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

@@ -9,6 +9,7 @@ import { applyRuntimeInjections } from "../daemon/conversation-runtime-assembly.
 import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
 import { registerDefaultPluginInjectors } from "../plugins/defaults/index.js";
 import type { Message } from "../providers/types.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // Populate the injector registry with the default plugins' injectors the way
 // bootstrap does in production, so `applyRuntimeInjections` walks a non-empty
@@ -33,16 +34,19 @@ const FALLBACK_CONVERSATION_ID = "runtime-assembly-fallback";
 // injectors resolve their blocks from it (the orchestrator no longer threads
 // workspace or active-surface content as options).
 function registerFallbackConversation(fields: Record<string, unknown>): void {
-  setConversation(FALLBACK_CONVERSATION_ID, {
-    conversationId: FALLBACK_CONVERSATION_ID,
-    workingDir: "/sandbox",
-    // Non-dirty empty workspace by default so the workspace-context injector
-    // skips both the filesystem rescan and the DB refresh unless a test
-    // explicitly seeds a block via `workspaceTopLevelContext`.
-    workspaceTopLevelContext: "",
-    workspaceTopLevelDirty: false,
-    ...fields,
-  } as never);
+  setConversation(
+    FALLBACK_CONVERSATION_ID,
+    asConversation({
+      conversationId: FALLBACK_CONVERSATION_ID,
+      workingDir: "/sandbox",
+      // Non-dirty empty workspace by default so the workspace-context injector
+      // skips both the filesystem rescan and the DB refresh unless a test
+      // explicitly seeds a block via `workspaceTopLevelContext`.
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      ...fields,
+    }),
+  );
 }
 
 // Seed the live conversation registry with a pre-rendered top-level block. The

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

@@ -62,6 +62,9 @@ mock.module("../persistence/conversation-crud.js", () => ({
   getLastUserTimestampBefore: () => 0,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
   updateMessageContent: mock(() => {}),
+  // The drain records the snapshot-stream anchor after each echo. Mocked so a
+  // sink that stamps seqs (the hub) cannot send the real recorder to SQLite.
+  recordConversationPersistedSeq: () => {},
 }));
 
 mock.module("../persistence/conversation-queries.js", () => ({

package/src/__tests__/conversation-surfaces-action-delivery.test.ts

@@ -43,6 +43,7 @@ function makeContext(sent: AssistantEvent[] = []): Conversation & {
   return asConversation({
     conversationId: "conv-1",
     sendToClient: (msg: AssistantEvent) => sent.push(msg),
+    emit: (msg: AssistantEvent) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/conversation-surfaces-activation-emit.test.ts

@@ -69,6 +69,7 @@ function makeContext(
   return {
     conversationId,
     sendToClient: (msg: AssistantEvent) => sent.push(msg),
+    emit: (msg: AssistantEvent) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

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

@@ -97,6 +97,7 @@ function buildMockContext(
           } as Conversation["currentTurnAuthContext"])
         : undefined,
     sendToClient: () => {},
+    emit: () => {},
     pendingSurfaceActions: new Map(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),

package/src/__tests__/conversation-surfaces-app-open.test.ts

@@ -29,7 +29,7 @@ function makeContext(
     channelCapabilities:
       options.channelCapabilities &&
       mockChannelCapabilities(options.channelCapabilities),
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/conversation-surfaces-data-persist.test.ts

@@ -57,7 +57,7 @@ import { asConversation } from "./helpers/mock-conversation.js";
 function makeContext(sent: AssistantEvent[] = []): Conversation {
   return asConversation({
     conversationId: "conv-persist-1",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/conversation-surfaces-history-restored-completion.test.ts

@@ -124,13 +124,17 @@ type EnqueueResult = { queued: boolean; requestId: string; rejected?: boolean };
 
 function makeContext(
   enqueueResult: EnqueueResult = { queued: false, requestId: "req-1" },
-  overrides: { trustContext?: TrustContext; queueDepth?: number } = {},
+  overrides: {
+    trustContext?: TrustContext;
+    queueDepth?: number;
+    emit?: (msg: AssistantEvent) => void;
+  } = {},
 ): Conversation & { enqueuedContents: string[] } {
   const enqueuedContents: string[] = [];
   return asConversation({
     conversationId: CONVERSATION_ID,
     trustContext: overrides.trustContext ?? GUARDIAN_TRUST,
-    sendToClient: () => {},
+    emit: overrides.emit ?? (() => {}),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,
@@ -885,11 +889,12 @@ describe("surface completion when the persisted write does not land", () => {
   test("a ui_dismiss completion whose write throws stays retryable", async () => {
     const surfaceId = "surface-dismiss-persist-throws-1";
     seedSurfaceRow(surfaceId, "choice");
-    const ctx = makeContext();
     const sentToClient: AssistantEvent[] = [];
-    ctx.sendToClient = (msg) => {
-      sentToClient.push(msg);
-    };
+    const ctx = makeContext(undefined, {
+      emit: (msg) => {
+        sentToClient.push(msg);
+      },
+    });
     seedAnsweredSurface(ctx, surfaceId);
     persistError = new Error("database is locked");
 
@@ -919,11 +924,12 @@ describe("surface completion when the persisted write does not land", () => {
   test("a ui_dismiss completion that lands clears the live state", async () => {
     const surfaceId = "surface-dismiss-persist-lands-1";
     seedSurfaceRow(surfaceId, "choice");
-    const ctx = makeContext();
     const sentToClient: AssistantEvent[] = [];
-    ctx.sendToClient = (msg) => {
-      sentToClient.push(msg);
-    };
+    const ctx = makeContext(undefined, {
+      emit: (msg) => {
+        sentToClient.push(msg);
+      },
+    });
     seedAnsweredSurface(ctx, surfaceId);
 
     const result = await surfaceProxyResolver(ctx, "ui_dismiss", {
@@ -942,11 +948,12 @@ describe("surface completion when the persisted write does not land", () => {
   test("a ui_dismiss with no recorded action clears the live state even when the write throws", async () => {
     const surfaceId = "surface-dismiss-no-action-1";
     seedSurfaceRow(surfaceId, "card");
-    const ctx = makeContext();
     const sentToClient: AssistantEvent[] = [];
-    ctx.sendToClient = (msg) => {
-      sentToClient.push(msg);
-    };
+    const ctx = makeContext(undefined, {
+      emit: (msg) => {
+        sentToClient.push(msg);
+      },
+    });
     ctx.pendingSurfaceActions.set(surfaceId, { surfaceType: "card" });
     ctx.surfaceState.set(surfaceId, { surfaceType: "card", data: {} });
     persistError = new Error("database is locked");

package/src/__tests__/conversation-surfaces-queued-emit.test.ts

@@ -22,6 +22,7 @@ function makeQueuedContext(): Conversation {
   return asConversation({
     conversationId: CONV_ID,
     sendToClient: () => {},
+    emit: () => {},
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/conversation-surfaces-standalone-payloads.test.ts

@@ -65,6 +65,7 @@ function createMockContext(
         })
       : undefined,
     sendToClient: (msg: AssistantEvent) => sentMessages.push(msg),
+    emit: (msg: AssistantEvent) => sentMessages.push(msg),
     pendingSurfaceActions: new Map(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),

package/src/__tests__/conversation-surfaces-standalone.test.ts

@@ -53,6 +53,7 @@ function createMockContext(
         })
       : undefined,
     sendToClient: (msg: AssistantEvent) => sentMessages.push(msg),
+    emit: (msg: AssistantEvent) => sentMessages.push(msg),
     pendingSurfaceActions: new Map(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),

package/src/__tests__/conversation-surfaces-state-update.test.ts

@@ -26,7 +26,7 @@ function makeContext(opts?: { sent?: AssistantEvent[] }): Conversation & {
 
   return asConversation({
     conversationId: "test-session",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/conversation-surfaces-table-action.test.ts

@@ -49,7 +49,7 @@ function makeContext(): Conversation & {
 
   return asConversation({
     conversationId: "test-convo",
-    sendToClient: (msg) => sentMessages.push(msg),
+    emit: (msg) => sentMessages.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/conversation-surfaces-task-progress.test.ts

@@ -26,7 +26,7 @@ function makeContext(
     conversationId: "session-1",
     channelCapabilities:
       channelCapabilities && mockChannelCapabilities(channelCapabilities),
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -94,7 +94,7 @@ function makeCtx(overrides: Partial<Conversation> = {}): Conversation {
     workingDir: "/tmp/test",
     getTurnActorPrincipalId: () => undefined,
     abortController: null,
-    sendToClient: mock(() => {}),
+    emit: mock(() => {}),
     pendingSurfaceActions: new Map(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),

package/src/__tests__/conversation-tool-setup-attribution.test.ts

@@ -101,7 +101,7 @@ function makeCtx(overrides: Partial<Conversation> = {}): Conversation {
     workingDir: "/tmp/test",
     getTurnActorPrincipalId: () => undefined,
     abortController: null,
-    sendToClient: mock(() => {}),
+    emit: mock(() => {}),
     pendingSurfaceActions: new Map(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),