@vellumai/assistant 0.10.12 → 0.11.0-staging.1

package/src/daemon/__tests__/channel-ui-capability.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  channelSupportsGuardianQuestionCards,
+  channelSupportsInlineOptions,
+  conversationSupportsGuardianQuestionCards,
+} from "../channel-ui-capability.js";
+
+// Single source of truth for which channels' adapters can render inline
+// tappable options. `resolveChannelCapabilities` populates
+// `ChannelCapabilities.supportsInlineOptions` from this, and the approval
+// delivery path reads it directly (retiring the old RICH_APPROVAL_CHANNELS set).
+describe("channelSupportsInlineOptions", () => {
+  test("true for channels with an inline-button adapter", () => {
+    expect(channelSupportsInlineOptions("telegram")).toBe(true);
+    expect(channelSupportsInlineOptions("whatsapp")).toBe(true);
+    expect(channelSupportsInlineOptions("slack")).toBe(true);
+  });
+
+  test("false for the app and text/voice-only channels", () => {
+    expect(channelSupportsInlineOptions("vellum")).toBe(false);
+    expect(channelSupportsInlineOptions("phone")).toBe(false);
+    expect(channelSupportsInlineOptions("email")).toBe(false);
+  });
+
+  test("false for unknown and empty channel ids", () => {
+    expect(channelSupportsInlineOptions("")).toBe(false);
+    expect(channelSupportsInlineOptions("mystery")).toBe(false);
+  });
+});
+
+// Strict subset of the inline-options channels: only channels with a
+// notification adapter that renders card actions can receive a parked
+// ask_question as a guardian-request card. WhatsApp renders approval buttons
+// on direct sends but has no notification adapter, so it must stay false —
+// parking a question for it would hang the turn with no card ever delivered.
+describe("channelSupportsGuardianQuestionCards", () => {
+  test("true only for channels with a card-rendering notification adapter", () => {
+    expect(channelSupportsGuardianQuestionCards("telegram")).toBe(true);
+    expect(channelSupportsGuardianQuestionCards("slack")).toBe(true);
+  });
+
+  test("false for whatsapp (approval buttons but no notification adapter)", () => {
+    expect(channelSupportsGuardianQuestionCards("whatsapp")).toBe(false);
+  });
+
+  test("false for the app, voice, unknown, and empty ids", () => {
+    expect(channelSupportsGuardianQuestionCards("vellum")).toBe(false);
+    expect(channelSupportsGuardianQuestionCards("phone")).toBe(false);
+    expect(channelSupportsGuardianQuestionCards("")).toBe(false);
+    expect(channelSupportsGuardianQuestionCards("mystery")).toBe(false);
+  });
+});
+
+describe("conversationSupportsGuardianQuestionCards", () => {
+  test("reads the channel from per-turn capabilities, then the structural fallback", () => {
+    expect(
+      conversationSupportsGuardianQuestionCards({
+        currentTurnChannelCapabilities: {
+          supportsDynamicUi: false,
+          channel: "telegram",
+        },
+      }),
+    ).toBe(true);
+    expect(
+      conversationSupportsGuardianQuestionCards({
+        channelCapabilities: { supportsDynamicUi: false, channel: "slack" },
+      }),
+    ).toBe(true);
+  });
+
+  test("false when the channel is card-less or unknown", () => {
+    expect(
+      conversationSupportsGuardianQuestionCards({
+        channelCapabilities: { supportsDynamicUi: false, channel: "whatsapp" },
+      }),
+    ).toBe(false);
+    expect(
+      conversationSupportsGuardianQuestionCards({
+        channelCapabilities: { supportsDynamicUi: true },
+      }),
+    ).toBe(false);
+    expect(conversationSupportsGuardianQuestionCards({})).toBe(false);
+  });
+});

package/src/daemon/__tests__/conversation-surfaces-launch.test.ts

@@ -126,7 +126,7 @@ const { createSurfaceMutex, handleSurfaceAction } =
 type SurfaceConversationContext =
   import("../conversation-surfaces.js").SurfaceConversationContext;
 type TrustContext = import("../trust-context-types.js").TrustContext;
-type ServerMessage = import("../message-protocol.js").ServerMessage;
+type AssistantEvent = import("../../api/index.js").AssistantEvent;
 type SurfaceType = import("../message-protocol.js").SurfaceType;
 
 // ── Harness reset helper ───────────────────────────────────────────
@@ -145,7 +145,7 @@ function resetProcessHarness(): void {
 // ── Surface-context harness ────────────────────────────────────────
 
 interface HarnessContext extends SurfaceConversationContext {
-  sent: ServerMessage[];
+  sent: AssistantEvent[];
   enqueueCalls: Array<{ content: string }>;
   processCalls: Array<{ content: string }>;
 }
@@ -153,7 +153,7 @@ interface HarnessContext extends SurfaceConversationContext {
 function makeContext(
   overrides?: Partial<SurfaceConversationContext>,
 ): HarnessContext {
-  const sent: ServerMessage[] = [];
+  const sent: AssistantEvent[] = [];
   const enqueueCalls: Array<{ content: string }> = [];
   const processCalls: Array<{ content: string }> = [];
 

package/src/daemon/__tests__/embedding-reconcile.test.ts

@@ -24,7 +24,7 @@ const realMemoryV3Gate = {
   ...(await import("../../config/memory-v3-gate.js")),
 };
 const realV2Qdrant = {
-  ...(await import("../../plugins/defaults/memory/v3/substrate/qdrant.js")),
+  ...(await import("../../plugins/defaults/memory/substrate/qdrant.js")),
 };
 const realSectionDenseStore = {
   ...(await import("../../plugins/defaults/memory/v3/section-dense-store.js")),
@@ -86,7 +86,7 @@ function makeDeps(opts: {
         : { provider: "gemini" as const, model: "m", dim: opts.probeDim },
     ),
     readConceptPageCollectionDim: mock(async () => {
-      if (opts.committedDimError) throw opts.committedDimError;
+      if (opts.committedDimError) {throw opts.committedDimError;}
       return opts.committedDim ?? null;
     }),
     decideEmbeddingReconcile: mock(() => opts.decision),
@@ -360,7 +360,7 @@ async function withDefaultDepsMocks(opts: {
       realMemoryV3Gate.isMemoryV3Live,
     ),
   }));
-  mock.module("../../plugins/defaults/memory/v3/substrate/qdrant.js", () => ({
+  mock.module("../../plugins/defaults/memory/substrate/qdrant.js", () => ({
     ...realV2Qdrant,
     ensureConceptPageCollection: delegate(
       spies.ensureConceptPageCollection,

package/src/daemon/__tests__/inference-profile-notification.test.ts

@@ -42,12 +42,9 @@ mock.module("../../plugins/defaults/memory/memory-recall-log-store.js", () => ({
   backfillMemoryRecallLogMessageId: () => {},
 }));
 
-mock.module(
-  "../../plugins/defaults/memory/memory-v2-activation-log-store.js",
-  () => ({
-    backfillMemoryV2ActivationMessageId: () => {},
-  }),
-);
+mock.module("../../plugins/defaults/memory/v2/activation-log-store.js", () => ({
+  backfillMemoryV2ActivationMessageId: () => {},
+}));
 
 // ── Imports (after mocks) ────────────────────────────────────────────────────
 import type { AgentEvent } from "../../agent/loop.js";

package/src/daemon/__tests__/native-web-search-metadata.test.ts

@@ -29,6 +29,7 @@ mock.module("../../persistence/llm-request-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type { AssistantEvent } from "../../api/index.js";
 import { WEB_SEARCH_BACKEND_FAILURE_MESSAGE } from "../../tools/network/web-search-error.js";
 import type {
   EventHandlerDeps,
@@ -38,17 +39,16 @@ import {
   createEventHandlerState,
   dispatchAgentEvent,
 } from "../conversation-agent-loop-handlers.js";
-import type { ServerMessage } from "../message-protocol.js";
 
-type ToolResultEvent = Extract<ServerMessage, { type: "tool_result" }>;
+type ToolResultEvent = Extract<AssistantEvent, { type: "tool_result" }>;
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 function createCollectorDeps(providerName = "anthropic"): {
   deps: EventHandlerDeps;
-  events: ServerMessage[];
+  events: AssistantEvent[];
 } {
-  const events: ServerMessage[] = [];
+  const events: AssistantEvent[] = [];
   const deps = {
     ctx: {
       conversationId: "conv-native-meta",
@@ -58,7 +58,7 @@ function createCollectorDeps(providerName = "anthropic"): {
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
     } as unknown as EventHandlerDeps["ctx"],
-    onEvent: (msg: ServerMessage) => events.push(msg),
+    onEvent: (msg: AssistantEvent) => events.push(msg),
     reqId: "req-native-meta",
     isFirstMessage: false,
     shouldGenerateTitle: false,

package/src/daemon/__tests__/web-search-status-text.test.ts

@@ -20,6 +20,7 @@ mock.module("../../persistence/llm-request-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type { AssistantEvent } from "../../api/index.js";
 import type {
   EventHandlerDeps,
   EventHandlerState,
@@ -30,7 +31,6 @@ import {
   formatFetchStatusText,
   formatSearchStatusText,
 } from "../conversation-agent-loop-handlers.js";
-import type { ServerMessage } from "../message-protocol.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -68,7 +68,7 @@ function createCollectorDeps(): {
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
     } as unknown as EventHandlerDeps["ctx"],
-    onEvent: (_msg: ServerMessage) => {},
+    onEvent: (_msg: AssistantEvent) => {},
     reqId: "req-status-text",
     isFirstMessage: false,
     shouldGenerateTitle: false,

package/src/daemon/channel-ui-capability.ts

@@ -8,8 +8,12 @@
 export interface DynamicUiCapabilityView {
   readonly currentTurnChannelCapabilities?: {
     readonly supportsDynamicUi: boolean;
+    readonly channel?: string;
+  };
+  readonly channelCapabilities?: {
+    readonly supportsDynamicUi: boolean;
+    readonly channel?: string;
   };
-  readonly channelCapabilities?: { readonly supportsDynamicUi: boolean };
 }
 
 /**
@@ -30,3 +34,68 @@ export function conversationSupportsDynamicUi(
     conversation.channelCapabilities;
   return caps?.supportsDynamicUi !== false;
 }
+
+/**
+ * Channels whose adapter can render inline tappable options — approval buttons
+ * today, question option pickers next. Single source of truth: `resolveChannelCapabilities`
+ * populates `ChannelCapabilities.supportsInlineOptions` from this, and the approval
+ * delivery path reads it directly, so no feature re-hardcodes its own channel set.
+ *
+ * Distinct from `supportsDynamicUi` (which gates the app's dynamic-UI surfaces): a
+ * text-only channel like Telegram renders inline buttons yet has no dynamic UI.
+ */
+const INLINE_OPTIONS_CHANNELS: ReadonlySet<string> = new Set([
+  "telegram",
+  "whatsapp",
+  "slack",
+]);
+
+/**
+ * Whether a channel's adapter can render inline tappable options. Pure
+ * set-membership on the canonical channel id (no normalization).
+ */
+export function channelSupportsInlineOptions(channel: string): boolean {
+  return INLINE_OPTIONS_CHANNELS.has(channel);
+}
+
+/**
+ * Channels where a parked `ask_question` can be delivered as a guardian-request
+ * card with tappable answer options — i.e. channels with a notification
+ * adapter that renders card actions (`notifications/adapters/`). A strict
+ * subset of {@link INLINE_OPTIONS_CHANNELS}: WhatsApp renders approval buttons
+ * on direct sends but has no notification adapter yet, so parking a question
+ * for it would hang the turn with no card ever delivered.
+ *
+ * Gates BOTH the `ask_question` park decision (tool context) and the
+ * guardian-request promotion, so the two can never disagree. Onboarding a
+ * channel = add its notification adapter, then add it here.
+ */
+const GUARDIAN_QUESTION_CARD_CHANNELS: ReadonlySet<string> = new Set([
+  "telegram",
+  "slack",
+]);
+
+/**
+ * Whether a parked question can be delivered to this channel as a
+ * guardian-request card. Pure set-membership on the canonical channel id.
+ */
+export function channelSupportsGuardianQuestionCards(channel: string): boolean {
+  return GUARDIAN_QUESTION_CARD_CHANNELS.has(channel);
+}
+
+/**
+ * Whether the conversation's current-turn channel can receive a parked
+ * question as a guardian-request card. Opt-in per channel: defaults to
+ * `false` when the channel is unknown. Prefers the per-turn capabilities,
+ * falling back to the structural channel capabilities.
+ */
+export function conversationSupportsGuardianQuestionCards(
+  conversation: DynamicUiCapabilityView,
+): boolean {
+  const caps =
+    conversation.currentTurnChannelCapabilities ??
+    conversation.channelCapabilities;
+  return caps?.channel
+    ? channelSupportsGuardianQuestionCards(caps.channel)
+    : false;
+}

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -11,6 +11,7 @@ import type pino from "pino";
 import { v4 as uuid } from "uuid";
 
 import type { AgentEvent } from "../agent/loop.js";
+import type { AssistantEvent } from "../api/index.js";
 import type {
   TurnChannelContext,
   TurnInterfaceContext,
@@ -54,7 +55,7 @@ import { endSection, markSection } from "../persistence/slow-sync-log.js";
 import type { ContextWindowResult } from "../plugins/defaults/compaction/window-manager.js";
 import { indexMessageNow } from "../plugins/defaults/memory/indexer.js";
 import { backfillMemoryRecallLogMessageId } from "../plugins/defaults/memory/memory-recall-log-store.js";
-import { backfillMemoryV2ActivationMessageId } from "../plugins/defaults/memory/memory-v2-activation-log-store.js";
+import { backfillMemoryV2ActivationMessageId } from "../plugins/defaults/memory/v2/activation-log-store.js";
 import { backfillMemoryV3SelectionMessageId } from "../plugins/defaults/memory/v3/shadow-plugin.js";
 import { resolveMediaSourceData } from "../providers/media-resolve.js";
 import type {
@@ -131,7 +132,6 @@ import {
 } from "./inflight-message-content.js";
 import type {
   CardSurfaceData,
-  ServerMessage,
   SurfaceAction,
   UiSurfaceShow,
 } from "./message-protocol.js";
@@ -511,7 +511,7 @@ export interface EventHandlerState {
 /** Immutable context shared across event handlers within a single agent loop run. */
 export interface EventHandlerDeps {
   readonly ctx: Conversation;
-  readonly onEvent: (msg: ServerMessage) => void;
+  readonly onEvent: (msg: AssistantEvent) => void;
   readonly reqId: string;
   readonly isFirstMessage: boolean;
   /** Whether the conversation title is replaceable — controls firstAssistantText accumulation for title generation. */
@@ -3309,7 +3309,7 @@ export async function dispatchAgentEvent(
       case "compaction_circuit_open":
       case "compaction_circuit_closed":
         // Circuit-breaker transitions are already in wire-contract shape
-        // (a subset of ServerMessage), so forward them to the client sink
+        // (a subset of AssistantEvent), so forward them to the client sink
         // unchanged. They drive the client's "auto-compaction paused"
         // banner.
         deps.onEvent(event);

package/src/daemon/conversation-agent-loop.ts

@@ -15,6 +15,7 @@ import type {
   CheckpointDecision,
 } from "../agent/loop.js";
 import { createAssistantMessage } from "../agent/message-types.js";
+import type { AssistantEvent } from "../api/index.js";
 import type {
   ChannelId,
   InterfaceId,
@@ -116,7 +117,7 @@ import {
   registerInflightTurn,
   unregisterInflightTurn,
 } from "./inflight-turn-registry.js";
-import type { ServerMessage, UsageStats } from "./message-protocol.js";
+import type { UsageStats } from "./message-protocol.js";
 import type { TrustContext } from "./trust-context-types.js";
 import { resolveTurnCallSite } from "./turn-call-site.js";
 import { runWithLatencySubSpans } from "./turn-latency-sub-spans.js";
@@ -240,7 +241,7 @@ export async function runAgentLoopImpl(
   ctx: Conversation,
   content: string,
   userMessageId: string,
-  onEvent: (msg: ServerMessage) => void,
+  onEvent: (msg: AssistantEvent) => void,
   options?: {
     isInteractive?: boolean;
     isUserMessage?: boolean;
@@ -1669,7 +1670,13 @@ export async function runAgentLoopImpl(
     // the API, enabling stable prefix caching across turns.  Compaction
     // consolidates when it summarizes old messages (cache miss is expected).
 
-    ctx.drainQueue(yieldedForHandoff ? "checkpoint_handoff" : "loop_complete");
+    // kickDrainQueue never rejects — a drain failure here would otherwise be
+    // an unhandled rejection that strands the queue with nothing left to
+    // re-trigger it.
+    void ctx.kickDrainQueue(
+      yieldedForHandoff ? "checkpoint_handoff" : "loop_complete",
+      "agent_loop_finally",
+    );
   }
 }
 
@@ -1680,7 +1687,7 @@ function emitUsage(
   inputTokens: number,
   outputTokens: number,
   model: string,
-  onEvent: (msg: ServerMessage) => void,
+  onEvent: (msg: AssistantEvent) => void,
   actor: UsageActor,
   requestId: string | null = null,
   cacheCreationInputTokens = 0,
@@ -1769,7 +1776,7 @@ export async function applyCompactionResult(
     summaryCallSite?: LLMCallSite;
     summaryOverrideProfile?: string | null;
   },
-  onEvent: (msg: ServerMessage) => void,
+  onEvent: (msg: AssistantEvent) => void,
   reqId: string | null,
   options: {
     slackContextCompactionWatermarkTs?: string | null;

package/src/daemon/conversation-evictor.ts

@@ -7,6 +7,7 @@ const log = getLogger("conversation-evictor");
 /** Minimal interface a conversation must satisfy to be evictable. */
 export interface EvictableConversation {
   isProcessing(): boolean;
+  hasQueuedMessages(): boolean;
   dispose(): void;
 }
 
@@ -63,7 +64,12 @@ export class ConversationEvictor {
       options?.sweepIntervalMs ?? DEFAULT_SWEEP_INTERVAL_MS;
   }
 
-  /** Abort any subagents belonging to a conversation as it's evicted. */
+  /**
+   * Abort any in-flight subagents belonging to a conversation as it's evicted.
+   * Terminal subagent metadata is left readable — an evicted conversation is
+   * resumable from the database, and its next turn may still `subagent_read` a
+   * completed child's result.
+   */
   onEvict(conversationId: string): void {
     getSubagentManager().abortAllForParent(conversationId);
   }
@@ -125,10 +131,19 @@ export class ConversationEvictor {
     };
 
     // Phase 1: TTL eviction — remove conversations idle longer than ttlMs.
+    // A conversation with queued messages is not idle: the queue drains via an
+    // async dispatch after the current turn's `finally`, so `isProcessing()`
+    // can read false while a queued turn (e.g. a subagent completion wake) is
+    // still pending. Disposing in that gap would silently drop the queued
+    // messages.
     for (const [id, conversation] of this.conversations) {
       const lastAccessTime = this.lastAccess.get(id) ?? 0;
       if (now - lastAccessTime < this.ttlMs) continue;
-      if (conversation.isProcessing() || this.shouldProtect(id)) {
+      if (
+        conversation.isProcessing() ||
+        conversation.hasQueuedMessages() ||
+        this.shouldProtect(id)
+      ) {
         result.skipped++;
         continue;
       }
@@ -202,8 +217,15 @@ export class ConversationEvictor {
   private idleConversationsByLru(): Array<[string, EvictableConversation]> {
     const idle: Array<[string, EvictableConversation, number]> = [];
     for (const [id, conversation] of this.conversations) {
-      if (conversation.isProcessing()) continue;
-      if (this.shouldProtect(id)) continue;
+      if (conversation.isProcessing()) {
+        continue;
+      }
+      if (conversation.hasQueuedMessages()) {
+        continue;
+      }
+      if (this.shouldProtect(id)) {
+        continue;
+      }
       idle.push([id, conversation, this.lastAccess.get(id) ?? 0]);
     }
     idle.sort((a, b) => a[2] - b[2]);

package/src/daemon/conversation-launch.ts

@@ -11,8 +11,7 @@ import { randomUUID } from "node:crypto";
 
 import { updateConversationTitle } from "../persistence/conversation-crud.js";
 import { getOrCreateConversation as getOrCreateConversationKey } from "../persistence/conversation-key-store.js";
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
 import { getOrCreateConversation } from "./conversation-store.js";
 import { processMessageInBackground } from "./process-message.js";
@@ -72,19 +71,17 @@ export async function launchConversation(
     updateConversationTitle(conversationId, params.title, 0);
   }
 
-  await assistantEventHub.publish(
-    buildAssistantEvent(
-      {
-        type: "open_conversation",
-        conversationId,
-        ...(params.title ? { title: params.title } : {}),
-        ...(params.anchorMessageId
-          ? { anchorMessageId: params.anchorMessageId }
-          : {}),
-        ...(params.focus !== undefined ? { focus: params.focus } : {}),
-      },
+  broadcastMessage(
+    {
+      type: "open_conversation",
       conversationId,
-    ),
+      ...(params.title ? { title: params.title } : {}),
+      ...(params.anchorMessageId
+        ? { anchorMessageId: params.anchorMessageId }
+        : {}),
+      ...(params.focus !== undefined ? { focus: params.focus } : {}),
+    },
+    conversationId,
   );
 
   processMessageInBackground(conversationId, params.seedPrompt, {

package/src/daemon/conversation-messaging.ts

@@ -16,6 +16,7 @@ import {
 } from "../agent/attachments.js";
 import { optimizeImageForTransport } from "../agent/image-optimize.js";
 import { createUserMessage } from "../agent/message-types.js";
+import type { AssistantEvent } from "../api/index.js";
 import type {
   TurnChannelContext,
   TurnInterfaceContext,
@@ -64,7 +65,6 @@ import { withSqliteRetry } from "../util/sqlite-retry.js";
 import type { MessageQueue } from "./conversation-queue-manager.js";
 import type { SlackInboundMessageMetadata } from "./handlers/shared.js";
 import type {
-  ServerMessage,
   UserMessageAttachment,
 } from "./message-protocol.js";
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
@@ -187,10 +187,10 @@ function resolveIngressSecretTarget(
   for (const detectedType of detectedTypes) {
     const normalizedType = normalizeIngressSecretTypeLabel(detectedType);
     const mapped = INGRESS_SECRET_TARGETS[normalizedType];
-    if (!mapped) continue;
+    if (!mapped) {continue;}
     mappedTargets.set(`${mapped.service}:${mapped.field}`, mapped);
   }
-  if (mappedTargets.size === 1) return mappedTargets.values().next().value!;
+  if (mappedTargets.size === 1) {return mappedTargets.values().next().value!;}
 
   return {
     service: "detected",
@@ -275,7 +275,7 @@ function computeReferenceImageDimensions(
   mediaType: string,
 ): { width: number; height: number } | null {
   const bytes = getAttachmentContent(attachmentId);
-  if (!bytes) return null;
+  if (!bytes) {return null;}
   const optimized = optimizeImageForTransport(
     bytes.toString("base64"),
     mediaType,
@@ -330,7 +330,7 @@ function materializeUserAttachment(
       );
       return stored ? { kind: "stored", stored } : { kind: "transient" };
     }
-    if (!a.data) return { kind: "rejected" };
+    if (!a.data) {return { kind: "rejected" };}
     const validation = validateAttachmentUpload(a.filename, a.mimeType);
     if (!validation.ok) {
       log.warn(
@@ -395,7 +395,7 @@ function referenceBlockForAttachment(
 function inlineBlockForAttachment(
   a: MessageAttachmentInput,
 ): ContentBlock | null {
-  if (!a.data) return null;
+  if (!a.data) {return null;}
   return attachmentsToContentBlocks([a])[0] ?? null;
 }
 
@@ -431,7 +431,7 @@ function prepareUserAttachmentReferences(
       });
       continue;
     }
-    if (outcome.kind === "rejected") continue;
+    if (outcome.kind === "rejected") {continue;}
     // transient: keep the upload by inlining its bytes (dropped only when the
     // recoverable failure left us with no bytes to inline).
     const inline = inlineBlockForAttachment(a);
@@ -450,24 +450,24 @@ function prepareUserAttachmentReferences(
 function extractTurnChannelContext(
   metadata?: Record<string, unknown>,
 ): TurnChannelContext | null {
-  if (!metadata) return null;
+  if (!metadata) {return null;}
   const userMessageChannel = parseChannelId(metadata.userMessageChannel);
   const assistantMessageChannel = parseChannelId(
     metadata.assistantMessageChannel,
   );
-  if (!userMessageChannel || !assistantMessageChannel) return null;
+  if (!userMessageChannel || !assistantMessageChannel) {return null;}
   return { userMessageChannel, assistantMessageChannel };
 }
 
 function extractTurnInterfaceContext(
   metadata?: Record<string, unknown>,
 ): TurnInterfaceContext | null {
-  if (!metadata) return null;
+  if (!metadata) {return null;}
   const userMessageInterface = parseInterfaceId(metadata.userMessageInterface);
   const assistantMessageInterface = parseInterfaceId(
     metadata.assistantMessageInterface,
   );
-  if (!userMessageInterface || !assistantMessageInterface) return null;
+  if (!userMessageInterface || !assistantMessageInterface) {return null;}
   return { userMessageInterface, assistantMessageInterface };
 }
 
@@ -530,7 +530,7 @@ export function buildSlackMetaForPersistence(params: {
 export interface EnqueueMessageOptions {
   content: string;
   attachments?: UserMessageAttachment[];
-  onEvent?: (msg: ServerMessage) => void;
+  onEvent?: (msg: AssistantEvent) => void;
   requestId?: string;
   activeSurfaceId?: string;
   currentPage?: string;
@@ -890,7 +890,7 @@ export async function persistQueuedMessageBody(
     // though the store anchor was lost, then persist the corrected content.
     let repairedBlocks: ContentBlock[] | null = null;
     preparedAttachments.forEach((p, idx) => {
-      if (!p.link) return;
+      if (!p.link) {return;}
       try {
         const scopedAttachmentId = linkAttachmentToMessage(
           persistedUserMessage.id,
@@ -982,7 +982,7 @@ export function redirectToSecurePrompt(
       conversationId,
     )
     .then(async (result): Promise<void> => {
-      if (!result.value) return;
+      if (!result.value) {return;}
 
       const { setSecureKeyAsync } = await import("../security/secure-keys.js");
       const { upsertCredentialMetadata } =

package/src/daemon/conversation-notifiers.ts

@@ -8,6 +8,7 @@
  */
 
 import { createAssistantMessage } from "../agent/message-types.js";
+import type { AssistantEvent } from "../api/index.js";
 import { buildCallCompletionMessage } from "../calls/call-conversation-messages.js";
 import {
   registerCallCompletionNotifier,
@@ -23,7 +24,6 @@ import {
   provenanceFromTrustContext,
 } from "../persistence/conversation-crud.js";
 import type { Message } from "../providers/types.js";
-import type { ServerMessage } from "./message-protocol.js";
 import type { TrustContext } from "./trust-context-types.js";
 
 /**
@@ -31,7 +31,7 @@ import type { TrustContext } from "./trust-context-types.js";
  * invocation time. Properties are read lazily from this reference.
  */
 export interface NotifierConversationContext {
-  sendToClient: (msg: ServerMessage) => void;
+  sendToClient: (msg: AssistantEvent) => void;
   messages: Message[];
   trustContext?: TrustContext;
 }