@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/config/webhook-routing.ts

@@ -0,0 +1,67 @@
+/**
+ * Derivations answering "is this deployment set up to receive provider
+ * webhooks?" from workspace config.
+ *
+ * Two consumers ask the same question for different reasons: the channel
+ * readiness probes report it to the user, and the Telegram webhook health
+ * sweep uses it to decide whether a missing/broken registration is even
+ * meaningful. Both must agree — a probe that says "ingress is configured"
+ * while the sweep says "no webhook expected" would be a silent divergence.
+ */
+
+import {
+  normalizePublicBaseUrl,
+  resolveTwilioPublicBaseUrl,
+} from "@vellumai/service-contracts/twilio-ingress";
+
+import { getIsPlatform } from "./env-registry.js";
+import { loadRawConfig } from "./loader.js";
+
+/**
+ * True when a public ingress base URL is set and ingress is enabled.
+ *
+ * `ingress.enabled` is treated as opt-out: an unset flag with a base URL
+ * present counts as enabled, matching how the URL alone has always been
+ * enough to drive registration.
+ */
+export function hasIngressConfigured(
+  options: { twilio?: boolean } = {},
+): boolean {
+  try {
+    const raw = loadRawConfig();
+    const ingress = (raw?.ingress ?? {}) as Record<string, unknown>;
+    const effectiveBaseUrl = options.twilio
+      ? (resolveTwilioPublicBaseUrl(ingress) ?? "")
+      : (normalizePublicBaseUrl(ingress.publicBaseUrl) ?? "");
+    const enabled =
+      (ingress.enabled as boolean | undefined) ??
+      (effectiveBaseUrl ? true : false);
+    return enabled && effectiveBaseUrl.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * True when inbound webhooks have somewhere to land: either a self-hosted
+ * public ingress URL, or — when `allowManagedCallbacks` is set and this is a
+ * platform deployment — the platform's managed callback routes.
+ */
+export function hasWebhookRoutingConfigured(
+  allowManagedCallbacks = false,
+  options: { twilio?: boolean } = {},
+): {
+  configured: boolean;
+  usesManagedCallbacks: boolean;
+} {
+  const ingressConfigured = hasIngressConfigured(options);
+  if (ingressConfigured) {
+    return { configured: true, usesManagedCallbacks: false };
+  }
+
+  const usesManagedCallbacks = allowManagedCallbacks && getIsPlatform();
+  return {
+    configured: usesManagedCallbacks,
+    usesManagedCallbacks,
+  };
+}

package/src/context/compactor.ts

@@ -1050,9 +1050,13 @@ function truncateHistoryToBudget(args: {
   systemPrompt: string;
   budgetTokens: number;
   providerName: string;
+  model?: string;
 }): Message[] {
-  const { messages, systemPrompt, budgetTokens, providerName } = args;
-  let estimate = estimatePromptTokens(messages, systemPrompt, { providerName });
+  const { messages, systemPrompt, budgetTokens, providerName, model } = args;
+  let estimate = estimatePromptTokens(messages, systemPrompt, {
+    providerName,
+    model,
+  });
   if (estimate <= budgetTokens || messages.length <= 1) {
     return messages;
   }
@@ -1061,6 +1065,7 @@ function truncateHistoryToBudget(args: {
     dropCount++;
     estimate = estimatePromptTokens(messages.slice(dropCount), systemPrompt, {
       providerName,
+      model,
     });
   }
   if (dropCount === 0) {
@@ -1155,6 +1160,7 @@ export async function runAssistantDrivenCompaction(
     systemPrompt: args.systemPrompt,
     budgetTokens: compactionPrefixBudget(args.maxInputTokens),
     providerName: args.provider.tokenEstimationProvider ?? args.provider.name,
+    model: args.provider.defaultModel,
   });
   const requestMessages = buildCompactionRequest(summaryHistory, instruction);
 
@@ -1354,7 +1360,7 @@ export async function runAssistantDrivenCompaction(
       estimatePromptTokens(
         [...fixedPrefix, ...stripInjectionsForCompaction(tail)],
         args.systemPrompt,
-        { providerName, toolTokenBudget },
+        { providerName, model: args.provider.defaultModel, toolTokenBudget },
       );
     const floorIndex = resolveTailFloorIndex(args.messages, pairedTailIndex);
     const advanced = advanceTailForBudget({
@@ -1616,6 +1622,7 @@ export async function runEmergencyCompaction(
     systemPrompt: args.systemPrompt,
     budgetTokens: compactionPrefixBudget(args.maxInputTokens),
     providerName: args.provider.tokenEstimationProvider ?? args.provider.name,
+    model: args.provider.defaultModel,
   });
 
   const instruction: Message = {

package/src/context/token-estimator.ts

@@ -3,6 +3,11 @@ import {
   normalizeGeminiAudioMime,
 } from "../providers/gemini/inline-media.js";
 import { mediaSourceByteLength } from "../providers/media-resolve.js";
+import { modelSupportsAudioInput } from "../providers/model-catalog.js";
+import {
+  estimateOpenAICompatAudioTokens,
+  isOpenAICompatInlineAudio,
+} from "../providers/openai/input-audio.js";
 import type {
   ContentBlock,
   Message,
@@ -90,6 +95,12 @@ const TOOL_DEFINITION_OVERHEAD_TOKENS = 28;
 
 export interface TokenEstimatorOptions {
   providerName?: string;
+  /**
+   * Model id the estimated request dispatches to, for model-keyed rules
+   * (e.g. audio-capable OpenAI-compatible models). Callers pass the
+   * provider's `defaultModel` when available.
+   */
+  model?: string;
   /** Pre-computed tool token budget. When provided, added to the prompt total. */
   toolTokenBudget?: number;
 }
@@ -142,6 +153,16 @@ function estimateFileDataTokens(
     return Math.ceil((Math.ceil(byteLength / 3) * 4) / CHARS_PER_TOKEN);
   }
 
+  // Audio-native OpenAI-compatible models (catalog `supportsAudioInput`)
+  // receive eligible audio inline as `input_audio` parts, billed by duration.
+  if (
+    options?.model !== undefined &&
+    modelSupportsAudioInput(options.model) &&
+    isOpenAICompatInlineAudio(block.source.media_type, byteLength)
+  ) {
+    return estimateOpenAICompatAudioTokens(byteLength);
+  }
+
   return 0;
 }
 

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, {