@vellumai/assistant 0.6.5 → 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,
@@ -88,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";
@@ -998,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 {
@@ -1271,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;
@@ -1283,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");
     }
   }
 
@@ -1339,6 +1414,7 @@ export async function handleSendMessage(
     bypassSecretCheck?: boolean;
     hostHomeDir?: string;
     hostUsername?: string;
+    clientId?: string;
     clientMessageId?: string;
     onboarding?: {
       tools: string[];
@@ -1495,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.
@@ -1618,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);
@@ -1688,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
@@ -1703,97 +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,
-            clientMessageId,
-          });
-          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);
+
+      const response = Response.json(
+        { accepted: true, messageId: persisted.id, conversationId },
+        { status: 202 },
+      );
 
-        log.info(
-          { conversationId },
-          "Served canned first greeting — skipped LLM inference",
+      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)
     : [];
@@ -2251,11 +2349,15 @@ async function generateLlmSuggestion(
     `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: userPrompt }] },
-      { role: "assistant", content: [{ type: "text", text: "<reply>" }] },
-    ],
+    [{ role: "user", content: [{ type: "text", text: userPrompt }] }],
     [], // no tools
     systemPrompt,
     {
@@ -2270,7 +2372,12 @@ async function generateLlmSuggestion(
 
   const textBlock = response.content.find((b) => b.type === "text");
   const raw = textBlock && "text" in textBlock ? textBlock.text : "";
-  const stripped = raw
+  // 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();

package/src/runtime/routes/inbound-message-handler.ts

@@ -21,9 +21,9 @@ import {
 } from "../../memory/conversation-attention-store.js";
 import {
   addMessage,
-  countMessagesWithSlackMeta,
   getMessageById,
   getMessages,
+  selectSlackMetaCandidateMetadata,
   updateMessageMetadata,
 } from "../../memory/conversation-crud.js";
 import * as deliveryChannels from "../../memory/delivery-channels.js";
@@ -1049,14 +1049,21 @@ export async function handleChannelInbound(
       // longer trigger backfill. Failures are non-fatal — the new message
       // proceeds without backfilled history.
       if (sourceChannel === "slack" && sourceChatType === "im") {
+        // Exclude the just-arrived webhook message from the history window —
+        // the normal inbound persistence path writes it separately, so
+        // including it here would produce duplicate user turns. Only pass a
+        // bound when we actually have a Slack ts (`<secs>.<micros>`): the
+        // fallback path writes `externalMessageId` into `channelTs`, but that
+        // identifier is not guaranteed to be a Slack ts, and Slack's
+        // `conversations.history` rejects anything that isn't a ts string.
+        const boundingTs = isSlackTs(sourceMessageId)
+          ? sourceMessageId
+          : undefined;
         await tryBackfillSlackDmIfCold({
           conversationId: result.conversationId,
           channelId: conversationExternalId,
           account: slackAccount,
-          // Exclude the just-arrived webhook message from the history window —
-          // the normal inbound persistence path writes it separately, so
-          // including it here would produce duplicate user turns.
-          latestTs: slackInbound?.channelTs,
+          latestTs: boundingTs,
         });
       }
 
@@ -1245,16 +1252,84 @@ async function persistSlackReactionAsMessage(params: {
 const SLACK_DM_BACKFILL_WARM_THRESHOLD = 3;
 
 /**
- * Count messages in a conversation whose `metadata` carries a `slackMeta`
- * envelope, capped at the warm threshold. Delegates to the DB helper which
- * pushes both `LIKE` and `LIMIT` into SQL so a warm DM conversation never
- * scans beyond the threshold's worth of rows on the webhook critical path.
+ * Shape-check for a Slack `ts` value. Slack IDs messages by `<seconds>.<micros>`
+ * strings (e.g. `"1700000000.000100"`). The daemon also stores an
+ * `externalMessageId` derived from the gateway's dedupe key which follows a
+ * different format, so any path that feeds a ts to Slack's API
+ * (`conversations.history`'s `latest`, etc.) must shape-check first — Slack
+ * rejects non-ts arguments with `invalid_arguments`, and passing a malformed
+ * bound silently disables the intended history window.
+ */
+function isSlackTs(value: string | null | undefined): value is string {
+  return typeof value === "string" && /^\d+\.\d+$/.test(value);
+}
+
+/**
+ * Batch size used when pulling candidate rows from SQL. A bare
+ * `LIKE '%"slackMeta"%'` match can include rows whose metadata JSON is
+ * malformed or carries the literal under an unrelated key, so we fetch in
+ * batches and re-validate each candidate with Zod. The threshold is tiny
+ * (see `SLACK_DM_BACKFILL_WARM_THRESHOLD`), so a 10× batch is a trivial
+ * scan while letting a handful of bad rows not starve the count.
+ */
+const SLACK_DM_CANDIDATE_BATCH_SIZE = SLACK_DM_BACKFILL_WARM_THRESHOLD * 10;
+
+/**
+ * Absolute cap on candidate rows inspected per webhook to classify a DM as
+ * warm. If this many substring matches have been examined without reaching
+ * the valid-row threshold, treat the conversation as cold — a scan this
+ * deep already dominates the critical-path budget and the cold-start
+ * backfill path is itself idempotent against re-runs.
+ */
+const SLACK_DM_CANDIDATE_MAX_SCAN = SLACK_DM_BACKFILL_WARM_THRESHOLD * 20;
+
+/**
+ * Count messages in a conversation whose `metadata` carries a well-formed
+ * `slackMeta` envelope, capped at the warm threshold. SQL prefilters with
+ * `LIKE` + `LIMIT`/`OFFSET` so warm DM conversations never scan the full
+ * table on the webhook critical path, and each candidate is re-validated
+ * through `readSlackMetadata` — a bare substring match would otherwise
+ * wrongly count rows whose metadata is truncated, parses but fails schema
+ * validation, or happens to contain the literal `"slackMeta"` under an
+ * unrelated key. Pulls candidates in batches, continuing until either the
+ * threshold of *valid* rows is reached or the per-call scan cap is hit, so
+ * a cluster of malformed rows at the head of the scan cannot starve the
+ * count and misclassify a warm conversation as cold.
  */
 function countSlackMetaMessages(conversationId: string): number {
-  return countMessagesWithSlackMeta(
-    conversationId,
-    SLACK_DM_BACKFILL_WARM_THRESHOLD,
-  );
+  let count = 0;
+  let offset = 0;
+  while (offset < SLACK_DM_CANDIDATE_MAX_SCAN) {
+    const remaining = SLACK_DM_CANDIDATE_MAX_SCAN - offset;
+    const batchLimit = Math.min(SLACK_DM_CANDIDATE_BATCH_SIZE, remaining);
+    const candidates = selectSlackMetaCandidateMetadata(
+      conversationId,
+      batchLimit,
+      offset,
+    );
+    if (candidates.length === 0) return count;
+    for (const raw of candidates) {
+      let parent: Record<string, unknown> | null = null;
+      try {
+        const parsed = JSON.parse(raw) as unknown;
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          parent = parsed as Record<string, unknown>;
+        }
+      } catch {
+        continue;
+      }
+      if (!parent) continue;
+      const inner = parent.slackMeta;
+      if (typeof inner !== "string") continue;
+      if (readSlackMetadata(inner)) {
+        count++;
+        if (count >= SLACK_DM_BACKFILL_WARM_THRESHOLD) return count;
+      }
+    }
+    if (candidates.length < batchLimit) return count;
+    offset += candidates.length;
+  }
+  return count;
 }
 
 /**

package/src/runtime/routes/memory-item-routes.test.ts

@@ -56,6 +56,7 @@ mock.module("../../memory/qdrant-client.js", () => ({
     searchWithFilter: async () => [...mockHybridSearchResults],
   }),
   initQdrantClient: () => {},
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
 }));
 
 mock.module("../../memory/qdrant-circuit-breaker.js", () => ({

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

@@ -255,9 +255,6 @@ export async function handleMigrationExport(req: Request): Promise<Response> {
     }
 
     const result = await streamExportVBundle({
-      // hooksDir is intentionally omitted — hooks now live under workspace/hooks/
-      // and are included in the workspace walk. Passing hooksDir separately would
-      // export them twice (once as workspace/hooks/... and again as hooks/...).
       workspaceDir: getWorkspaceDir(),
       source: "runtime-export",
       description,