@vellumai/assistant 0.7.0 → 0.7.1

package/src/daemon/conversation-launch.ts

@@ -5,11 +5,6 @@
  * Called from `handleSurfaceAction` when a persistent `ui_show` card fires a
  * `launch_conversation` action — the origin conversation's `TrustContext` is
  * forwarded so spawned conversations inherit guardian / trust class.
- *
- * The helper depends on DaemonServer state (conversation map,
- * `persistAndProcessMessage`, assistant ID, hub publisher) and is wired via
- * {@link registerLaunchConversationDeps} at daemon startup. Tests can stub
- * deps directly via the same registration.
  */
 
 import { randomUUID } from "node:crypto";
@@ -18,71 +13,13 @@ import { updateConversationTitle } from "../memory/conversation-crud.js";
 import { getOrCreateConversation as getOrCreateConversationKey } from "../memory/conversation-key-store.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { getLogger } from "../util/logger.js";
-import type { Conversation } from "./conversation.js";
-import type { ConversationCreateOptions } from "./handlers/shared.js";
-import type { ServerMessage } from "./message-protocol.js";
+import { getOrCreateConversation } from "./conversation-store.js";
+import { processMessageInBackground } from "./process-message.js";
 import type { TrustContext } from "./trust-context.js";
 
 const log = getLogger("conversation-launch");
 
-// ── Dependency registry ─────────────────────────────────────────────
-
-export interface LaunchConversationDeps {
-  /**
-   * Return the live {@link Conversation} instance for the given id,
-   * creating + hydrating it if necessary. Wraps `DaemonServer.getOrCreateConversation`.
-   */
-  getOrCreateConversation: (
-    conversationId: string,
-    options?: ConversationCreateOptions,
-  ) => Promise<Conversation>;
-  /**
-   * Persist the seed message and run the agent loop. Wraps
-   * `DaemonServer.persistAndProcessMessage`.
-   */
-  persistAndProcessMessage: (
-    conversationId: string,
-    content: string,
-    attachmentIds?: string[],
-    options?: ConversationCreateOptions,
-    sourceChannel?: string,
-    sourceInterface?: string,
-  ) => Promise<{ messageId: string }>;
-  /**
-   * Forward a `ServerMessage` to the process-level assistant event hub.
-   * Wraps `DaemonServer.publishAssistantEvent`.
-   */
-  publishAssistantEvent: (msg: ServerMessage, conversationId?: string) => void;
-  /** Assistant id to stamp onto the `open_conversation` event. */
-  getAssistantId: () => string | undefined;
-}
-
-let _deps: LaunchConversationDeps | null = null;
-
-/**
- * Register the daemon-side dependencies the helper needs. Called once by
- * `DaemonServer.start()` and (in tests) by unit tests that exercise
- * {@link launchConversation} directly.
- */
-export function registerLaunchConversationDeps(
-  deps: LaunchConversationDeps,
-): void {
-  _deps = deps;
-}
-
-/**
- * Test-only helper: reset the module-level `_deps` between test cases so
- * accidental coupling between tests can't hide bugs (e.g. a test that does
- * not register deps but happens to pass because an earlier test in the same
- * file left deps registered and the validation short-circuit hides the
- * "deps not registered" throw).
- */
-export function resetLaunchConversationDeps(): void {
-  _deps = null;
-}
-
 // ── Helper ──────────────────────────────────────────────────────────
 
 export interface LaunchConversationParams {
@@ -109,74 +46,37 @@ export interface LaunchConversationParams {
  * spawning context. When absent, the conversation runs without an inherited
  * trust context.
  *
- * The seed turn (`persistAndProcessMessage`) runs **fire-and-forget** so this
- * helper returns as soon as the conversation is created, titled, and the
- * `open_conversation` event has been published. Callers driving a fan-out
- * UX (multiple launches from a single click) rely on this: blocking on the
- * full LLM turn would hold the HTTP request open for tens of seconds.
- * Errors from the seed turn are logged but not surfaced — the new
- * conversation still exists in the sidebar so the user can retry from there.
+ * The seed turn runs **fire-and-forget** so this helper returns as soon as
+ * the conversation is created, titled, and the `open_conversation` event has
+ * been published. Errors from the seed turn are logged but not surfaced.
  *
- * Throws if the helper's daemon-side dependencies have not been registered
- * or if conversation creation / titling itself fails.
+ * Throws if conversation creation / titling itself fails.
  */
 export async function launchConversation(
   params: LaunchConversationParams,
 ): Promise<{ conversationId: string }> {
-  // Belt-and-suspenders validation: callers (handleSurfaceAction) also check
-  // for these, but enforcing here keeps the helper self-contained so future
-  // direct callers can't accidentally emit `open_conversation` events with a
-  // blank title (which would create a blank-titled sidebar entry on macOS).
   if (!params.title || !params.seedPrompt) {
     throw new Error("launchConversation: title and seedPrompt are required");
   }
-  if (!_deps) {
-    throw new Error(
-      "launchConversation dependencies not registered — daemon may not be ready",
-    );
-  }
-  const deps = _deps;
 
-  // Each launch gets a globally unique conversation key so the skill always
-  // creates a fresh conversation rather than reusing any prior mapping.
-  // `getOrCreateConversation` will insert a new row.
   const conversationKey = `launcher-${randomUUID()}`;
   const { conversationId } = getOrCreateConversationKey(conversationKey);
 
-  // Hydrate the live Conversation instance so we can apply trust context
-  // before the seed turn begins. persistAndProcessMessage will reuse this
-  // instance from the conversations map.
-  const conversation = await deps.getOrCreateConversation(conversationId);
+  const conversation = await getOrCreateConversation(conversationId);
 
-  // Inherit guardian / trust-class state from the caller when available.
-  // `handleSurfaceAction` passes the origin conversation's trustContext.
   if (params.originTrustContext) {
     conversation.setTrustContext(params.originTrustContext);
   }
 
-  // Set the user-facing title immediately so clients that stub a sidebar
-  // entry from the open_conversation event see the right label even before
-  // the turn completes.
   if (params.title) {
     updateConversationTitle(conversationId, params.title, 0);
   }
 
-  // Tell connected clients about the new conversation BEFORE kicking off the
-  // seed turn so the sidebar entry appears instantly. This helper is the sole
-  // emitter of `open_conversation` for this launch path. Pass through the
-  // caller-specified `focus` so fan-out launchers can avoid stealing focus
-  // from the origin.
   await assistantEventHub.publish(
     buildAssistantEvent(
-      deps.getAssistantId() ?? DAEMON_INTERNAL_ASSISTANT_ID,
       {
         type: "open_conversation",
         conversationId,
-        // Conditional spread so an empty / falsy title is omitted entirely
-        // instead of leaking into the Swift handler (`if let title = msg.title`
-        // accepts empty strings and would create a blank-titled sidebar entry).
-        // The validation guard above already rejects empty titles for our
-        // current callers, but this is defense-in-depth for future ones.
         ...(params.title ? { title: params.title } : {}),
         ...(params.anchorMessageId
           ? { anchorMessageId: params.anchorMessageId }
@@ -187,34 +87,19 @@ export async function launchConversation(
     ),
   );
 
-  // Seed the conversation by running the seed prompt through the same
-  // pipeline POST /v1/messages uses. Publishing to the hub lets any
-  // connected client stream the turn live. Fire-and-forget so callers
-  // aren't blocked on the full LLM turn — errors are logged but swallowed.
-  const hubSender = (msg: ServerMessage) => {
-    const msgConversationId =
-      "conversationId" in msg &&
-      typeof (msg as { conversationId?: unknown }).conversationId === "string"
-        ? (msg as { conversationId: string }).conversationId
-        : undefined;
-    deps.publishAssistantEvent(msg, msgConversationId ?? conversationId);
-  };
-
-  deps
-    .persistAndProcessMessage(
-      conversationId,
-      params.seedPrompt,
-      undefined,
-      { onEvent: hubSender },
-      "vellum",
-      "cli",
-    )
-    .catch((err) => {
-      log.error(
-        { err, conversationId },
-        "Seed turn failed for launched conversation (non-fatal)",
-      );
-    });
+  processMessageInBackground(
+    conversationId,
+    params.seedPrompt,
+    undefined,
+    undefined,
+    "vellum",
+    "cli",
+  ).catch((err) => {
+    log.error(
+      { err, conversationId },
+      "Seed turn failed for launched conversation (non-fatal)",
+    );
+  });
 
   return { conversationId };
 }

package/src/daemon/conversation-lifecycle.ts

@@ -244,7 +244,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
             content = [
               {
                 type: "text" as const,
-                text: `<memory __injected>\n${meta.memoryInjectedBlock}\n</memory>`,
+                text: `<memory>\n${meta.memoryInjectedBlock}\n</memory>`,
               },
               ...content,
             ];

package/src/daemon/conversation-messaging.ts

@@ -309,6 +309,7 @@ export function enqueueMessage(
   if (!accepted) {
     onEvent({
       type: "error",
+      conversationId: ctx.conversationId,
       message:
         "The assistant is busy and cannot accept more messages right now. Please try again shortly.",
       category: "queue_full",

package/src/daemon/conversation-process.ts

@@ -12,14 +12,12 @@ import {
   createUserMessage,
 } from "../agent/message-types.js";
 import {
-  canServiceRegistryBrowser,
   parseChannelId,
   parseInterfaceId,
   supportsHostProxy,
   type TurnChannelContext,
   type TurnInterfaceContext,
 } from "../channels/types.js";
-import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { ContextWindowResult } from "../context/window-manager.js";
 import { listPendingRequestsByConversationScope } from "../memory/canonical-guardian-store.js";
@@ -42,12 +40,12 @@ import type {
 } from "./conversation-queue-manager.js";
 import type { ChannelCapabilities } from "./conversation-runtime-assembly.js";
 import {
+  buildSlashContextForContent,
   classifySlash,
   resolveSlash,
   type SlashContext,
 } from "./conversation-slash.js";
 import { getModelInfo } from "./handlers/config-model.js";
-import type { HostBrowserProxy } from "./host-browser-proxy.js";
 import type {
   ServerMessage,
   UsageStats,
@@ -63,22 +61,32 @@ const log = getLogger("conversation-process");
 
 /** Format the result of a forced compaction into a user-facing message. */
 export function formatCompactResult(result: ContextWindowResult): string {
-  const fmt = (n: number) => n.toLocaleString("en-US");
+  const fmt = (n: number | undefined) => (n ?? 0).toLocaleString("en-US");
   if (!result.compacted) {
-    return `Context compaction skipped — ${result.reason ?? "nothing to compact"}.`;
+    return [
+      `Context compaction skipped — ${result.reason ?? "nothing to compact"}.`,
+      `Context: ${fmt(result.estimatedInputTokens)} / ${fmt(
+        result.maxInputTokens,
+      )} tokens`,
+    ].join("\n");
   }
   const saved =
     result.previousEstimatedInputTokens - result.estimatedInputTokens;
   return [
     "Context Compacted\n",
     `Tokens:   ${fmt(result.previousEstimatedInputTokens)} → ${fmt(result.estimatedInputTokens)} (${fmt(saved)} saved)`,
+    `Context:  ${fmt(result.estimatedInputTokens)} / ${fmt(
+      result.maxInputTokens,
+    )} tokens`,
     `Messages: ${fmt(result.compactedMessages)} compacted`,
   ].join("\n");
 }
 
 /** Build a model_info event with fresh config data. */
-export async function buildModelInfoEvent(): Promise<ServerMessage> {
-  return { type: "model_info", ...(await getModelInfo()) };
+export async function buildModelInfoEvent(
+  conversationId?: string,
+): Promise<ServerMessage> {
+  return { type: "model_info", conversationId, ...(await getModelInfo()) };
 }
 
 /** True when the trimmed content is the /models slash command. */
@@ -134,7 +142,7 @@ export interface ProcessConversationContext {
   runAgentLoop(
     content: string,
     userMessageId: string,
-    onEvent: (msg: ServerMessage) => void,
+    onEvent?: (msg: ServerMessage) => void,
     options?: {
       isInteractive?: boolean;
       isUserMessage?: boolean;
@@ -146,26 +154,6 @@ export interface ProcessConversationContext {
   setTurnChannelContext(ctx: TurnChannelContext): void;
   getTurnInterfaceContext(): TurnInterfaceContext | null;
   setTurnInterfaceContext(ctx: TurnInterfaceContext): void;
-  /** Mark host proxies as unavailable so tool execution uses local fallback. */
-  clearProxyAvailability(): void;
-  /**
-   * Restore host proxy availability based on whether a real client is connected.
-   * When `skipBrowser` is true, the browser proxy is left untouched — use this
-   * when `restoreBrowserProxyAvailability()` will handle the browser proxy
-   * separately with the correct registry-routed sender.
-   */
-  restoreProxyAvailability(options?: { skipBrowser?: boolean }): void;
-  /** Restore only the host browser proxy (used by chrome-extension and macOS drains). */
-  restoreBrowserProxyAvailability(): void;
-  /**
-   * Registry-routed sender override for the host browser proxy. When set,
-   * `restoreBrowserProxyAvailability()` uses this function instead of
-   * `sendToClient`. Set by the POST /messages handler when the guardian
-   * has an active extension connection (regardless of interface).
-   */
-  hostBrowserSenderOverride?: (msg: ServerMessage) => void;
-  /** Replace or clear the conversation's host browser proxy. */
-  setHostBrowserProxy(proxy: HostBrowserProxy | undefined): void;
   emitActivityState(
     phase:
       | "idle"
@@ -249,20 +237,18 @@ function resolveQueuedTurnInterfaceContext(
 
 /** Build a SlashContext from the current conversation state and config. */
 function buildSlashContext(
+  content: string,
   conversation: ProcessConversationContext,
-): SlashContext {
-  const config = getConfig();
+): SlashContext | undefined {
   const turnInterface = conversation.getTurnInterfaceContext();
-  return {
+  return buildSlashContextForContent(content, {
+    conversationId: conversation.conversationId,
     messageCount: conversation.messages.length,
     inputTokens: conversation.usageStats.inputTokens,
     outputTokens: conversation.usageStats.outputTokens,
-    maxInputTokens: config.llm.default.contextWindow.maxInputTokens,
-    model: config.llm.default.model,
-    provider: config.llm.default.provider,
     estimatedCost: conversation.usageStats.estimatedCost,
     userMessageInterface: turnInterface?.userMessageInterface,
-  };
+  });
 }
 
 /**
@@ -439,87 +425,14 @@ async function drainSingleMessage(
     conversation.applyHostEnvFromTransport(next.transport);
   }
 
-  // Non-interactive queued messages (channel requests) must not execute tools
-  // via the desktop host proxy. Clear proxy availability so isAvailable()
-  // returns false and tool execution falls back to local.
-  if (next.isInteractive === false) {
-    conversation.clearProxyAvailability();
-    // chrome-extension is non-interactive (no SSE prompter UI) but DOES have
-    // a connected client that can service host_browser_request events. The
-    // unconditional clear above turned its hostBrowserProxy off; restore it
-    // here so the queued turn can still drive the browser via CDP.
-    const drainInterfaceCtx =
-      queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
-    const drainInterface = drainInterfaceCtx?.userMessageInterface;
-    if (
-      drainInterface &&
-      !supportsHostProxy(drainInterface) &&
-      supportsHostProxy(drainInterface, "host_browser")
-    ) {
-      conversation.restoreBrowserProxyAvailability();
-    }
-  } else {
-    // Restore proxy availability only for desktop-originating turns (macos)
-    // in case a prior non-interactive drain disabled it. Non-desktop interactive
-    // interfaces (CLI, Vellum) should not re-enable desktop host proxies. The
-    // chrome-extension interface only supports host_browser, not the desktop
-    // proxies or computer-use, so it is excluded by the no-arg form of
-    // supportsHostProxy (which returns false for chrome-extension).
+  // Preactivate computer-use skill for interactive desktop turns.
+  if (next.isInteractive !== false) {
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
     const sourceInterface = interfaceCtx?.userMessageInterface;
     if (sourceInterface && supportsHostProxy(sourceInterface)) {
-      // When hostBrowserSenderOverride is set, skip the browser proxy here
-      // — restoreBrowserProxyAvailability() below will handle it with the
-      // correct registry-routed sender instead of the SSE hub emitter.
-      // When no override is set (macOS without extension), restoring the
-      // browser proxy via restoreProxyAvailability is correct — it will
-      // use the SSE sender so host_browser_request frames reach the
-      // desktop client directly.
-      conversation.restoreProxyAvailability(
-        conversation.hostBrowserSenderOverride
-          ? { skipBrowser: true }
-          : undefined,
-      );
       conversation.addPreactivatedSkillId("computer-use");
     }
-    // Tear down a stale hostBrowserProxy inherited from a prior turn on a
-    // different interface (e.g. chrome-extension or macOS installed one,
-    // then a CLI turn drains). Without this, restoreProxyAvailability()
-    // above would re-enable the proxy and getCdpClient() would route
-    // browser tools through host_browser_request and hang waiting for a
-    // client that this turn's interface can't service.
-    //
-    // Skip teardown only when BOTH conditions hold:
-    //   1. `hostBrowserSenderOverride` is set (live registry-routed sender)
-    //   2. The current turn's interface can service host_browser frames
-    //      (chrome-extension or macOS).
-    // Without the interface check, queued turns from CLI/iOS/Vellum would
-    // inherit a stale override left by a prior extension-connected turn
-    // and keep the proxy alive, causing cross-interface misrouting.
-    //
-    // macOS and chrome-extension both support host_browser natively, so
-    // this teardown only fires for interfaces that do not support
-    // host_browser at all (CLI, iOS, Vellum, channels).
-    const currentTurnCanServiceBrowser =
-      !!sourceInterface && canServiceRegistryBrowser(sourceInterface);
-    if (
-      sourceInterface &&
-      !supportsHostProxy(sourceInterface, "host_browser") &&
-      !(conversation.hostBrowserSenderOverride && currentTurnCanServiceBrowser)
-    ) {
-      conversation.setHostBrowserProxy(undefined);
-    }
-    // When a macOS turn has a registry-routed sender override (active
-    // extension connection), restore the browser proxy so host_browser
-    // tools route through the extension rather than cdp-inspect/local.
-    if (
-      sourceInterface &&
-      supportsHostProxy(sourceInterface) &&
-      conversation.hostBrowserSenderOverride
-    ) {
-      conversation.restoreBrowserProxyAvailability();
-    }
   }
 
   // Snapshot persona context at turn start so later tool turns can't pick up
@@ -531,7 +444,7 @@ async function drainSingleMessage(
   // Resolve slash commands for queued messages
   const slashResult = await resolveSlash(
     next.content,
-    buildSlashContext(conversation),
+    buildSlashContext(next.content, conversation),
   );
 
   // Unknown slash — persist the exchange and continue draining.
@@ -616,9 +529,13 @@ async function drainSingleMessage(
       // Emit fresh model info before the text delta so the client has
       // up-to-date configuredProviders when rendering /model or /models UI.
       if (isModelSlashCommand(next.content)) {
-        next.onEvent(await buildModelInfoEvent());
+        next.onEvent(await buildModelInfoEvent(conversation.conversationId));
       }
-      next.onEvent({ type: "assistant_text_delta", text: slashResult.message });
+      next.onEvent({
+        type: "assistant_text_delta",
+        text: slashResult.message,
+        conversationId: conversation.conversationId,
+      });
       conversation.traceEmitter.emit(
         "message_complete",
         "Unknown slash command handled",
@@ -650,7 +567,11 @@ async function drainSingleMessage(
           attributes: { reason: "persist_failure" },
         },
       );
-      next.onEvent({ type: "error", message });
+      next.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        message,
+      });
     }
     // Continue draining regardless of success/failure
     await drainQueue(conversation);
@@ -707,7 +628,11 @@ async function drainSingleMessage(
       );
       conversation.messages.push(assistantMsg);
 
-      next.onEvent({ type: "assistant_text_delta", text: responseText });
+      next.onEvent({
+        type: "assistant_text_delta",
+        text: responseText,
+        conversationId: conversation.conversationId,
+      });
       conversation.traceEmitter.emit(
         "message_complete",
         "Compact slash command handled",
@@ -727,7 +652,11 @@ async function drainSingleMessage(
         },
         "Failed to execute /compact",
       );
-      next.onEvent({ type: "error", message });
+      next.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        message,
+      });
     }
     await drainQueue(conversation);
     return;
@@ -787,7 +716,11 @@ async function drainSingleMessage(
         attributes: { reason: "persist_failure" },
       },
     );
-    next.onEvent({ type: "error", message });
+    next.onEvent({
+      type: "error",
+      conversationId: conversation.conversationId,
+      message,
+    });
     // runAgentLoop never ran, so its finally block won't clear this
     conversation.preactivatedSkillIds = undefined;
     // Continue draining — don't strand remaining messages
@@ -872,6 +805,7 @@ async function drainSingleMessage(
       );
       next.onEvent({
         type: "error",
+        conversationId: conversation.conversationId,
         message: `Failed to process queued message: ${message}`,
       });
     });
@@ -928,50 +862,15 @@ async function drainBatch(
     conversation.applyHostEnvFromTransport(head.transport);
   }
 
-  // Non-interactive queued messages (channel requests) must not execute tools
-  // via the desktop host proxy. Clear proxy availability so isAvailable()
-  // returns false and tool execution falls back to local. Mirrors the
-  // single-message path exactly — sourced from `head`.
-  if (head.isInteractive === false) {
-    conversation.clearProxyAvailability();
-    const drainInterfaceCtx =
-      queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
-    const drainInterface = drainInterfaceCtx?.userMessageInterface;
-    if (
-      drainInterface &&
-      !supportsHostProxy(drainInterface) &&
-      supportsHostProxy(drainInterface, "host_browser")
-    ) {
-      conversation.restoreBrowserProxyAvailability();
-    }
-  } else {
+  // Preactivate computer-use skill for interactive desktop turns.
+  // Mirrors the single-message path exactly — sourced from `head`.
+  if (head.isInteractive !== false) {
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
     const sourceInterface = interfaceCtx?.userMessageInterface;
     if (sourceInterface && supportsHostProxy(sourceInterface)) {
-      conversation.restoreProxyAvailability(
-        conversation.hostBrowserSenderOverride
-          ? { skipBrowser: true }
-          : undefined,
-      );
       conversation.addPreactivatedSkillId("computer-use");
     }
-    const currentTurnCanServiceBrowser =
-      !!sourceInterface && canServiceRegistryBrowser(sourceInterface);
-    if (
-      sourceInterface &&
-      !supportsHostProxy(sourceInterface, "host_browser") &&
-      !(conversation.hostBrowserSenderOverride && currentTurnCanServiceBrowser)
-    ) {
-      conversation.setHostBrowserProxy(undefined);
-    }
-    if (
-      sourceInterface &&
-      supportsHostProxy(sourceInterface) &&
-      conversation.hostBrowserSenderOverride
-    ) {
-      conversation.restoreBrowserProxyAvailability();
-    }
   }
 
   // Snapshot persona context at turn start so later tool turns can't pick up
@@ -1025,7 +924,7 @@ async function drainBatch(
 
     const qmSlash = await resolveSlash(
       qm.content,
-      buildSlashContext(conversation),
+      buildSlashContext(qm.content, conversation),
     );
     if (qmSlash.kind !== "passthrough") {
       // Defensive recovery. `buildPassthroughBatch` should make this
@@ -1051,7 +950,11 @@ async function drainBatch(
         status: "error",
         attributes: { reason: "batch_invariant_violation" },
       });
-      qm.onEvent({ type: "error", message: invariantMessage });
+      qm.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        message: invariantMessage,
+      });
       if (i === 0) {
         // Head invariant fired — no in-flight turn yet (the check runs
         // before persistUserMessage, so the head was never persisted).
@@ -1118,7 +1021,11 @@ async function drainBatch(
           attributes: { reason: "persist_failure" },
         },
       );
-      qm.onEvent({ type: "error", message });
+      qm.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        message,
+      });
 
       if (i === 0) {
         // Head persist failed — processing is not set yet, no in-flight turn
@@ -1279,6 +1186,7 @@ async function drainBatch(
       );
       fanOutOnEvent({
         type: "error",
+        conversationId: conversation.conversationId,
         message: `Failed to process queued messages: ${message}`,
       });
     });
@@ -1415,7 +1323,7 @@ export async function processMessage(
   // Resolve slash commands before persistence
   const slashResult = await resolveSlash(
     content,
-    buildSlashContext(conversation),
+    buildSlashContext(content, conversation),
   );
 
   // Unknown slash command — persist the exchange (user + assistant) so the
@@ -1491,9 +1399,13 @@ export async function processMessage(
     // Emit fresh model info before the text delta so the client has
     // up-to-date configuredProviders when rendering /model or /models UI.
     if (isModelSlashCommand(content)) {
-      onEvent(await buildModelInfoEvent());
+      onEvent(await buildModelInfoEvent(conversation.conversationId));
     }
-    onEvent({ type: "assistant_text_delta", text: slashResult.message });
+    onEvent({
+      type: "assistant_text_delta",
+      text: slashResult.message,
+      conversationId: conversation.conversationId,
+    });
     conversation.traceEmitter.emit(
       "message_complete",
       "Unknown slash command handled",
@@ -1561,7 +1473,11 @@ export async function processMessage(
       );
       conversation.messages.push(assistantMsg);
 
-      onEvent({ type: "assistant_text_delta", text: responseText });
+      onEvent({
+        type: "assistant_text_delta",
+        text: responseText,
+        conversationId: conversation.conversationId,
+      });
       conversation.traceEmitter.emit(
         "message_complete",
         "Compact slash command handled",
@@ -1613,7 +1529,11 @@ export async function processMessage(
     );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    onEvent({ type: "error", message });
+    onEvent({
+      type: "error",
+      conversationId: conversation.conversationId,
+      message,
+    });
     // runAgentLoop never ran, so its finally block won't clear this
     conversation.preactivatedSkillIds = undefined;
     return "";