@vellumai/assistant 0.6.4 → 0.6.6

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

@@ -1,7 +1,13 @@
 /**
  * Route handlers for conversation messages and suggestions.
  */
-import { existsSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import { join, relative } from "node:path";
 
 import { z } from "zod";
@@ -48,10 +54,12 @@ import type {
   NonHostProxyTransportMetadata,
 } from "../../daemon/message-types/conversations.js";
 import type { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
+import { emitFeedEvent } from "../../home/emit-feed-event.js";
 import {
   writeOnboardingSidecar,
   writeRelationshipState,
 } from "../../home/relationship-state-writer.js";
+import { rewriteCommandPreview } from "../../home/rewrite-command-preview.js";
 import * as attachmentsStore from "../../memory/attachments-store.js";
 import {
   createCanonicalGuardianRequest,
@@ -65,6 +73,7 @@ import {
   getLastAssistantTimestampBefore,
   getMessages,
   getMessagesPaginated,
+  hasMessages,
   type MessageRow,
   provenanceFromTrustContext,
   setConversationOriginChannelIfUnset,
@@ -87,6 +96,7 @@ import { buildAssistantEvent } from "../assistant-event.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import type { AuthContext } from "../auth/types.js";
 import { getChromeExtensionRegistry } from "../chrome-extension-registry.js";
+import { getClientRegistry } from "../client-registry.js";
 import { bridgeConfirmationRequestToGuardian } from "../confirmation-request-guardian-bridge.js";
 import { routeGuardianReply } from "../guardian-reply-router.js";
 import { healGuardianBindingDrift } from "../guardian-vellum-migration.js";
@@ -997,6 +1007,54 @@ function makeHubPublisher(
         },
       });
 
+      const inputRecord = msg.input as Record<string, unknown>;
+      const commandPreview =
+        redactSecrets(summarizeToolInput(msg.toolName, inputRecord)) ||
+        undefined;
+      const technicalTitle = commandPreview
+        ? `Requesting permission: ${commandPreview}`
+        : `Requesting approval to use ${msg.toolName}.`;
+      const dedupKey = `tool-approval:${msg.requestId}`;
+
+      // Emit immediately with the technical preview.
+      void emitFeedEvent({
+        source: "assistant",
+        title: technicalTitle,
+        summary: technicalTitle,
+        dedupKey,
+        urgency: msg.riskLevel === "high" ? "high" : "medium",
+        conversationId,
+      }).catch((err) => {
+        log.warn(
+          { err, requestId: msg.requestId },
+          "Failed to emit tool approval request feed event",
+        );
+      });
+
+      // Background: rewrite into prose and update the feed item.
+      if (commandPreview) {
+        void rewriteCommandPreview(msg.toolName, commandPreview)
+          .then((prose) => {
+            if (prose) {
+              const proseTitle = `Requesting permission: ${prose}`;
+              return emitFeedEvent({
+                source: "assistant",
+                title: proseTitle,
+                summary: proseTitle,
+                dedupKey,
+                urgency: msg.riskLevel === "high" ? "high" : "medium",
+                conversationId,
+              });
+            }
+          })
+          .catch((err) => {
+            log.warn(
+              { err, requestId: msg.requestId },
+              "Failed to update feed event with prose rewrite",
+            );
+          });
+      }
+
       // Create a canonical guardian request so HTTP handlers can find it
       // via applyCanonicalGuardianDecision.
       try {
@@ -1066,7 +1124,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,
@@ -1082,6 +1153,29 @@ 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",
+          );
+        }
+      }
     })();
   };
 }
@@ -1234,7 +1328,7 @@ function resolveHostBrowserSender(
  * failure. The route handler path must never reject because of a
  * best-effort persistence step.
  */
-function persistOnboardingArtifacts(onboarding: {
+export function persistOnboardingArtifacts(onboarding: {
   tools: string[];
   tasks: string[];
   tone: string;
@@ -1246,31 +1340,49 @@ function persistOnboardingArtifacts(onboarding: {
   const assistantName = onboarding.assistantName?.trim();
   if (assistantName) {
     const identityPath = getWorkspacePromptPath("IDENTITY.md");
-    if (!existsSync(identityPath)) {
-      try {
+    try {
+      if (existsSync(identityPath)) {
+        const content = readFileSync(identityPath, "utf-8");
+        const updated = content.replace(
+          /^- (?:\*\*)?Name:(?:\*\*)?\s*.*$/m,
+          () => `- **Name:** ${assistantName}`,
+        );
+        if (updated !== content) {
+          writeFileSync(identityPath, updated, "utf-8");
+        }
+      } else {
         writeFileSync(
           identityPath,
-          `# Identity\n\n- Name: ${assistantName}\n`,
+          `# Identity\n\n- **Name:** ${assistantName}\n`,
           "utf-8",
         );
-      } catch (err) {
-        log.warn(
-          { err, identityPath },
-          "Failed to seed IDENTITY.md from onboarding",
-        );
       }
+    } 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");
+    try {
+      if (existsSync(userPath)) {
+        const content = readFileSync(userPath, "utf-8");
+        const updated = content.replace(
+          /^- (?:\*\*)?Name:(?:\*\*)?\s*.*$/m,
+          () => `- **Name:** ${userName}`,
+        );
+        if (updated !== content) {
+          writeFileSync(userPath, updated, "utf-8");
+        }
+      } else {
+        writeFileSync(userPath, `# User\n\n- **Name:** ${userName}\n`, "utf-8");
       }
+    } catch (err) {
+      log.warn({ err, userPath }, "Failed to seed USER.md from onboarding");
     }
   }
 
@@ -1302,6 +1414,8 @@ export async function handleSendMessage(
     bypassSecretCheck?: boolean;
     hostHomeDir?: string;
     hostUsername?: string;
+    clientId?: string;
+    clientMessageId?: string;
     onboarding?: {
       tools: string[];
       tasks: string[];
@@ -1312,6 +1426,8 @@ export async function handleSendMessage(
   };
 
   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);
   }
@@ -1414,19 +1530,27 @@ export async function handleSendMessage(
 
   const smDeps = deps.sendMessageDeps;
 
-  // Notify all connected clients that the conversation list changed when a
-  // new standard conversation is created so sidebars can refresh.
-  if (mapping.created && mapping.conversationType === "standard") {
-    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");
-      });
+  // 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
@@ -1447,20 +1571,37 @@ export async function handleSendMessage(
         interfaceId: sourceInterface,
       } satisfies NonHostProxyTransportMetadata);
 
+  // Register/refresh the client in the unified client registry so
+  // `assistant clients list` can discover all connected interfaces.
+  // Uses the client-supplied clientId when available (stable per-install
+  // UUID), falling back to a synthetic key derived from interfaceId so
+  // older clients that don't send clientId still appear in the registry.
+  const effectiveClientId =
+    typeof body.clientId === "string" && body.clientId.length > 0
+      ? body.clientId
+      : `synthetic:${sourceInterface}`;
+  getClientRegistry().register({
+    clientId: effectiveClientId,
+    interfaceId: sourceInterface,
+    hostHomeDir: body.hostHomeDir,
+    hostUsername: body.hostUsername,
+  });
+
   const conversation = await smDeps.getOrCreateConversation(
     mapping.conversationId,
     { 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);
+  // very first message (no prior messages loaded). Artifact persistence
+  // (IDENTITY.md, USER.md, sidecar) is deferred: on the canned greeting
+  // path it runs inside the setTimeout right before warmPromptCache() so
+  // the warmed system prompt includes the identity; on the normal LLM
+  // path it runs immediately before inference starts.
+  const isFirstOnboarding =
+    !!body.onboarding && conversation.messages.length === 0;
+  if (isFirstOnboarding) {
+    conversation.setOnboardingContext(body.onboarding!);
   }
 
   // Resolve guardian context from the AuthContext's actorPrincipalId.
@@ -1570,14 +1711,13 @@ export async function handleSendMessage(
     conversation.hostBrowserSenderOverride = undefined;
   }
 
-  // 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.
+  // Provision the host browser proxy. Both macOS and chrome-extension
+  // natively support host_browser. For macOS, the proxy is wired to the
+  // SSE sender by default so `host_browser_request` frames reach the
+  // desktop client directly. When the guardian also has an active extension
+  // connection (isRegistryRouted), the registry-routed sender is used
+  // instead so browser tools route through the user's real Chrome session.
+  // For chrome-extension, the registry sender is always used.
   const shouldProvisionBrowserProxy =
     supportsHostProxy(sourceInterface, "host_browser") ||
     (canServiceRegistryBrowser(sourceInterface) && isRegistryRouted);
@@ -1640,9 +1780,10 @@ export async function handleSendMessage(
     skipProxySenderUpdate: preservingProxies,
   });
   // Re-enable the browser proxy for turns that provisioned one. This covers:
+  // - macOS: always provisioned (SSE sender or registry-routed when extension
+  //   is connected)
   // - 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
   //
   // The helper bypasses the `hasNoClient` gate so chrome-extension turns can
   // drive the browser via CDP without leaking host_bash/host_file tool
@@ -1655,96 +1796,102 @@ export async function handleSendMessage(
 
   // ── Canned first-greeting fast path ──
   // On a completely fresh workspace, skip LLM inference for the macOS
-  // wake-up greeting and return a pre-written response. This eliminates
-  // 10-30s of inference latency on first boot.
+  // wake-up greeting and return a pre-written response. When onboarding
+  // context is present the greeting is personalized using the selections;
+  // otherwise a generic greeting is served. Both paths are instant.
   if (isWakeUpGreeting(trimmedContent, conversation.getMessages().length)) {
-    const cannedGreeting = getCannedFirstGreeting();
-    if (cannedGreeting) {
-      conversation.processing = true;
-      let cleanupDeferred = false;
-      try {
-        const provenance = provenanceFromTrustContext(
-          conversation.trustContext,
-        );
-        const channelMeta = {
-          ...provenance,
-          userMessageChannel: sourceChannel,
-          assistantMessageChannel: sourceChannel,
-          userMessageInterface: sourceInterface,
-          assistantMessageInterface: sourceInterface,
-        };
-
-        const rawContent = content ?? "";
-        const attachments = hasAttachments
-          ? smDeps.resolveAttachments(attachmentIds)
-          : [];
-        const userMsg = createUserMessage(rawContent, attachments);
-        const persisted = await addMessage(
-          mapping.conversationId,
-          "user",
-          JSON.stringify(userMsg.content),
-          channelMeta,
-        );
-        conversation.getMessages().push(userMsg);
+    const cannedGreeting = getCannedFirstGreeting(body.onboarding ?? undefined);
 
-        setConversationOriginChannelIfUnset(
-          mapping.conversationId,
-          sourceChannel,
-        );
-        setConversationOriginInterfaceIfUnset(
-          mapping.conversationId,
-          sourceInterface,
-        );
+    conversation.processing = true;
+    let cleanupDeferred = false;
+    try {
+      const provenance = provenanceFromTrustContext(conversation.trustContext);
+      const channelMeta = {
+        ...provenance,
+        userMessageChannel: sourceChannel,
+        assistantMessageChannel: sourceChannel,
+        userMessageInterface: sourceInterface,
+        assistantMessageInterface: sourceInterface,
+      };
 
-        const assistantMsg = createAssistantMessage(cannedGreeting);
-        await addMessage(
-          mapping.conversationId,
-          "assistant",
-          JSON.stringify(assistantMsg.content),
-          channelMeta,
-        );
-        conversation.getMessages().push(assistantMsg);
+      const rawContent = content ?? "";
+      const attachments = hasAttachments
+        ? smDeps.resolveAttachments(attachmentIds)
+        : [];
+      const userMsg = createUserMessage(rawContent, attachments);
+      const persisted = await addMessage(
+        mapping.conversationId,
+        "user",
+        JSON.stringify(userMsg.content),
+        channelMeta,
+      );
+      conversation.getMessages().push(userMsg);
 
-        const conversationId = mapping.conversationId;
-        const response = Response.json(
-          { accepted: true, messageId: persisted.id, conversationId },
-          { status: 202 },
-        );
+      setConversationOriginChannelIfUnset(
+        mapping.conversationId,
+        sourceChannel,
+      );
+      setConversationOriginInterfaceIfUnset(
+        mapping.conversationId,
+        sourceInterface,
+      );
 
-        // Defer event publishing to next tick (same pattern as unknown-slash
-        // 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,
-          });
-          onEvent({ type: "assistant_text_delta", text: cannedGreeting });
-          onEvent({ type: "message_complete", conversationId });
-          conversation.processing = false;
-          silentlyWithLog(
-            conversation.drainQueue(),
-            "canned-greeting queue drain",
-          );
-        }, 0);
+      const conversationId = mapping.conversationId;
+
+      const assistantMsg = createAssistantMessage(cannedGreeting);
+      await addMessage(
+        mapping.conversationId,
+        "assistant",
+        JSON.stringify(assistantMsg.content),
+        channelMeta,
+      );
+      conversation.getMessages().push(assistantMsg);
 
-        log.info(
-          { conversationId },
-          "Served canned first greeting — skipped LLM inference",
+      const response = Response.json(
+        { accepted: true, messageId: persisted.id, conversationId },
+        { status: 202 },
+      );
+
+      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;
+        silentlyWithLog(
+          conversation.drainQueue(),
+          "canned-greeting queue drain",
         );
-        cleanupDeferred = true;
-        return response;
-      } finally {
-        if (!cleanupDeferred && conversation.processing) {
-          conversation.processing = false;
-          silentlyWithLog(conversation.drainQueue(), "error-path queue drain");
+
+        if (isFirstOnboarding) {
+          persistOnboardingArtifacts(body.onboarding!);
         }
+        conversation.warmPromptCache();
+      }, 0);
+
+      log.info(
+        { conversationId, personalized: !!body.onboarding },
+        "Served canned first greeting — skipped LLM inference",
+      );
+      cleanupDeferred = true;
+      return response;
+    } finally {
+      if (!cleanupDeferred && conversation.processing) {
+        conversation.processing = false;
+        silentlyWithLog(conversation.drainQueue(), "error-path queue drain");
       }
     }
   }
 
+  if (isFirstOnboarding) {
+    persistOnboardingArtifacts(body.onboarding!);
+  }
+
   const attachments = hasAttachments
     ? smDeps.resolveAttachments(attachmentIds)
     : [];
@@ -1817,6 +1964,7 @@ export async function handleSendMessage(
       { isInteractive },
       undefined, // displayContent
       transport,
+      clientMessageId,
     );
     if (enqueueResult.rejected) {
       return Response.json(
@@ -1929,9 +2077,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,
   };
@@ -2019,6 +2167,7 @@ export async function handleSendMessage(
           text: rawContent,
           conversationId,
           messageId: persisted.id,
+          clientMessageId,
         });
         if (modelInfoEvent) {
           onEvent(modelInfoEvent);
@@ -2075,6 +2224,7 @@ export async function handleSendMessage(
           text: rawContent,
           conversationId,
           messageId: persisted.id,
+          clientMessageId,
         });
         conversation.emitActivityState(
           "thinking",
@@ -2144,6 +2294,7 @@ export async function handleSendMessage(
     conversationId: mapping.conversationId,
     messageId,
     requestId,
+    clientMessageId,
   });
 
   // Fire-and-forget the agent loop; events flow to the hub via onEvent.
@@ -2165,28 +2316,71 @@ 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>`;
+
+  // Single user message only — no assistant-role prefill. Anthropic
+  // rejects assistant prefill whenever the request triggers extended
+  // thinking (e.g. Opus 4.x at `effort: "xhigh"`), and the call-site
+  // config is user-controlled, so we can't statically guarantee a
+  // prefill-safe model. Keep `stop_sequences: ["</reply>"]` as an
+  // early-termination hint; the parser below handles both tagged and
+  // untagged responses so untagged "casual answer" replies still work.
   const response = await provider.sendMessage(
-    [{ role: "user", content: [{ type: "text", text: prompt }] }],
+    [{ role: "user", content: [{ type: "text", text: userPrompt }] }],
     [], // 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 : "";
+  // Prefer the content inside <reply>…</reply> when the model honors the
+  // tag format. If the response has no tags, fall back to the raw text —
+  // a plain "Sure, tomorrow works" without tags is still a valid chip.
+  const tagMatch = raw.match(/<reply>([\s\S]*?)(?:<\/reply>|$)/i);
+  const extracted = tagMatch ? tagMatch[1] : raw;
+  const stripped = extracted
+    .replace(/<\/?reply>/gi, "")
+    .replace(/^["'`]+|["'`]+$/g, "")
+    .trim();
 
   if (!stripped) {
     log.debug("Suggestion rejected: empty LLM response");
@@ -2299,14 +2493,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);
         }