@vellumai/assistant 0.6.2 → 0.6.4

package/src/daemon/server.ts

@@ -7,6 +7,7 @@ import {
   setBroadcastToAllClients,
 } from "../acp/index.js";
 import { enrichMessageWithSourcePaths } from "../agent/attachments.js";
+import type { AgentEvent } from "../agent/loop.js";
 import {
   createAssistantMessage,
   createUserMessage,
@@ -23,7 +24,9 @@ import { getConfig } from "../config/loader.js";
 import { onContactChange } from "../contacts/contact-events.js";
 import type { CesClient } from "../credential-execution/client.js";
 import type { CesProcessManager } from "../credential-execution/process-manager.js";
+import type { FilingService } from "../filing/filing-service.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
+import { CliIpcServer } from "../ipc/cli-server.js";
 import { getApp, getAppDirPath, isMultifileApp } from "../memory/app-store.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
 import {
@@ -39,11 +42,19 @@ import {
   setConversationOriginChannelIfUnset,
   setConversationOriginInterfaceIfUnset,
 } from "../memory/conversation-crud.js";
-import { updateMetaFile } from "../memory/conversation-disk-view.js";
+import {
+  syncMessageToDisk,
+  updateMetaFile,
+} from "../memory/conversation-disk-view.js";
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
+import { syncIdentityNameToPlatform } from "../platform/sync-identity.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
 import { getProvider, initializeProviders } from "../providers/registry.js";
+import {
+  registerDefaultWakeResolver,
+  type WakeTarget,
+} from "../runtime/agent-wake.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";
@@ -59,6 +70,7 @@ import { appendEventToStream } from "../signals/event-stream.js";
 import { registerUserMessageCallback } from "../signals/user-message.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { summarizeToolInput } from "../tools/tool-input-summary.js";
+import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import {
   getAvatarImagePath,
@@ -66,7 +78,10 @@ import {
   getWorkspacePromptPath,
 } from "../util/platform.js";
 import { registerDaemonCallbacks } from "../work-items/work-item-runner.js";
-import { AppSourceWatcher } from "./app-source-watcher.js";
+import {
+  AppSourceWatcher,
+  setEnsureAppSourceWatcher,
+} from "./app-source-watcher.js";
 import { ConfigWatcher } from "./config-watcher.js";
 import {
   Conversation,
@@ -74,6 +89,7 @@ import {
   DEFAULT_MEMORY_POLICY,
 } from "./conversation.js";
 import { ConversationEvictor } from "./conversation-evictor.js";
+import { registerLaunchConversationDeps } from "./conversation-launch.js";
 import { formatCompactResult } from "./conversation-process.js";
 import { resolveChannelCapabilities } from "./conversation-runtime-assembly.js";
 import { resolveSlash, type SlashContext } from "./conversation-slash.js";
@@ -86,6 +102,7 @@ import type {
 } from "./handlers/shared.js";
 import type { SkillOperationContext } from "./handlers/skills.js";
 import { HostBashProxy } from "./host-bash-proxy.js";
+import { HostBrowserProxy } from "./host-browser-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
 import { HostFileProxy } from "./host-file-proxy.js";
 import type {
@@ -158,9 +175,10 @@ function resolveCanonicalRequestSourceType(
 
 /**
  * Build an onEvent callback that registers pending interactions when the agent
- * loop emits confirmation_request, secret_request, host_bash_request, or
- * host_file_request events. This ensures that channel approval interception
- * can look up the conversation by requestId.
+ * loop emits confirmation_request, secret_request, host_bash_request,
+ * host_browser_request, host_file_request, or host_cu_request events. This
+ * ensures that channel approval interception can look up the conversation by
+ * requestId.
  */
 function makePendingInteractionRegistrar(
   conversation: Conversation,
@@ -249,6 +267,12 @@ function makePendingInteractionRegistrar(
         conversationId,
         kind: "host_bash",
       });
+    } else if (msg.type === "host_browser_request") {
+      pendingInteractions.register(msg.requestId, {
+        conversation,
+        conversationId,
+        kind: "host_browser",
+      });
     } else if (msg.type === "host_file_request") {
       pendingInteractions.register(msg.requestId, {
         conversation,
@@ -277,6 +301,7 @@ export class DaemonServer {
   // Composed subsystems
   private configWatcher = new ConfigWatcher();
   private appSourceWatcher = new AppSourceWatcher();
+  private cliIpc = new CliIpcServer();
 
   // CES (Credential Execution Service) — process-level singleton.
   // Lifecycle is managed by startCesProcess() in lifecycle.ts; the server
@@ -353,6 +378,17 @@ export class DaemonServer {
     return this._heartbeatService;
   }
 
+  /** Optional filing service reference for "Run Now" from the UI. */
+  private _filingService?: FilingService;
+
+  setFilingService(service: FilingService): void {
+    this._filingService = service;
+  }
+
+  getFilingService(): FilingService | undefined {
+    return this._filingService;
+  }
+
   private deriveMemoryPolicy(conversationId: string): ConversationMemoryPolicy {
     const conversationType = getConversationType(conversationId);
     if (conversationType === "private") {
@@ -376,13 +412,23 @@ export class DaemonServer {
       "Transport metadata received",
     );
     conversation.setTransportHints(buildTransportHints(transport));
+    // Route client-reported host env through the capability-gated setter on
+    // Conversation so both the create/reuse path here and the queue-drain
+    // path in conversation-process share one implementation. The method
+    // gates on `supportsHostProxy` (not a specific interface name), so any
+    // new host-capable client added to `HostProxyInterfaceId` will flow its
+    // host env through automatically.
+    conversation.applyHostEnvFromTransport(transport);
   }
 
   constructor() {
     this.evictor = new ConversationEvictor(this.conversations);
     getSubagentManager().sharedRequestTimestamps = this.sharedRequestTimestamps;
     getSubagentManager().broadcastToAllClients = (msg) => this.broadcast(msg);
+    getSubagentManager().resolveParentConversation = (id) =>
+      this.conversations.get(id);
     setBroadcastToAllClients((msg) => this.broadcast(msg));
+    setEnsureAppSourceWatcher(() => this.appSourceWatcher.ensureStarted());
     this.evictor.onEvict = (conversationId: string) => {
       getSubagentManager().abortAllForParent(conversationId);
     };
@@ -524,11 +570,32 @@ export class DaemonServer {
         emoji: fields.emoji,
         home: fields.home,
       });
+
+      // Best-effort sync of the assistant name to the platform record.
+      if (fields.name) {
+        syncIdentityNameToPlatform(fields.name);
+      }
     } catch (err) {
       log.error({ err }, "Failed to broadcast identity change");
     }
   }
 
+  /** Best-effort sync of the IDENTITY.md name to the platform record. */
+  private syncIdentityToPlatform(): void {
+    try {
+      const identityPath = getWorkspacePromptPath("IDENTITY.md");
+      const content = existsSync(identityPath)
+        ? readFileSync(identityPath, "utf-8")
+        : "";
+      const fields = parseIdentityFields(content);
+      if (fields.name) {
+        syncIdentityNameToPlatform(fields.name);
+      }
+    } catch (err) {
+      log.error({ err }, "Failed to sync identity to platform at startup");
+    }
+  }
+
   private broadcastConfigChanged(): void {
     this.broadcast({ type: "config_changed" });
   }
@@ -605,7 +672,13 @@ export class DaemonServer {
       const conversation = this.conversations.get(conversationId);
       if (!conversation) return false;
       this.evictor.touch(conversationId);
-      conversation.abort();
+      conversation.abort(
+        createAbortReason(
+          "signal_cancel",
+          "registerCancelCallback",
+          conversationId,
+        ),
+      );
       getSubagentManager().abortAllForParent(conversationId);
       return true;
     });
@@ -732,6 +805,56 @@ export class DaemonServer {
       return { accepted: true };
     });
 
+    // Install the default resolver for `wakeAgentForOpportunity()` so
+    // internal subsystems (e.g. the Meet chat-opportunity detector wired
+    // up in `MeetSessionManager`) can invoke it without having to build
+    // a `WakeTarget` adapter themselves. The adapter wraps a live
+    // `Conversation` fetched from the in-memory map / hydrated from the
+    // DB, exposing only the narrow surface the wake helper needs.
+    registerDefaultWakeResolver(async (conversationId) => {
+      try {
+        const conversation = await this.getOrCreateConversation(conversationId);
+        return conversationToWakeTarget(conversation);
+      } catch (err) {
+        log.warn(
+          { err, conversationId },
+          "agent-wake default resolver: failed to hydrate conversation",
+        );
+        return null;
+      }
+    });
+
+    // Start the CLI IPC server. Built-in methods (wake_conversation) are
+    // registered by the constructor; CLI commands connect to this socket to
+    // invoke daemon-side operations that require in-process state.
+    this.cliIpc.start();
+
+    // Wire the launchConversation helper to daemon-side state so
+    // handleSurfaceAction can spawn conversations through it.
+    registerLaunchConversationDeps({
+      getOrCreateConversation: (id, options) =>
+        this.getOrCreateConversation(id, options),
+      persistAndProcessMessage: (
+        conversationId,
+        content,
+        attachmentIds,
+        options,
+        sourceChannel,
+        sourceInterface,
+      ) =>
+        this.persistAndProcessMessage(
+          conversationId,
+          content,
+          attachmentIds,
+          options,
+          sourceChannel,
+          sourceInterface,
+        ),
+      publishAssistantEvent: (msg, conversationId) =>
+        this.publishAssistantEvent(msg, conversationId),
+      getAssistantId: () => this.assistantId,
+    });
+
     this.configWatcher.start(
       () => this.evictConversationsForReload(),
       () => this.broadcastIdentityChanged(),
@@ -741,6 +864,8 @@ export class DaemonServer {
       () => this.broadcastFeatureFlagsChanged(),
     );
 
+    this.syncIdentityToPlatform();
+
     this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
 
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
@@ -757,6 +882,7 @@ export class DaemonServer {
     this.evictor.stop();
     this.configWatcher.stop();
     this.appSourceWatcher.stop();
+    this.cliIpc.stop();
     if (this.unsubscribeContactChange) {
       this.unsubscribeContactChange();
       this.unsubscribeContactChange = null;
@@ -880,10 +1006,11 @@ export class DaemonServer {
     let conversation = this.conversations.get(conversationId);
     const sendToClient = () => {};
 
-    if (options && Object.values(options).some((v) => v !== undefined)) {
+    const { taskRunId: _taskRunId, ...persistentOptions } = options ?? {};
+    if (Object.values(persistentOptions).some((v) => v !== undefined)) {
       this.conversationOptions.set(conversationId, {
         ...this.conversationOptions.get(conversationId),
-        ...options,
+        ...persistentOptions,
       });
     }
 
@@ -937,6 +1064,9 @@ export class DaemonServer {
           memoryPolicy,
           sharedCesClient,
           storedOptions?.speed,
+          undefined,
+          storedOptions?.modelIntent,
+          storedOptions?.modelOverride,
         );
         newConversation.updateClient(sendToClient, true);
         await newConversation.loadFromDb();
@@ -975,6 +1105,15 @@ export class DaemonServer {
       // overwrite the in-flight conversation's transportHints.
       if (!conversation.isProcessing()) {
         this.applyTransportMetadata(conversation, options);
+        // trustContext is reapplied here only when the conversation is idle,
+        // so concurrent requests cannot overwrite an in-flight turn's guardian
+        // scope. Direct callers (e.g. schedule-routes run-now) that invoke
+        // processMessage without going through prepareConversationForMessage
+        // rely on this to pick up the trustContext passed in options.
+        // prepareConversationForMessage also reapplies after its own idle check.
+        if (options?.trustContext !== undefined) {
+          conversation.setTrustContext(options.trustContext);
+        }
       }
       this.evictor.touch(conversationId);
     }
@@ -1055,6 +1194,7 @@ export class DaemonServer {
     conversation.setAssistantId(
       options?.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
     );
+    conversation.taskRunId = options?.taskRunId;
     // Only overwrite trust/auth context when explicitly provided. Callers that
     // don't supply a trust context (e.g. signal-injected messages) should
     // inherit whatever the conversation already has from a prior session.
@@ -1082,13 +1222,36 @@ export class DaemonServer {
         options?.transport?.chatType,
       ),
     );
-    // Only create the host bash proxy for desktop client interfaces that can
-    // execute commands on the user's machine. Non-desktop conversations (CLI,
-    // channels, headless) fall back to local execution.
+    // Chrome-extension host_browser wiring is intentionally not supported
+    // through this entry point. `prepareConversationForMessage` constructs
+    // host_browser proxies that capture `conversation.getCurrentSender()`
+    // directly, which would route browser frames through the daemon SSE
+    // channel instead of the `ChromeExtensionRegistry`. Chrome-extension
+    // flows reach host_browser exclusively through the
+    // `/v1/messages` flow in `conversation-routes.ts`, which wires a
+    // registry-aware sender and sets `hostBrowserSenderOverride`.
+    //
+    // Fail loudly rather than silently returning a mis-wired proxy so that
+    // any future caller that tries to route chrome-extension through this
+    // path discovers the gap immediately. When the time comes, factor the
+    // wiring in conversation-routes.ts (registry lookup + override) into a
+    // shared helper and call it from both sites.
+    if (resolvedInterface === "chrome-extension") {
+      throw new Error(
+        "prepareConversationForMessage does not yet support chrome-extension transport — " +
+          "use the conversation-routes.ts /v1/messages flow which routes host_browser through " +
+          "the ChromeExtensionRegistry. If you need chrome-extension here, factor out the " +
+          "wiring in conversation-routes.ts into a shared helper.",
+      );
+    }
+    // Only create each host proxy for interfaces that support the matching
+    // capability. macOS supports all four; the chrome-extension interface only
+    // supports host_browser. Non-desktop conversations (CLI, channels, headless)
+    // fall back to local execution.
     // Guard: don't replace an active proxy during concurrent turn races —
     // another request may have started processing between the isProcessing()
     // check above and the await on ensureActorScopedHistory().
-    if (supportsHostProxy(resolvedInterface)) {
+    if (supportsHostProxy(resolvedInterface, "host_bash")) {
       if (!conversation.isProcessing() || !conversation.hostBashProxy) {
         conversation.setHostBashProxy(
           new HostBashProxy(conversation.getCurrentSender(), (requestId) => {
@@ -1096,6 +1259,21 @@ export class DaemonServer {
           }),
         );
       }
+    } else if (!conversation.isProcessing()) {
+      conversation.setHostBashProxy(undefined);
+    }
+    if (supportsHostProxy(resolvedInterface, "host_browser")) {
+      if (!conversation.isProcessing() || !conversation.hostBrowserProxy) {
+        conversation.setHostBrowserProxy(
+          new HostBrowserProxy(conversation.getCurrentSender(), (requestId) => {
+            pendingInteractions.resolve(requestId);
+          }),
+        );
+      }
+    } else if (!conversation.isProcessing()) {
+      conversation.setHostBrowserProxy(undefined);
+    }
+    if (supportsHostProxy(resolvedInterface, "host_file")) {
       if (!conversation.isProcessing() || !conversation.hostFileProxy) {
         conversation.setHostFileProxy(
           new HostFileProxy(conversation.getCurrentSender(), (requestId) => {
@@ -1103,6 +1281,10 @@ export class DaemonServer {
           }),
         );
       }
+    } else if (!conversation.isProcessing()) {
+      conversation.setHostFileProxy(undefined);
+    }
+    if (supportsHostProxy(resolvedInterface, "host_cu")) {
       if (!conversation.isProcessing() || !conversation.hostCuProxy) {
         conversation.setHostCuProxy(
           new HostCuProxy(conversation.getCurrentSender(), (requestId) => {
@@ -1112,8 +1294,6 @@ export class DaemonServer {
       }
       conversation.addPreactivatedSkillId("computer-use");
     } else if (!conversation.isProcessing()) {
-      conversation.setHostBashProxy(undefined);
-      conversation.setHostFileProxy(undefined);
       conversation.setHostCuProxy(undefined);
     }
     conversation.setCommandIntent(options?.commandIntent ?? null);
@@ -1192,8 +1372,25 @@ export class DaemonServer {
           }
         }
       : registrar;
+    // Non-interactive interfaces that still have a connected client capable
+    // of handling host_browser_request events (e.g. chrome-extension) need
+    // their hostBrowserProxy explicitly marked connected. The proxy
+    // constructor defaults clientConnected = false, so without an explicit
+    // sender update the chrome-extension proxy would be created and
+    // immediately unavailable. We do NOT call updateClient(onEvent, false)
+    // for that case, because flipping hasNoClient false would also enable
+    // host_bash/host_file/host_cu tool gating for an interface that can't
+    // service them. Instead, provision just the browser proxy's sender.
+    const persistInterfaceCtx = conversation.getTurnInterfaceContext();
+    const persistInterface = persistInterfaceCtx?.userMessageInterface;
     if (options?.isInteractive === true) {
       conversation.updateClient(onEvent, false);
+    } else if (
+      persistInterface &&
+      !supportsHostProxy(persistInterface) &&
+      supportsHostProxy(persistInterface, "host_browser")
+    ) {
+      conversation.hostBrowserProxy?.updateSender(onEvent, true);
     }
 
     conversation
@@ -1504,3 +1701,231 @@ function extractConversationId(msg: ServerMessage): string | undefined {
   }
   return undefined;
 }
+
+/**
+ * Translate a raw {@link AgentEvent} from the agent loop into the
+ * corresponding {@link ServerMessage} wire frame. The normal user-turn
+ * path does this via the full state-aware handler in
+ * `conversation-agent-loop-handlers.ts`; the wake path has no tool
+ * accounting, title generation, or activity-state tracking to worry
+ * about, so we only need the subset that produces client-visible
+ * frames. Events that have no client-visible wire shape (usage, error,
+ * preview/input-json deltas, etc.) are dropped — they produce no UI.
+ *
+ * Keeping this translator co-located with the wake adapter preserves
+ * the runtime/daemon layering: `runtime/agent-wake.ts` never imports
+ * `message-protocol.ts` or wire shapes, and the daemon owns all
+ * translation from agent-loop semantics to client frames.
+ */
+function translateAgentEventToServerMessage(
+  event: AgentEvent,
+  conversationId: string,
+): ServerMessage | null {
+  switch (event.type) {
+    case "text_delta":
+      return {
+        type: "assistant_text_delta",
+        text: event.text,
+        conversationId,
+      };
+    case "thinking_delta":
+      return {
+        type: "assistant_thinking_delta",
+        thinking: event.thinking,
+        conversationId,
+      };
+    case "tool_use":
+      return {
+        type: "tool_use_start",
+        toolName: event.name,
+        input: event.input,
+        conversationId,
+        toolUseId: event.id,
+      };
+    case "tool_use_preview_start":
+      return {
+        type: "tool_use_preview_start",
+        toolUseId: event.toolUseId,
+        toolName: event.toolName,
+        conversationId,
+      };
+    case "tool_output_chunk":
+      return {
+        type: "tool_output_chunk",
+        chunk: event.chunk,
+        conversationId,
+        toolUseId: event.toolUseId,
+      };
+    case "tool_result": {
+      const imageBlocks = event.contentBlocks?.filter(
+        (b): b is Extract<typeof b, { type: "image" }> => b.type === "image",
+      );
+      const imageDataList = imageBlocks?.length
+        ? imageBlocks.map((b) => b.source.data)
+        : undefined;
+      return {
+        type: "tool_result",
+        toolName: "",
+        result: event.content,
+        isError: event.isError,
+        diff: event.diff,
+        status: event.status,
+        conversationId,
+        imageData: imageDataList?.[0],
+        imageDataList,
+        toolUseId: event.toolUseId,
+      };
+    }
+    case "server_tool_start":
+      return {
+        type: "tool_use_start",
+        toolName: event.name,
+        input: event.input,
+        conversationId,
+        toolUseId: event.toolUseId,
+      };
+    case "server_tool_complete": {
+      let resultText = "";
+      if (Array.isArray(event.content) && event.content.length > 0) {
+        resultText = (event.content as unknown[])
+          .filter(
+            (r): r is { type: string; title: string; url: string } =>
+              typeof r === "object" &&
+              r != null &&
+              (r as { type?: string }).type === "web_search_result",
+          )
+          .map((r) => `${r.title}\n${r.url}`)
+          .join("\n\n");
+      }
+      return {
+        type: "tool_result",
+        toolName: "web_search",
+        result: resultText,
+        isError: event.isError,
+        conversationId,
+        toolUseId: event.toolUseId,
+      };
+    }
+    case "message_complete":
+      return {
+        type: "message_complete",
+        conversationId,
+      };
+    // No wire frame for these — usage/error/input_json_delta are either
+    // server-internal (accounting/classification) or app-only debug
+    // streams the client doesn't surface for wake-originated turns.
+    case "input_json_delta":
+    case "usage":
+    case "error":
+      return null;
+  }
+}
+
+/**
+ * Adapt a live {@link Conversation} to the narrow {@link WakeTarget}
+ * surface expected by `wakeAgentForOpportunity()`. Kept here so the
+ * runtime-level wake helper stays decoupled from the heavyweight
+ * conversation class (see `registerDefaultWakeResolver` above).
+ *
+ * Routing notes:
+ *   - `emitAgentEvent` dispatches via `broadcastToAllClients` rather
+ *     than `sendToClient`. Several signal-injected paths reset
+ *     `sendToClient` to a no-op in their `finally` blocks (see the
+ *     `updateClient(() => {}, true)` calls in `persistAndProcessMessage`
+ *     / `processMessage`), so a wake fired on such a conversation would
+ *     find a silent sink. `broadcastToAllClients` is wired to
+ *     `this.broadcast(msg)` at construction time and always reaches the
+ *     hub, regardless of which sender the most-recent user turn left
+ *     behind.
+ *   - `persistTailMessage` mirrors the canonical user-turn handlers
+ *     (`handleMessageComplete` / the tool-result block in
+ *     `conversation-agent-loop-handlers.ts`): builds channel/interface
+ *     metadata via `provenanceFromTrustContext` plus the live turn
+ *     channel/interface contexts, persists with metadata, and syncs the
+ *     resulting row to the disk view so wake-produced messages appear
+ *     in the on-disk transcript and carry provenance tags.
+ *   - `drainQueue` delegates to the conversation so any user messages
+ *     queued while the wake was running are processed. The wake helper
+ *     calls this in its finally AFTER `markProcessing(false)`; the
+ *     order matters because `enqueueMessage` only queues when
+ *     `processing === true`.
+ */
+function conversationToWakeTarget(conversation: Conversation): WakeTarget {
+  return {
+    conversationId: conversation.conversationId,
+    agentLoop: conversation.agentLoop,
+    getMessages: () => conversation.getMessages(),
+    pushMessage: (msg) => {
+      conversation.messages.push(msg);
+    },
+    emitAgentEvent: (event) => {
+      const frame = translateAgentEventToServerMessage(
+        event,
+        conversation.conversationId,
+      );
+      if (!frame) return;
+      // Prefer `broadcastToAllClients` (wired to the hub at construction
+      // time and always live) over `sendToClient` (which several
+      // signal-injected paths reset to `() => {}` in their finally
+      // blocks). Fall back to `sendToClient` when the broadcaster is
+      // missing (e.g. in tests that construct a Conversation directly).
+      if (conversation.broadcastToAllClients) {
+        conversation.broadcastToAllClients(frame);
+      } else {
+        conversation.sendToClient(frame);
+      }
+    },
+    isProcessing: () => conversation.isProcessing(),
+    markProcessing: (on) => {
+      conversation.processing = on;
+    },
+    persistTailMessage: async (message) => {
+      // Build metadata that mirrors the canonical handlers in
+      // `conversation-agent-loop-handlers.ts`. If the live turn channel
+      // / interface contexts are missing (a wake can fire on a
+      // conversation that has never run a user turn), fall back to the
+      // conversation's origin channel/interface defaults (`"vellum"`)
+      // so persisted rows still carry valid channel/interface ids.
+      const turnChannelCtx = conversation.getTurnChannelContext();
+      const turnInterfaceCtx = conversation.getTurnInterfaceContext();
+      const metadata: Record<string, unknown> = {
+        ...provenanceFromTrustContext(conversation.trustContext),
+        userMessageChannel: turnChannelCtx?.userMessageChannel ?? "vellum",
+        assistantMessageChannel:
+          turnChannelCtx?.assistantMessageChannel ?? "vellum",
+        userMessageInterface:
+          turnInterfaceCtx?.userMessageInterface ?? "vellum",
+        assistantMessageInterface:
+          turnInterfaceCtx?.assistantMessageInterface ?? "vellum",
+      };
+      const persisted = await addMessage(
+        conversation.conversationId,
+        message.role,
+        JSON.stringify(message.content),
+        metadata,
+      );
+      // Sync the persisted row to the disk view so wake-produced
+      // messages appear in the on-disk transcript and tools that read
+      // from disk (e.g. `messages.jsonl`-based diagnostics) see them.
+      // Mirrors the `syncMessageToDisk(...)` calls in the canonical
+      // handlers — best-effort because a sync failure must not strand
+      // the in-memory tail.
+      try {
+        const convRow = getConversation(conversation.conversationId);
+        if (convRow) {
+          syncMessageToDisk(
+            conversation.conversationId,
+            persisted.id,
+            convRow.createdAt,
+          );
+        }
+      } catch (err) {
+        log.warn(
+          { err, conversationId: conversation.conversationId },
+          "wake adapter: syncMessageToDisk failed (non-fatal)",
+        );
+      }
+    },
+    drainQueue: () => conversation.drainQueue(),
+  };
+}