@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/daemon/conversation-lineage.ts

@@ -0,0 +1,76 @@
+/**
+ * Resolution of a conversation's subagent lineage — the chain of forks that
+ * leads back to the user-visible thread a background run belongs to.
+ */
+
+import { getPersistedParentConversationId } from "../persistence/conversation-parent.js";
+import { findConversationOrSubagent } from "./conversation-registry.js";
+
+/**
+ * Depth cap: a subagent chain deeper than this is a bug, not a hierarchy.
+ * Matches the fork-chain cap in the memory plugin's ancestor walk so the two
+ * conversation-ancestry walks agree on what counts as pathological.
+ */
+export const MAX_LINEAGE_DEPTH = 16;
+
+/**
+ * The spawner of a conversation: the in-memory registry's record, falling back
+ * to the persisted `parent_conversation_id` column. Returns `undefined` at the
+ * top of the chain.
+ *
+ * Both sources are consulted because residency is short-lived —
+ * `SubagentManager` drops a subagent's index entry the moment its run goes
+ * terminal, and the evictor sweeps idle top-level conversations — and because
+ * a resident instance does not necessarily carry the parentage its row does.
+ * The column is stamped at subagent bootstrap and outlives both.
+ *
+ * A failed durable read is swallowed: linking artifacts to a partial chain is
+ * better than failing the caller, which is always a best-effort side effect.
+ */
+function parentOf(conversationId: string): string | undefined {
+  const resident = findConversationOrSubagent(conversationId);
+  if (resident?.parentConversationId) {
+    return resident.parentConversationId;
+  }
+  try {
+    return getPersistedParentConversationId(conversationId);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The conversation itself plus every subagent ancestor above it, nearest
+ * first. A subagent Conversation records its spawner in the readonly
+ * `parentConversationId` set at construction (see subagent/manager.ts) and in
+ * the `parent_conversation_id` column written at bootstrap, so walking that
+ * chain reaches the user-visible thread a background run was forked from.
+ *
+ * Resident hops resolve through {@link findConversationOrSubagent}, because
+ * the seed is typically a background subagent and `SubagentManager` keeps live
+ * subagent conversations in their own index rather than the eviction-managed
+ * top-level store. Non-resident hops fall back to the durable column, so a
+ * link attempted after the run went terminal or the thread was evicted still
+ * reaches the user-visible ancestor.
+ *
+ * Never throws: a failed database read degrades to the chain resolved so far,
+ * which can therefore be shorter than the true ancestry. Bounded by
+ * {@link MAX_LINEAGE_DEPTH} and a visited set, so a cycle terminates.
+ */
+export function resolveConversationLineage(conversationId: string): string[] {
+  const lineage = [conversationId];
+  const visited = new Set([conversationId]);
+
+  let current = conversationId;
+  while (lineage.length < MAX_LINEAGE_DEPTH) {
+    const parent = parentOf(current);
+    if (!parent || visited.has(parent)) {
+      break;
+    }
+    lineage.push(parent);
+    visited.add(parent);
+    current = parent;
+  }
+
+  return lineage;
+}

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;
 }

package/src/daemon/conversation-process.ts

@@ -11,6 +11,7 @@ import {
   createAssistantMessage,
   createUserMessage,
 } from "../agent/message-types.js";
+import type { AssistantEvent } from "../api/index.js";
 import { listPendingRequestsByScopeOrEmpty } from "../channels/gateway-guardian-requests.js";
 import {
   parseChannelId,
@@ -56,10 +57,7 @@ import {
 } from "./conversation-slash.js";
 import { getModelInfo } from "./handlers/config-model.js";
 import { preactivateHostProxySkills } from "./host-proxy-preactivation.js";
-import type {
-  ServerMessage,
-  UserMessageAttachment,
-} from "./message-protocol.js";
+import type { UserMessageAttachment } from "./message-protocol.js";
 import { buildTransportHints } from "./transport-hints.js";
 import { resolveVerificationSessionIntent } from "./verification-session-intent.js";
 
@@ -192,7 +190,7 @@ export function formatCleanResult(result: CleanResult): string {
 /** Build a model_info event with fresh config data. */
 export async function buildModelInfoEvent(
   conversationId?: string,
-): Promise<ServerMessage> {
+): Promise<AssistantEvent> {
   return { type: "model_info", conversationId, ...(await getModelInfo()) };
 }
 
@@ -438,13 +436,15 @@ function repairPendingToolUseBlocks(conversation: Conversation): void {
 
 /**
  * Restore drained messages to the front of the queue, in their original
- * order, when another turn (e.g. a barged-in voice turn woken by the idle
- * transition) owns the processing lock. The lock holder's own finally block
- * re-drains the queue. A steered drain also re-arms `pendingSteerRepair` so
- * the re-drain promotes the steered head on its own instead of batching it
- * with tails; the tool-use repair it re-triggers is idempotent.
+ * order, when the drain cannot run them: another turn (e.g. a barged-in
+ * voice turn woken by the idle transition) owns the processing lock, or the
+ * dispatch threw before the turn took over. The next drain trigger (the lock
+ * holder's own finally block, or `kickQueueDrain`'s retry) picks them back
+ * up. A steered drain also re-arms `pendingSteerRepair` so the re-drain
+ * promotes the steered head on its own instead of batching it with tails;
+ * the tool-use repair it re-triggers is idempotent.
  */
-function requeueOnLockContention(
+function requeueDrainedMessages(
   conversation: Conversation,
   messages: QueuedMessage[],
   steered: boolean,
@@ -493,7 +493,9 @@ export async function drainQueue(
     if (!next) {
       return;
     }
-    return drainSingleMessage(conversation, next, reason, true);
+    return dispatchDrainWithRestore(conversation, [next], true, () =>
+      drainSingleMessage(conversation, next, reason, true),
+    );
   }
 
   const batch = await buildPassthroughBatch(conversation);
@@ -505,12 +507,122 @@ export async function drainQueue(
     if (!next) {
       return;
     }
-    return drainSingleMessage(conversation, next, reason);
+    return dispatchDrainWithRestore(conversation, [next], false, () =>
+      drainSingleMessage(conversation, next, reason),
+    );
   }
   if (batch.length === 1) {
-    return drainSingleMessage(conversation, batch[0], reason);
+    return dispatchDrainWithRestore(conversation, batch, false, () =>
+      drainSingleMessage(conversation, batch[0], reason),
+    );
+  }
+  return dispatchDrainWithRestore(conversation, batch, false, () =>
+    drainBatch(conversation, batch, reason),
+  );
+}
+
+/**
+ * Errors that already triggered a queue restore on their way up. Drains
+ * recurse (a dropped message's error path re-drains the remaining queue), so
+ * without the marker an inner dispatch failure would also restore the outer
+ * dispatch's messages — resurrecting a message whose sender was already told
+ * it failed.
+ */
+const restoredDrainErrors = new WeakSet<object>();
+
+/**
+ * Run a drain dispatch whose messages are already removed from the queue,
+ * restoring them to the front if the dispatch throws. `drainQueue` pops
+ * messages before the throw-prone turn-start steps (slash resolution,
+ * per-turn context application), so without the restore a retry would skip
+ * the failed message entirely: it drains the NEXT item, succeeds, and the
+ * removed message is silently lost with no `queue_drain_failed` event.
+ */
+async function dispatchDrainWithRestore(
+  conversation: Conversation,
+  messages: QueuedMessage[],
+  steered: boolean,
+  dispatch: () => Promise<void>,
+): Promise<void> {
+  try {
+    return await dispatch();
+  } catch (err) {
+    const alreadyRestored =
+      typeof err === "object" && err !== null && restoredDrainErrors.has(err);
+    if (!alreadyRestored) {
+      if (typeof err === "object" && err !== null) {
+        restoredDrainErrors.add(err);
+      }
+      requeueDrainedMessages(
+        conversation,
+        messages,
+        steered,
+        "Requeueing drained messages: drain dispatch threw",
+      );
+    }
+    throw err;
+  }
+}
+
+/**
+ * Fire-and-forget entry point for drain triggers that sit outside the drain
+ * promise chain (the agent loop's `finally`, route handlers releasing the
+ * processing lock). `drainQueue` is async — batch building awaits slash
+ * resolution and can throw — and nothing re-triggers a drain whose promise
+ * rejects: the queued messages would sit stranded until an unrelated later
+ * turn completes. This wrapper never rejects. A failed drain is retried
+ * once — `dispatchDrainWithRestore` has already returned any popped
+ * messages to the queue head, so the retry retries the same messages. If
+ * the retry also fails, every queued sender is notified so the stall is
+ * visible to the user instead of silent, and the messages remain queued
+ * for the next drain trigger.
+ *
+ * `origin` names the triggering site for log correlation.
+ */
+export async function kickQueueDrain(
+  conversation: Conversation,
+  reason: QueueDrainReason = "loop_complete",
+  origin?: string,
+): Promise<void> {
+  try {
+    await drainQueue(conversation, reason);
+    return;
+  } catch (err) {
+    log.error(
+      {
+        err,
+        conversationId: conversation.conversationId,
+        reason,
+        origin,
+        queueDepth: conversation.queue.length,
+      },
+      "drainQueue rejected; retrying once",
+    );
+  }
+  try {
+    await drainQueue(conversation, reason);
+  } catch (err) {
+    log.error(
+      {
+        err,
+        conversationId: conversation.conversationId,
+        reason,
+        origin,
+        queueDepth: conversation.queue.length,
+      },
+      "drainQueue retry rejected; queued messages remain stranded until the next drain trigger",
+    );
+    for (const queued of conversation.queue.snapshot()) {
+      queued.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        requestId: queued.requestId,
+        message:
+          "The assistant couldn't start your queued message due to an internal error. The message is still queued and will be retried after the next reply; you can also cancel and resend it.",
+        category: "queue_drain_failed",
+      });
+    }
   }
-  return drainBatch(conversation, batch, reason);
 }
 
 async function drainSingleMessage(
@@ -526,7 +638,7 @@ async function drainSingleMessage(
   // requeue below stays as the TOCTOU backstop for a lock taken after
   // this check.
   if (conversation.isProcessing()) {
-    requeueOnLockContention(
+    requeueDrainedMessages(
       conversation,
       [next],
       steered,
@@ -952,7 +1064,7 @@ async function drainSingleMessage(
       // Another turn took the lock between this drain's dequeue and its
       // persist. The message is still valid — requeue it at the front and
       // stop; the lock holder's own finally re-drains the queue.
-      requeueOnLockContention(
+      requeueDrainedMessages(
         conversation,
         [next],
         steered,
@@ -1110,7 +1222,7 @@ async function drainBatch(
   // The head persist-busy requeue below stays as the TOCTOU backstop.
   // Steered drains never batch, so there is no steer promotion to restore.
   if (conversation.isProcessing()) {
-    requeueOnLockContention(
+    requeueDrainedMessages(
       conversation,
       batch,
       false,
@@ -1329,7 +1441,7 @@ async function drainBatch(
         // whole batch is still valid — requeue it at the front in order
         // and stop; the lock holder's finally re-drains the queue.
         conversation.preactivatedSkillIds = undefined;
-        requeueOnLockContention(
+        requeueDrainedMessages(
           conversation,
           batch,
           false,
@@ -1503,7 +1615,7 @@ async function drainBatch(
   const successfulEventSinks = Array.from(
     new Set(successfulBatch.map((qm) => qm.onEvent)),
   );
-  const fanOutOnEvent = (msg: ServerMessage) => {
+  const fanOutOnEvent = (msg: AssistantEvent) => {
     for (const onEvent of successfulEventSinks) {
       onEvent(msg);
     }
@@ -1567,7 +1679,7 @@ async function drainBatch(
 export interface ProcessMessageOptions {
   content: string;
   attachments: UserMessageAttachment[];
-  onEvent?: (msg: ServerMessage) => void;
+  onEvent?: (msg: AssistantEvent) => void;
   requestId?: string;
   activeSurfaceId?: string;
   currentPage?: string;

package/src/daemon/conversation-queue-manager.ts

@@ -5,6 +5,7 @@
  * agent loop is in flight.
  */
 
+import type { AssistantEvent } from "../api/index.js";
 import type {
   TurnChannelContext,
   TurnInterfaceContext,
@@ -12,7 +13,6 @@ import type {
 import type { AuthContext } from "../runtime/auth/types.js";
 import { getLogger } from "../util/logger.js";
 import type {
-  ServerMessage,
   UserMessageAttachment,
 } from "./message-protocol.js";
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
@@ -23,7 +23,7 @@ export interface QueuedMessage {
   content: string;
   attachments: UserMessageAttachment[];
   requestId: string;
-  onEvent: (msg: ServerMessage) => void;
+  onEvent: (msg: AssistantEvent) => void;
   activeSurfaceId?: string;
   currentPage?: string;
   metadata?: Record<string, unknown>;
@@ -156,7 +156,7 @@ export class MessageQueue {
    */
   shiftN(count: number): QueuedMessage[] {
     const n = Math.min(Math.max(0, count), this.items.length);
-    if (n === 0) return [];
+    if (n === 0) {return [];}
     const removed = this.items.splice(0, n);
     for (const item of removed) {
       this.currentBytes -= estimateItemBytes(item);
@@ -188,8 +188,8 @@ export class MessageQueue {
    */
   promoteToHead(requestId: string): QueuedMessage | undefined {
     const idx = this.items.findIndex((m) => m.requestId === requestId);
-    if (idx === -1) return undefined;
-    if (idx === 0) return this.items[0]; // already at head
+    if (idx === -1) {return undefined;}
+    if (idx === 0) {return this.items[0];} // already at head
     const [promoted] = this.items.splice(idx, 1);
     this.items.unshift(promoted);
     return promoted;
@@ -201,7 +201,7 @@ export class MessageQueue {
    */
   removeByRequestId(requestId: string): QueuedMessage | undefined {
     const idx = this.items.findIndex((m) => m.requestId === requestId);
-    if (idx === -1) return undefined;
+    if (idx === -1) {return undefined;}
     const [removed] = this.items.splice(idx, 1);
     this.currentBytes -= estimateItemBytes(removed);
     return removed;
@@ -220,7 +220,7 @@ function estimateItemBytes(item: QueuedMessage): number {
   let bytes = item.content.length * 2; // JS strings are UTF-16
   for (const a of item.attachments) {
     bytes += a.data.length * 2;
-    if (a.extractedText) bytes += a.extractedText.length * 2;
+    if (a.extractedText) {bytes += a.extractedText.length * 2;}
   }
   // Include transport metadata in the estimate so large transport
   // payloads (e.g. hostHomeDir, hostUsername) count against the budget.

package/src/daemon/conversation-runtime-assembly.ts

@@ -74,6 +74,7 @@ import { resolveCapabilities } from "../runtime/capabilities.js";
 import type { SubagentState } from "../subagent/types.js";
 import { TERMINAL_STATUSES } from "../subagent/types.js";
 import { canonicalizeInboundIdentity } from "../util/canonicalize-identity.js";
+import { channelSupportsInlineOptions } from "./channel-ui-capability.js";
 import { findConversationOrSubagent } from "./conversation-registry.js";
 import type { SurfaceShowPair } from "./conversation-surfaces.js";
 import { canonicalizeTimeZone, formatTurnTimestamp } from "./date-context.js";
@@ -97,6 +98,13 @@ export interface ChannelCapabilities {
   dashboardCapable: boolean;
   /** Whether the channel supports dynamic UI surfaces (ui_show / ui_update). */
   supportsDynamicUi: boolean;
+  /**
+   * Whether the channel's adapter can render inline tappable options — approval
+   * buttons and (next) question option pickers. Distinct from `supportsDynamicUi`:
+   * a text-only channel can render inline buttons without dynamic UI. Optional;
+   * absent is treated as `false`.
+   */
+  supportsInlineOptions?: boolean;
   /** Whether the channel supports voice/microphone input. */
   supportsVoiceInput: boolean;
   /** The client OS/interface identifier (e.g. "macos", "ios", "web"). */
@@ -282,6 +290,7 @@ export function resolveChannelCapabilities(
         channel,
         dashboardCapable: supportsDesktopUi,
         supportsDynamicUi: supportsDesktopUi || iface === "web",
+        supportsInlineOptions: channelSupportsInlineOptions(channel),
         supportsVoiceInput: supportsDesktopUi,
         clientOS: iface ?? undefined,
         chatType: resolvedChatType,
@@ -296,6 +305,7 @@ export function resolveChannelCapabilities(
         channel,
         dashboardCapable: false,
         supportsDynamicUi: false,
+        supportsInlineOptions: channelSupportsInlineOptions(channel),
         supportsVoiceInput: false,
         chatType: resolvedChatType,
       };
@@ -304,6 +314,7 @@ export function resolveChannelCapabilities(
         channel,
         dashboardCapable: false,
         supportsDynamicUi: false,
+        supportsInlineOptions: channelSupportsInlineOptions(channel),
         supportsVoiceInput: false,
         chatType: resolvedChatType,
       };
@@ -974,6 +985,11 @@ function placeholderForBlockType(type: ContentBlock["type"]): string | null {
     case "tool_result":
     case "web_search_tool_result":
       return "[tool result]";
+    // Surfaces normally ride with a `_surfaceFallback` text sibling that
+    // supplies the line, so this label is reached only by legacy rows that
+    // carry a bare card — better than rendering an empty transcript line.
+    case "ui_surface":
+      return "[card]";
     case "thinking":
     case "redacted_thinking":
     case "text":

package/src/daemon/conversation-store.ts

@@ -118,6 +118,9 @@ export async function getOrCreateConversation(
     (conversation.isStale() && !conversation.isProcessing())
   ) {
     if (conversation) {
+      // Stale rebuild: the conversation id lives on, so abort in-flight
+      // children but keep terminal subagent results readable for the
+      // retention window.
       getSubagentManager().abortAllForParent(conversationId);
       conversation.dispose();
     }
@@ -247,12 +250,15 @@ export async function getOrCreateConversation(
  * deleted conversation and trip FK constraints.
  */
 export function destroyActiveConversation(conversationId: string): void {
+  // Subagent teardown is keyed by parent id, not the live instance — an
+  // evicted parent still retains its terminal children, and deleting the
+  // conversation must take their records with it.
+  getSubagentManager().disposeAllForParent(conversationId);
   const conversation = findConversation(conversationId);
   if (!conversation) {
     return;
   }
   removeFromEvictor(conversationId);
-  getSubagentManager().abortAllForParent(conversationId);
   conversation.dispose();
   deleteConversation(conversationId);
   deleteConversationOptions(conversationId);
@@ -277,10 +283,12 @@ export function stopConversations(): void {
  */
 export function clearAllActiveConversations(): number {
   const count = conversationCount();
-  const subagentManager = getSubagentManager();
+  // Dispose subagents across ALL parents, not just the in-memory ones — an
+  // evicted parent still retains its terminal children, and clear-all must
+  // take their records with it.
+  getSubagentManager().disposeAllForAllParents();
   for (const id of conversationIds()) {
     removeFromEvictor(id);
-    subagentManager.abortAllForParent(id);
   }
   for (const conversation of allConversations()) {
     conversation.dispose();