@vellumai/assistant 0.6.3 → 0.6.5

package/src/runtime/routes/conversation-routes.ts

@@ -1,7 +1,7 @@
 /**
  * Route handlers for conversation messages and suggestions.
  */
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { join, relative } from "node:path";
 
 import { z } from "zod";
@@ -12,8 +12,10 @@ import {
   createUserMessage,
 } from "../../agent/message-types.js";
 import {
+  canServiceRegistryBrowser,
   CHANNEL_IDS,
   INTERFACE_IDS,
+  type InterfaceId,
   isInteractiveInterface,
   parseChannelId,
   parseInterfaceId,
@@ -21,6 +23,7 @@ import {
 } from "../../channels/types.js";
 import { isHttpAuthDisabled } from "../../config/env.js";
 import { getConfig } from "../../config/loader.js";
+import type { Conversation } from "../../daemon/conversation.js";
 import {
   buildModelInfoEvent,
   formatCompactResult,
@@ -45,6 +48,10 @@ import type {
   NonHostProxyTransportMetadata,
 } from "../../daemon/message-types/conversations.js";
 import type { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
+import {
+  writeOnboardingSidecar,
+  writeRelationshipState,
+} from "../../home/relationship-state-writer.js";
 import * as attachmentsStore from "../../memory/attachments-store.js";
 import {
   createCanonicalGuardianRequest,
@@ -58,6 +65,7 @@ import {
   getLastAssistantTimestampBefore,
   getMessages,
   getMessagesPaginated,
+  hasMessages,
   type MessageRow,
   provenanceFromTrustContext,
   setConversationOriginChannelIfUnset,
@@ -74,6 +82,7 @@ import { checkIngressForSecrets } from "../../security/secret-ingress.js";
 import { redactSecrets } from "../../security/secret-scanner.js";
 import { summarizeToolInput } from "../../tools/tool-input-summary.js";
 import { getLogger } from "../../util/logger.js";
+import { getWorkspacePromptPath } from "../../util/platform.js";
 import { silentlyWithLog } from "../../util/silently.js";
 import { buildAssistantEvent } from "../assistant-event.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
@@ -107,7 +116,7 @@ const SUGGESTION_CACHE_MAX = 100;
 function collectCanonicalGuardianRequestHintIds(
   conversationId: string,
   sourceChannel: string,
-  conversation: import("../../daemon/conversation.js").Conversation,
+  conversation: Conversation,
 ): string[] {
   const requests = listPendingRequestsByConversationScope(
     conversationId,
@@ -172,7 +181,7 @@ async function tryConsumeCanonicalGuardianReply(params: {
     data: string;
     filePath?: string;
   }>;
-  conversation: import("../../daemon/conversation.js").Conversation;
+  conversation: Conversation;
   onEvent: (msg: ServerMessage) => void;
   approvalConversationGenerator?: ApprovalConversationGenerator;
   /** Verified actor identity from actor-token middleware. */
@@ -967,7 +976,7 @@ function mergeConsecutiveAssistantMessages(messages: MessageRow[]): {
 function makeHubPublisher(
   deps: SendMessageDeps,
   conversationId: string,
-  conversation: import("../../daemon/conversation.js").Conversation,
+  conversation: Conversation,
 ): (msg: ServerMessage) => void {
   let hubChain: Promise<void> = Promise.resolve();
   return (msg: ServerMessage) => {
@@ -1048,30 +1057,8 @@ function makeHubPublisher(
         conversationId,
         kind: "secret",
       });
-    } else if (msg.type === "host_bash_request") {
-      pendingInteractions.register(msg.requestId, {
-        conversation,
-        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,
-        conversationId,
-        kind: "host_file",
-      });
-    } else if (msg.type === "host_cu_request") {
-      pendingInteractions.register(msg.requestId, {
-        conversation,
-        conversationId,
-        kind: "host_cu",
-      });
+    } else {
+      registerHostProxyPendingInteraction(msg, conversation, conversationId);
     }
 
     // ServerMessage is a large union; conversationId exists on most but not all variants.
@@ -1080,7 +1067,20 @@ function makeHubPublisher(
       typeof (msg as { conversationId?: unknown }).conversationId === "string"
         ? (msg as { conversationId: string }).conversationId
         : undefined;
-    const resolvedConversationId = msgConversationId ?? conversationId;
+    // `conversation_list_invalidated` is a list-level system event: it
+    // describes no particular conversation and every connected client
+    // should refresh its sidebar. Publish it unscoped so the SSE hub does
+    // not filter it out by the subscriber's `filter.conversationId`.
+    // Other events (including `conversation_title_updated`) stay scoped to
+    // their conversation — unscoped scoped-events would leak foreign
+    // `conversationId` values to native clients' speculative ID-resolution
+    // path. For `conversation_title_updated` we instead enqueue a matching
+    // unscoped `conversation_list_invalidated` below so other clients'
+    // sidebars can refresh and pick up the new title.
+    const resolvedConversationId =
+      msg.type === "conversation_list_invalidated"
+        ? undefined
+        : (msgConversationId ?? conversationId);
     const event = buildAssistantEvent(
       DAEMON_INTERNAL_ASSISTANT_ID,
       msg,
@@ -1096,10 +1096,229 @@ function makeHubPublisher(
           "assistant-events hub subscriber threw during POST /messages",
         );
       }
+
+      // When the agent loop auto-generates a conversation title, also
+      // broadcast an unscoped `conversation_list_invalidated` so every
+      // connected client's sidebar can refresh and pick up the new title.
+      // Without this, clients viewing other conversations (or a draft)
+      // would never learn that the title for this conversation changed.
+      // The scoped `conversation_title_updated` above still handles the
+      // in-place update for the client currently viewing this conversation.
+      if (msg.type === "conversation_title_updated") {
+        try {
+          await deps.assistantEventHub.publish(
+            buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+              type: "conversation_list_invalidated",
+              reason: "renamed",
+            }),
+          );
+        } catch (err) {
+          log.warn(
+            { err },
+            "Failed to publish conversation_list_invalidated after title update",
+          );
+        }
+      }
     })();
   };
 }
 
+/**
+ * Register pending interactions for host proxy request envelopes so
+ * standalone result endpoints can resolve by requestId.
+ *
+ * Returns the registered requestId when a host proxy request was registered.
+ * Callers that route through non-hub transports (e.g. registry-routed
+ * host_browser sends) can use this to clean up the registration if send fails.
+ */
+function registerHostProxyPendingInteraction(
+  msg: ServerMessage,
+  conversation: Conversation,
+  conversationId: string,
+): string | undefined {
+  if (msg.type === "host_bash_request") {
+    pendingInteractions.register(msg.requestId, {
+      conversation,
+      conversationId,
+      kind: "host_bash",
+    });
+    return msg.requestId;
+  }
+  if (msg.type === "host_browser_request") {
+    pendingInteractions.register(msg.requestId, {
+      conversation,
+      conversationId,
+      kind: "host_browser",
+    });
+    return msg.requestId;
+  }
+  if (msg.type === "host_file_request") {
+    pendingInteractions.register(msg.requestId, {
+      conversation,
+      conversationId,
+      kind: "host_file",
+    });
+    return msg.requestId;
+  }
+  if (msg.type === "host_cu_request") {
+    pendingInteractions.register(msg.requestId, {
+      conversation,
+      conversationId,
+      kind: "host_cu",
+    });
+    return msg.requestId;
+  }
+  return undefined;
+}
+
+/**
+ * Resolve the host_browser sender function for a conversation turn.
+ *
+ * When the guardian has an active extension connection in the
+ * ChromeExtensionRegistry, returns a registry-routed sender that forwards
+ * `host_browser_request` / `host_browser_cancel` frames through the
+ * WebSocket to the connected extension. Otherwise returns the SSE hub
+ * emitter (`onEvent`).
+ *
+ * For `chrome-extension` turns the registry sender is **always** returned
+ * regardless of the POST-time connection check. The chrome-extension
+ * interface has no SSE consumer for `host_browser_request` frames, so
+ * falling back to `onEvent` would cause CDP calls to stall until the proxy
+ * timeout (30 s) instead of failing immediately at send time when the
+ * registry throws on a missing connection.
+ *
+ * This helper is interface-agnostic: both chrome-extension and macOS turns
+ * can obtain a registry-routed sender when extension connectivity exists.
+ * The `isRegistryRouted` flag lets the caller decide whether to set
+ * `hostBrowserSenderOverride` and whether to provision a `HostBrowserProxy`
+ * for interfaces that don't statically support host_browser (e.g. macOS).
+ */
+function resolveHostBrowserSender(
+  conversation: Conversation,
+  conversationId: string,
+  authContext: AuthContext,
+  onEvent: (msg: ServerMessage) => void,
+  sourceInterface: InterfaceId,
+): { sender: (msg: ServerMessage) => void; isRegistryRouted: boolean } {
+  // Check whether the guardian has any active extension connection.
+  const guardianId =
+    conversation.trustContext?.guardianPrincipalId ??
+    authContext.actorPrincipalId;
+  const hasExtensionConnection =
+    !!guardianId && !!getChromeExtensionRegistry().get(guardianId);
+
+  // For chrome-extension, always use the registry sender so that send-time
+  // failures produce immediate errors rather than 30-second proxy timeouts.
+  // The SSE hub has no extension consumer, so falling back to onEvent is
+  // never correct for this interface.
+  if (!hasExtensionConnection && sourceInterface !== "chrome-extension") {
+    return { sender: onEvent, isRegistryRouted: false };
+  }
+
+  // Build a registry-routed sender. The guardian principal ID is resolved
+  // at send time rather than captured here so that queue-drain restores
+  // (which re-fire this closure outside the original POST context) follow
+  // the conversation's bound guardian identity rather than a stale
+  // authContext.actorPrincipalId.
+  const registrySender = (msg: ServerMessage): void => {
+    const requestId = registerHostProxyPendingInteraction(
+      msg,
+      conversation,
+      conversationId,
+    );
+    const gid =
+      conversation.trustContext?.guardianPrincipalId ??
+      authContext.actorPrincipalId;
+    if (!gid) {
+      if (requestId) pendingInteractions.resolve(requestId);
+      throw new Error(
+        "host_browser send skipped: no guardianId on AuthContext",
+      );
+    }
+    const ok = getChromeExtensionRegistry().send(gid, msg);
+    if (!ok) {
+      if (requestId) pendingInteractions.resolve(requestId);
+      throw new Error(
+        `host_browser send failed: no active connection for guardian ${gid}`,
+      );
+    }
+  };
+
+  return { sender: registrySender, isRegistryRouted: true };
+}
+
+/**
+ * Persist the pre-chat onboarding payload to disk.
+ *
+ * Runs only on the very first message of a fresh conversation. Three
+ * artifacts are produced:
+ *
+ *   1. `data/onboarding-context.json` — sidecar read by the
+ *      relationship-state writer so onboarding-sourced facts survive
+ *      the pure-recomputation write cycle (every turn boundary rebuilds
+ *      facts from markdown; the sidecar is the durable source for the
+ *      tool/task/tone chips).
+ *   2. `IDENTITY.md` / `USER.md` — persona seed files, only written
+ *      when missing so we never clobber existing content. These feed
+ *      the system prompt and the relationship-state writer's
+ *      `parseIdentity` / `parseUserName` helpers after a daemon
+ *      restart when the in-memory onboarding context is gone.
+ *   3. `data/relationship-state.json` — kicked off fire-and-forget so
+ *      the Home page can populate immediately on first visit instead
+ *      of waiting for the first agent-turn boundary.
+ *
+ * Never throws: every write is guarded and logged as a warning on
+ * failure. The route handler path must never reject because of a
+ * best-effort persistence step.
+ */
+function persistOnboardingArtifacts(onboarding: {
+  tools: string[];
+  tasks: string[];
+  tone: string;
+  userName?: string;
+  assistantName?: string;
+}): void {
+  writeOnboardingSidecar(onboarding);
+
+  const assistantName = onboarding.assistantName?.trim();
+  if (assistantName) {
+    const identityPath = getWorkspacePromptPath("IDENTITY.md");
+    if (!existsSync(identityPath)) {
+      try {
+        writeFileSync(
+          identityPath,
+          `# Identity\n\n- Name: ${assistantName}\n`,
+          "utf-8",
+        );
+      } catch (err) {
+        log.warn(
+          { err, identityPath },
+          "Failed to seed IDENTITY.md from onboarding",
+        );
+      }
+    }
+  }
+
+  const userName = onboarding.userName?.trim();
+  if (userName) {
+    const userPath = getWorkspacePromptPath("USER.md");
+    if (!existsSync(userPath)) {
+      try {
+        writeFileSync(userPath, `# User\n\n- Name: ${userName}\n`, "utf-8");
+      } catch (err) {
+        log.warn({ err, userPath }, "Failed to seed USER.md from onboarding");
+      }
+    }
+  }
+
+  void writeRelationshipState().catch((err) => {
+    log.warn(
+      { err },
+      "Failed to kick off relationship-state write after onboarding",
+    );
+  });
+}
+
 export async function handleSendMessage(
   req: Request,
   deps: {
@@ -1120,9 +1339,19 @@ export async function handleSendMessage(
     bypassSecretCheck?: boolean;
     hostHomeDir?: string;
     hostUsername?: string;
+    clientMessageId?: string;
+    onboarding?: {
+      tools: string[];
+      tasks: string[];
+      tone: string;
+      userName?: string;
+      assistantName?: string;
+    };
   };
 
   const { conversationKey, content, attachmentIds } = body;
+  const clientMessageId =
+    typeof body.clientMessageId === "string" ? body.clientMessageId : undefined;
   if (!body.sourceChannel || typeof body.sourceChannel !== "string") {
     return httpError("BAD_REQUEST", "sourceChannel is required", 400);
   }
@@ -1222,8 +1451,32 @@ export async function handleSendMessage(
   const mapping = getOrCreateConversation(resolvedConversationKey, {
     conversationType,
   });
+
   const smDeps = deps.sendMessageDeps;
 
+  // Notify all connected clients that the conversation list changed when
+  // this is the first message in a standard conversation, so sidebars on
+  // other devices can refresh. We check for first-message rather than
+  // first-create because the SSE subscribe handler (events-routes.ts) may
+  // have already materialised the conversation from a draft key before any
+  // message was sent — in that case `mapping.created` is `false` even
+  // though, from the user's perspective, this is a brand-new conversation
+  // that other clients don't yet know about.
+  if (mapping.conversationType === "standard") {
+    if (!hasMessages(mapping.conversationId)) {
+      smDeps.assistantEventHub
+        .publish(
+          buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+            type: "conversation_list_invalidated",
+            reason: "created",
+          }),
+        )
+        .catch((err) => {
+          log.warn({ err }, "Failed to publish conversation_list_invalidated");
+        });
+    }
+  }
+
   // Build transport metadata from the request so the daemon can inject
   // host environment hints (home directory, username) into the LLM context.
   // The `supportsHostProxy` type predicate narrows `sourceInterface` to
@@ -1247,6 +1500,17 @@ export async function handleSendMessage(
     { transport },
   );
 
+  // Store pre-chat onboarding context on the conversation when this is the
+  // very first message (no prior messages loaded). Also persist the
+  // onboarding selections so the Home page shows onboarding-sourced
+  // chips immediately, and seed IDENTITY.md / USER.md so subsequent
+  // turn-boundary recomputes of relationship-state have a stable
+  // persona source beyond the in-memory conversation object.
+  if (body.onboarding && conversation.messages.length === 0) {
+    conversation.setOnboardingContext(body.onboarding);
+    persistOnboardingArtifacts(body.onboarding);
+  }
+
   // Resolve guardian context from the AuthContext's actorPrincipalId.
   // The JWT-verified principal is used as the sender identity through
   // the same trust resolution pipeline that channel ingress uses.
@@ -1328,66 +1592,44 @@ export async function handleSendMessage(
   } else if (!conversation.isProcessing()) {
     conversation.setHostBashProxy(undefined);
   }
-  // For the chrome-extension interface we route host_browser_request /
-  // host_browser_cancel frames through the in-process ChromeExtensionRegistry
-  // to the WebSocket opened against /v1/browser-relay by the connected
-  // extension, instead of the SSE/onEvent hub used by macOS. The registry
-  // lookup is keyed by the JWT-derived actor principal id, which the
-  // runtime captured at WebSocket upgrade time.
-  //
-  // A single guardian may have multiple parallel extension installs
-  // connected at once (two Chrome profiles, two desktops). The registry
-  // tracks them under (guardianId, clientInstanceId) pairs and the
-  // default `send(guardianId, msg)` path routes to whichever instance
-  // has the most recent activity — typically the one the user is
-  // currently driving. Pinning to a specific instance can be done via
-  // `sendToInstance` if a caller ever needs it.
-  //
-  // macOS (and any other interface that supports host_browser in the
-  // future via the SSE hub) keeps using `onEvent` — see the else branch.
-  const browserProxySendToClient: (msg: ServerMessage) => void =
-    sourceInterface === "chrome-extension"
-      ? (msg) => {
-          // Resolve the guardian principal id at send time rather than
-          // capturing it from the POST-time authContext. This closure can be
-          // re-fired on queue drain — if a different actor's POST lands while
-          // the queue is still draining an earlier turn, a captured
-          // authContext.actorPrincipalId would mis-route the earlier turn's
-          // host_browser frames to the *new* actor. Preferring
-          // conversation.trustContext?.guardianPrincipalId makes the routing
-          // follow the conversation's bound guardian, which is stable across
-          // subsequent POSTs. Falls back to the per-POST authContext for
-          // turns that haven't been bound to a trust context yet.
-          const gid =
-            conversation.trustContext?.guardianPrincipalId ??
-            authContext.actorPrincipalId;
-          if (!gid) {
-            // No guardian identity on this turn — nothing to route to.
-            // The proxy will observe this via its try/catch and surface a
-            // transport error back to the caller.
-            throw new Error(
-              "chrome-extension host_browser send skipped: no guardianId on AuthContext",
-            );
-          }
-          const ok = getChromeExtensionRegistry().send(gid, msg);
-          if (!ok) {
-            throw new Error(
-              `chrome-extension host_browser send failed: no active connection for guardian ${gid}`,
-            );
-          }
-        }
-      : onEvent;
+  // Resolve the host_browser sender — registry-routed when the guardian has
+  // an active extension connection, SSE hub otherwise. This applies to both
+  // chrome-extension and macOS interfaces so that macOS turns can route
+  // browser automation through the user's real Chrome session when available.
+  const { sender: browserProxySendToClient, isRegistryRouted } =
+    resolveHostBrowserSender(
+      conversation,
+      mapping.conversationId,
+      authContext,
+      onEvent,
+      sourceInterface,
+    );
+
   // Stash the registry-routed sender on the conversation so queue-drain
   // restores (which run outside of conversation-routes.ts and only have
   // access to `sendToClient`) can preserve it when calling
-  // `restoreBrowserProxyAvailability()`. For non-chrome-extension
-  // interfaces the override is cleared so the SSE hub sender is used.
-  if (sourceInterface === "chrome-extension") {
+  // `restoreBrowserProxyAvailability()`. The override is set when the
+  // sender is registry-routed (regardless of interface) and cleared when
+  // the SSE hub sender is used, so the drain path always restores the
+  // correct transport.
+  if (isRegistryRouted) {
     conversation.hostBrowserSenderOverride = browserProxySendToClient;
   } else {
     conversation.hostBrowserSenderOverride = undefined;
   }
-  if (supportsHostProxy(sourceInterface, "host_browser")) {
+
+  // Provision the host browser proxy. For interfaces that natively support
+  // host_browser (chrome-extension), always provision it. For macOS, the
+  // static capability check returns false (supportsHostProxy("macos",
+  // "host_browser") === false) because the extension isn't guaranteed to be
+  // attached — but when the registry confirms an active extension
+  // connection, we provision the proxy anyway so macOS turns can drive the
+  // user's real Chrome session. When no extension is connected, macOS skips
+  // provisioning and browser tools fall through to cdp-inspect/local.
+  const shouldProvisionBrowserProxy =
+    supportsHostProxy(sourceInterface, "host_browser") ||
+    (canServiceRegistryBrowser(sourceInterface) && isRegistryRouted);
+  if (shouldProvisionBrowserProxy) {
     if (!conversation.isProcessing() || !conversation.hostBrowserProxy) {
       const browserProxy = new HostBrowserProxy(
         browserProxySendToClient,
@@ -1445,18 +1687,17 @@ export async function handleSendMessage(
   conversation.updateClient(onEvent, !isInteractive, {
     skipProxySenderUpdate: preservingProxies,
   });
-  // For non-interactive interfaces that DO support host_browser
-  // (chrome-extension), explicitly re-enable just the browser proxy. The
-  // helper bypasses the `hasNoClient` gate so the single-capability
-  // chrome-extension turn can drive the browser via CDP without leaking
-  // host_bash/host_file tool availability into tool gating.
+  // Re-enable the browser proxy for turns that provisioned one. This covers:
+  // - chrome-extension: natively supports host_browser (non-interactive but
+  //   has a connected client for host_browser_request events)
+  // - macOS with extension: provisioned above when isRegistryRouted is true
   //
-  // `restoreBrowserProxyAvailability()` reads `hostBrowserSenderOverride`
-  // (set above for chrome-extension) and applies the registry-routed
-  // sender, so the chrome-extension path gets the correct sender here
-  // — including after queue-drain restores run from conversation-process.ts,
-  // which only have access to the conversation instance.
-  if (supportsHostProxy(sourceInterface, "host_browser")) {
+  // The helper bypasses the `hasNoClient` gate so chrome-extension turns can
+  // drive the browser via CDP without leaking host_bash/host_file tool
+  // availability. It reads `hostBrowserSenderOverride` (set above when
+  // registry-routed) and applies the correct sender — including after
+  // queue-drain restores run from conversation-process.ts.
+  if (shouldProvisionBrowserProxy) {
     conversation.restoreBrowserProxyAvailability?.();
   }
 
@@ -1522,6 +1763,13 @@ export async function handleSendMessage(
         // fast path) so the HTTP response reaches the client before SSE
         // events arrive.
         setTimeout(() => {
+          onEvent({
+            type: "user_message_echo",
+            text: rawContent,
+            conversationId,
+            messageId: persisted.id,
+            clientMessageId,
+          });
           onEvent({ type: "assistant_text_delta", text: cannedGreeting });
           onEvent({ type: "message_complete", conversationId });
           conversation.processing = false;
@@ -1618,6 +1866,7 @@ export async function handleSendMessage(
       { isInteractive },
       undefined, // displayContent
       transport,
+      clientMessageId,
     );
     if (enqueueResult.rejected) {
       return Response.json(
@@ -1730,9 +1979,9 @@ export async function handleSendMessage(
     messageCount: conversation.getMessages().length,
     inputTokens: conversation.usageStats.inputTokens,
     outputTokens: conversation.usageStats.outputTokens,
-    maxInputTokens: config.contextWindow.maxInputTokens,
-    model: config.services.inference.model,
-    provider: config.services.inference.provider,
+    maxInputTokens: config.llm.default.contextWindow.maxInputTokens,
+    model: config.llm.default.model,
+    provider: config.llm.default.provider,
     estimatedCost: conversation.usageStats.estimatedCost,
     userMessageInterface: sourceInterface,
   };
@@ -1815,6 +2064,13 @@ export async function handleSendMessage(
       const conversationId = mapping.conversationId;
       const message = slashResult.message;
       setTimeout(() => {
+        onEvent({
+          type: "user_message_echo",
+          text: rawContent,
+          conversationId,
+          messageId: persisted.id,
+          clientMessageId,
+        });
         if (modelInfoEvent) {
           onEvent(modelInfoEvent);
         }
@@ -1841,80 +2097,89 @@ export async function handleSendMessage(
 
   if (slashResult.kind === "compact") {
     conversation.processing = true;
-    let cleanupDeferred = false;
-    try {
-      const provenance = provenanceFromTrustContext(conversation.trustContext);
-      const channelMeta = {
-        ...provenance,
-        userMessageChannel: sourceChannel,
-        assistantMessageChannel: sourceChannel,
-        userMessageInterface: sourceInterface,
-        assistantMessageInterface: sourceInterface,
-      };
-      const cleanMsg = createUserMessage(rawContent, attachments);
-      const persisted = await addMessage(
-        mapping.conversationId,
-        "user",
-        JSON.stringify(cleanMsg.content),
-        channelMeta,
-      );
-      conversation.getMessages().push(cleanMsg);
-
-      conversation.emitActivityState(
-        "thinking",
-        "context_compacting",
-        "assistant_turn",
-      );
-      const result = await conversation.forceCompact();
-      const responseText = formatCompactResult(result);
+    const provenance = provenanceFromTrustContext(conversation.trustContext);
+    const channelMeta = {
+      ...provenance,
+      userMessageChannel: sourceChannel,
+      assistantMessageChannel: sourceChannel,
+      userMessageInterface: sourceInterface,
+      assistantMessageInterface: sourceInterface,
+    };
+    const cleanMsg = createUserMessage(rawContent, attachments);
+    const persisted = await addMessage(
+      mapping.conversationId,
+      "user",
+      JSON.stringify(cleanMsg.content),
+      channelMeta,
+    );
+    conversation.getMessages().push(cleanMsg);
 
-      const assistantMsg = createAssistantMessage(responseText);
-      await addMessage(
-        mapping.conversationId,
-        "assistant",
-        JSON.stringify(assistantMsg.content),
-        channelMeta,
-      );
-      conversation.getMessages().push(assistantMsg);
+    const conversationId = mapping.conversationId;
 
-      const response = Response.json(
-        {
-          accepted: true,
+    // Fire-and-forget: return 202 immediately, run compaction async.
+    // forceCompact() makes an LLM call that can exceed the client's
+    // HTTP timeout on large contexts, causing a false "Failed to send".
+    (async () => {
+      try {
+        onEvent({
+          type: "user_message_echo",
+          text: rawContent,
+          conversationId,
           messageId: persisted.id,
-          conversationId: mapping.conversationId,
-        },
-        { status: 202 },
-      );
+          clientMessageId,
+        });
+        conversation.emitActivityState(
+          "thinking",
+          "context_compacting",
+          "assistant_turn",
+        );
+        const result = await conversation.forceCompact();
+        const responseText = formatCompactResult(result);
+
+        const assistantMsg = createAssistantMessage(responseText);
+        await addMessage(
+          conversationId,
+          "assistant",
+          JSON.stringify(assistantMsg.content),
+          channelMeta,
+        );
+        conversation.getMessages().push(assistantMsg);
 
-      const conversationId = mapping.conversationId;
-      setTimeout(() => {
         onEvent({ type: "assistant_text_delta", text: responseText });
+        onEvent({ type: "message_complete", conversationId });
+      } catch (err) {
+        log.error({ err, conversationId }, "Compact command failed");
         onEvent({
-          type: "message_complete",
+          type: "conversation_error",
           conversationId,
+          code: "UNKNOWN",
+          userMessage: `Compaction failed: ${err instanceof Error ? err.message : String(err)}`,
+          retryable: true,
         });
+      } finally {
         conversation.processing = false;
         silentlyWithLog(
           conversation.drainQueue(),
           "compact-command queue drain",
         );
-      }, 0);
-
-      cleanupDeferred = true;
-      return response;
-    } finally {
-      if (!cleanupDeferred && conversation.processing) {
-        conversation.processing = false;
-        silentlyWithLog(conversation.drainQueue(), "error-path queue drain");
       }
-    }
+    })();
+
+    return Response.json(
+      {
+        accepted: true,
+        messageId: persisted.id,
+        conversationId,
+      },
+      { status: 202 },
+    );
   }
 
   const resolvedContent = slashResult.content;
 
+  const requestId = crypto.randomUUID();
   let messageId: string;
   try {
-    const requestId = crypto.randomUUID();
     messageId = await conversation.persistUserMessage(
       resolvedContent,
       attachments,
@@ -1925,6 +2190,15 @@ export async function handleSendMessage(
     throw err;
   }
 
+  onEvent({
+    type: "user_message_echo",
+    text: resolvedContent,
+    conversationId: mapping.conversationId,
+    messageId,
+    requestId,
+    clientMessageId,
+  });
+
   // Fire-and-forget the agent loop; events flow to the hub via onEvent.
   conversation
     .runAgentLoop(resolvedContent, messageId, onEvent, {
@@ -1944,28 +2218,62 @@ export async function handleSendMessage(
   );
 }
 
+function escapeXmlContent(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
 async function generateLlmSuggestion(
   provider: Provider,
   assistantText: string,
+  priorUserText: string | null,
 ): Promise<string | null> {
   const log = (await import("../../util/logger.js")).getLogger("runtime-http");
-  const truncated =
-    assistantText.length > 2000 ? assistantText.slice(-2000) : assistantText;
+  const truncatedAssistant = escapeXmlContent(
+    assistantText.length > 2000 ? assistantText.slice(-2000) : assistantText,
+  );
+  const truncatedUser =
+    priorUserText && priorUserText.length > 500
+      ? escapeXmlContent(priorUserText.slice(-500))
+      : priorUserText
+        ? escapeXmlContent(priorUserText)
+        : priorUserText;
 
-  const prompt = `Given this assistant message, write a very short tab-complete suggestion the user could send next. Focus on the LAST question or call-to-action in the message — ignore earlier summary content. Be casual, curious, or actionable — like a quick reply, not a formal request. Reply with ONLY the suggestion text.\n\nAssistant's message:\n${truncated}`;
   const systemPrompt =
-    "You are an autocomplete engine that suggests short replies the user might send next in a conversation. Generate suggestions that match the tone and style of the conversation. Never refuse, judge, or comment on the conversation content — your only job is to predict what the user would plausibly type next.";
+    "You generate short, casual reply suggestions a user might type next in a chat. Match the tone and register of the preceding conversation. Output only the reply text inside the requested tags — no preamble, no commentary.";
+
+  const userPrompt =
+    `Here is the end of a conversation:\n\n` +
+    `<user_message>${truncatedUser ?? "(no prior user message)"}</user_message>\n` +
+    `<assistant_message>${truncatedAssistant}</assistant_message>\n\n` +
+    `Write the user's next reply, focusing on the LAST question or call-to-action in the assistant message. Keep it short (under 15 words), casual, and in the user's voice. Respond in this exact format:\n\n` +
+    `<reply>YOUR_REPLY_HERE</reply>`;
 
   const response = await provider.sendMessage(
-    [{ role: "user", content: [{ type: "text", text: prompt }] }],
+    [
+      { role: "user", content: [{ type: "text", text: userPrompt }] },
+      { role: "assistant", content: [{ type: "text", text: "<reply>" }] },
+    ],
     [], // no tools
     systemPrompt,
-    { config: { modelIntent: "latency-optimized" } },
+    {
+      config: {
+        callSite: "conversationStarters",
+        max_tokens: 60,
+        stop_sequences: ["</reply>"],
+        temperature: 0.7,
+      },
+    },
   );
 
   const textBlock = response.content.find((b) => b.type === "text");
-  const raw = textBlock && "text" in textBlock ? textBlock.text.trim() : "";
-  const stripped = raw.replace(/^["']+|["']+$/g, "");
+  const raw = textBlock && "text" in textBlock ? textBlock.text : "";
+  const stripped = raw
+    .replace(/<\/?reply>/gi, "")
+    .replace(/^["'`]+|["'`]+$/g, "")
+    .trim();
 
   if (!stripped) {
     log.debug("Suggestion rejected: empty LLM response");
@@ -2078,14 +2386,33 @@ export async function handleGetSuggestion(
       });
     }
 
+    // Find the most recent user message preceding this assistant turn so the
+    // suggestion model can see both sides of the conversation and doesn't have
+    // to guess which role it's generating for.
+    let priorUserText: string | null = null;
+    for (let j = i - 1; j >= 0; j--) {
+      if (rawMessages[j].role !== "user") continue;
+      let userContent: unknown;
+      try {
+        userContent = JSON.parse(rawMessages[j].content);
+      } catch {
+        userContent = rawMessages[j].content;
+      }
+      const userText = renderHistoryContent(userContent).text.trim();
+      if (userText) {
+        priorUserText = userText;
+        break;
+      }
+    }
+
     // Try LLM suggestion using the configured provider
-    const provider = await getConfiguredProvider();
+    const provider = await getConfiguredProvider("conversationStarters");
     if (provider) {
       try {
         // Deduplicate concurrent requests
         let promise = suggestionInFlight.get(msg.id);
         if (!promise) {
-          promise = generateLlmSuggestion(provider, text);
+          promise = generateLlmSuggestion(provider, text, priorUserText);
           suggestionInFlight.set(msg.id, promise);
         }