@vellumai/assistant 0.12.3 → 0.12.4-staging.2

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

@@ -22,7 +22,6 @@ import {
   getConfiguredProvider,
   userMessage,
 } from "../../providers/provider-send-message.js";
-import { isMaxTokensStopReason } from "../../providers/stop-reasons.js";
 import { getLogger } from "../../util/logger.js";
 import { safeStringSlice } from "../../util/unicode.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
@@ -73,56 +72,14 @@ function buildAppMetadataBlock(context: DictationContext): string {
   ].join("\n");
 }
 
-function buildCombinedDictationPrompt(
-  body: DictationBody,
-  stylePrompt?: string,
-): string {
-  // Every line here is read on every hold, so the prompt says each thing
-  // once and leaves the model no reasoning to write.
-  const sections = [
-    "You are a voice input assistant. Given a speech transcription, classify it and, if it is dictation, clean it up.",
-    "",
-    "## Classification",
+function buildDictationClassificationPrompt(body: DictationBody): string {
+  return [
+    "Classify the speech transcription without rewriting it.",
     "dictation: the user is composing text to be typed as-is.",
-    "action: the user is asking an assistant to do something (send, message, open, search, create, schedule). Return the transcription unchanged.",
+    "action: the user is asking an assistant to do something (send, message, open, search, create, schedule).",
     `Cursor in text field: ${body.context.cursorInTextField ? "yes" : "no"}. If yes, lean toward dictation unless the intent to command is clear.`,
-    "",
-    "## Cleanup",
-    "- Fix grammar, punctuation and capitalization; remove filler words",
-    "- Rewrite hedging into clear statements, keeping the speaker's meaning",
-    "- When the speaker enumerates items, lay them out as a list, one per line",
-    "- Keep the user's natural voice; do not over-formalize casual speech",
-  ];
-
-  if (stylePrompt) {
-    sections.push(
-      "",
-      "## User Style (highest priority)",
-      "The user's own writing preferences. They override the tone guidance below.",
-      "",
-      stylePrompt,
-    );
-  }
-
-  sections.push(
-    "",
-    "## Tone",
-    stylePrompt
-      ? "Fallback guidance where the User Style above is silent:"
-      : "Adapt tone to the active application:",
-    "- Email: professional but warm, greetings and sign-offs where they fit",
-    "- Slack: casual and conversational",
-    "- Code editors: technical and concise",
-    "- Terminal: terse, command-like",
-    "- Messages: very casual, short sentences",
-    "- Notes and docs: neutral, clear writing",
-    "- Otherwise: the user's natural voice",
-    "The window title may name the recipient; adapt formality to the apparent relationship.",
-    "",
     buildAppMetadataBlock(body.context),
-  );
-
-  return sections.join("\n");
+  ].join("\n");
 }
 
 function buildCommandPrompt(body: DictationBody, stylePrompt?: string): string {
@@ -184,44 +141,10 @@ function buildCommandPrompt(body: DictationBody, stylePrompt?: string): string {
 
 export function computeMaxTokens(inputLength: number): number {
   const estimatedInputTokens = Math.ceil(inputLength / 3);
-  // The cleanup tool call carries the whole transcript back in its `text`
-  // argument, plus a `reasoning` string and the JSON scaffolding around both,
-  // so the budget has to cover well more than the input alone. `max_tokens` is
-  // a ceiling rather than a target: a call that stops short of it costs no
-  // extra latency.
+  // Leave room for the transformed selection and tool-call JSON.
   return Math.max(512, estimatedInputTokens * 2 + 256);
 }
 
-export type CleanupRejection = "truncated";
-
-/**
- * Decide whether the cleanup model's rewrite is safe to use as the payload.
- *
- * The rewrite replaces what the user actually said. A token-cap stop means the
- * tool JSON was cut mid-argument, so however complete the `text` argument
- * happens to look, it is a fragment; the raw transcript is the safer payload
- * then. Unpolished beats wrong.
- *
- * Whether a shorter rewrite still preserved the meaning is the model's call
- * (the prompt asks it to drop fillers and tighten phrasing), so there is no
- * length check here: a deterministic ratio cannot tell a concise cleanup from
- * a summary.
- */
-export function resolveCleanedDictation(
-  raw: string,
-  cleaned: string,
-  stopReason: string | null | undefined,
-): { text: string; rejected: CleanupRejection | null } {
-  const trimmed = cleaned.trim();
-  if (!trimmed) {
-    return { text: raw, rejected: null };
-  }
-  if (isMaxTokensStopReason(stopReason)) {
-    return { text: raw, rejected: "truncated" };
-  }
-  return { text: trimmed, rejected: null };
-}
-
 interface DictationResult {
   text: string;
   mode: DictationMode;
@@ -263,174 +186,88 @@ async function handleDictation(body: DictationBody): Promise<DictationResult> {
     return handleCommandMode(body, profile, profileMeta, stylePrompt);
   }
 
-  // Non-command: single LLM call that classifies AND cleans in one shot
-  const transcription = expandSnippets(body.transcription, profile.snippets);
+  const mode = await classifyDictation(body);
+  if (mode === "action") {
+    return {
+      text: body.transcription,
+      mode,
+      actionPlan: `User wants to: ${body.transcription}`,
+      ...profileMeta,
+    };
+  }
 
-  // Covers provider resolution as well as the call, which is what the caller
-  // waits for.
-  const modelStartedAt = Date.now();
+  // Only explicit user-authored replacements may change dictated words.
+  const text = applyDictionary(
+    expandSnippets(body.transcription, profile.snippets),
+    profile.dictionary,
+  );
+  return { text, mode, ...profileMeta };
+}
+
+async function classifyDictation(
+  body: DictationBody,
+): Promise<"dictation" | "action"> {
   try {
     const provider = await getConfiguredProvider("interactionClassifier");
-    if (!provider) {
-      log.warn(
-        "Dictation: no provider available, using heuristic + raw transcription",
+    if (provider) {
+      const { signal, cleanup } = createTimeout(
+        DICTATION_CLASSIFICATION_TIMEOUT_MS,
       );
-      // Build a compatible msg for the heuristic
-      const mode = detectDictationModeHeuristic({
-        type: "dictation_request",
-        transcription: body.transcription,
-        context: body.context,
-      } as DictationRequest);
-      const normalizedText = applyDictionary(transcription, profile.dictionary);
-      if (mode === "action") {
-        return {
-          text: body.transcription,
-          mode: "action",
-          actionPlan: `User wants to: ${body.transcription}`,
-          ...profileMeta,
-        };
-      }
-      return {
-        text: normalizedText,
-        mode,
-        ...profileMeta,
-      };
-    }
-
-    const systemPrompt = buildCombinedDictationPrompt(body, stylePrompt);
-    const maxTokens = computeMaxTokens(transcription.length);
-    const { signal, cleanup } = createTimeout(
-      DICTATION_CLASSIFICATION_TIMEOUT_MS,
-    );
-
-    try {
-      const response = await provider.sendMessage(
-        [userMessage(`Transcription: "${transcription}"`)],
-        {
-          tools: [
-            {
-              name: "process_dictation",
-              description: "Classify the voice input and return cleaned text",
-              input_schema: {
-                type: "object" as const,
-                properties: {
-                  mode: {
-                    type: "string",
-                    enum: ["dictation", "action"],
-                    description:
-                      "dictation = user wants text inserted/cleaned up for typing. action = user wants the assistant to perform a task.",
-                  },
-                  text: {
-                    type: "string",
-                    description:
-                      "If dictation: the cleaned/formatted text ready for insertion. If action: the raw transcription unchanged.",
+      try {
+        const response = await provider.sendMessage(
+          [userMessage(body.transcription)],
+          {
+            tools: [
+              {
+                name: "process_dictation",
+                description: "Classify the voice input",
+                input_schema: {
+                  type: "object" as const,
+                  properties: {
+                    mode: {
+                      type: "string",
+                      enum: ["dictation", "action"],
+                      description:
+                        "dictation = user wants text inserted. action = user wants the assistant to perform a task.",
+                    },
                   },
+                  required: ["mode"],
                 },
-                required: ["mode", "text"],
               },
+            ],
+            systemPrompt: buildDictationClassificationPrompt(body),
+            config: {
+              callSite: "interactionClassifier",
+              max_tokens: 512,
+              tool_choice: { type: "tool" as const, name: "process_dictation" },
             },
-          ],
-          systemPrompt,
-          config: {
-            callSite: "interactionClassifier",
-            max_tokens: maxTokens,
-            tool_choice: {
-              type: "tool" as const,
-              name: "process_dictation",
-            },
+            signal,
           },
-          signal,
-        },
-      );
-      cleanup();
-
-      const toolBlock = extractToolUse(response);
-      if (toolBlock) {
-        const input = toolBlock.input as {
-          mode?: string;
-          text?: string;
-        };
-        const mode: DictationMode =
-          input.mode === "action" ? "action" : "dictation";
-        log.info(
-          {
-            mode,
-            modelMs: Date.now() - modelStartedAt,
-            inChars: transcription.length,
-            outChars: input.text?.length ?? 0,
-          },
-          "LLM dictation classify+clean",
         );
-
-        if (mode === "action") {
-          return {
-            text: body.transcription,
-            mode: "action",
-            actionPlan: `User wants to: ${body.transcription}`,
-            ...profileMeta,
-          };
+        const input = extractToolUse(response)?.input as
+          | { mode?: string }
+          | undefined;
+        if (input?.mode === "action" || input?.mode === "dictation") {
+          return input.mode;
         }
-        const { text: cleanedText, rejected } = resolveCleanedDictation(
-          transcription,
-          input.text ?? "",
-          response.stopReason,
-        );
-        if (rejected) {
-          // Lengths only -- transcript content must never be logged.
-          log.warn(
-            {
-              rejected,
-              stopReason: response.stopReason,
-              rawChars: transcription.length,
-              cleanedChars: input.text?.trim().length ?? 0,
-            },
-            "Dictation cleanup rejected, using raw transcription",
-          );
-        }
-        const normalizedText = applyDictionary(cleanedText, profile.dictionary);
-        return {
-          text: normalizedText,
-          mode: "dictation",
-          ...profileMeta,
-        };
+      } finally {
+        cleanup();
       }
-
-      log.warn(
-        { modelMs: Date.now() - modelStartedAt },
-        "No tool_use block in combined dictation call, using heuristic",
-      );
-    } finally {
-      cleanup();
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log.warn(
-      { err: message, modelMs: Date.now() - modelStartedAt },
-      "Combined dictation LLM call failed, using heuristic",
+      { err: message },
+      "Dictation classification failed, using heuristic",
     );
   }
 
-  // Heuristic fallback
-  const fallbackMode = detectDictationModeHeuristic({
+  const mode = detectDictationModeHeuristic({
     type: "dictation_request",
     transcription: body.transcription,
     context: body.context,
   } as DictationRequest);
-  log.info({ mode: fallbackMode }, "Using heuristic fallback");
-  if (fallbackMode === "action") {
-    return {
-      text: body.transcription,
-      mode: "action",
-      actionPlan: `User wants to: ${body.transcription}`,
-      ...profileMeta,
-    };
-  }
-  const normalizedText = applyDictionary(transcription, profile.dictionary);
-  return {
-    text: normalizedText,
-    mode: fallbackMode,
-    ...profileMeta,
-  };
+  return mode === "action" ? "action" : "dictation";
 }
 
 async function handleCommandMode(
@@ -560,7 +397,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Process dictation",
     description:
-      "Classify voice input as dictation or action, clean up text, and apply user style preferences.",
+      "Preserve dictated words with explicit dictionary and snippet replacements, classify actions, or edit selected text when instructed.",
     tags: ["diagnostics"],
     requestBody: DictationRequestSchema,
     responseBody: z.object({

package/src/runtime/routes/global-search-routes.ts

@@ -11,6 +11,7 @@
 import { z } from "zod";
 
 import { getConfig } from "../../config/loader.js";
+import { isSidebarDoneEnabled } from "../../config/sidebar-done-gate.js";
 import { searchContacts } from "../../contacts/contact-store.js";
 import { searchConversations } from "../../persistence/conversation-queries.js";
 import { getMemorySqlite } from "../../persistence/db-connection.js";
@@ -123,23 +124,32 @@ function parseCategories(raw: string | undefined): Set<Category> {
  * cleaned term as a literal query, so unknown filters are visible to lexical
  * matching rather than silently dropped.
  *
- * Examples:
+ * `defaultArchived` is what an unfiltered query means. It is `false` by
+ * default and `true` under the `sidebar-done` flag, where a done chat is a
+ * filed chat rather than a hidden one and search is how the user reaches it.
+ * Either way both filters still say exactly what they say, so `is:unarchived`
+ * is the opt-out whenever the default is on.
+ *
+ * Examples (with `defaultArchived: false`):
  *   "foo bar"            -> { term: "foo bar",        archived: false }
  *   "is:archived foo"    -> { term: "foo",            archived: true  }
  *   "foo is:archived"    -> { term: "foo",            archived: true  }
  *   "is:archived"        -> { term: "",               archived: true  }
  *   "is:starred foo"     -> { term: "is:starred foo", archived: false }
  */
-function parseSearchQuery(rawQ: string | undefined): {
+function parseSearchQuery(
+  rawQ: string | undefined,
+  defaultArchived: boolean,
+): {
   term: string;
   archived: boolean;
 } {
   if (!rawQ) {
-    return { term: "", archived: false };
+    return { term: "", archived: defaultArchived };
   }
   const tokens = rawQ.split(/\s+/).filter((t) => t.length > 0);
   const termTokens: string[] = [];
-  let archived = false;
+  let archived = defaultArchived;
   for (const tok of tokens) {
     const lower = tok.toLowerCase();
     if (
@@ -291,11 +301,16 @@ async function handleGlobalSearch({
     throw new BadRequestError("q query parameter is required");
   }
 
-  // Pull the archive opt-in out of the query string itself (`is:archived` /
+  // Pull the archive filter out of the query string itself (`is:archived` /
   // `archive:yes` / etc.) so the user controls it the same way they control
   // every other modifier: by typing it into the search box. The cleaned term
-  // is what the backends actually search on.
-  const { term, archived: includeArchived } = parseSearchQuery(rawQ);
+  // is what the backends actually search on. Under `sidebar-done` the
+  // unfiltered default flips to including done chats, and `is:unarchived`
+  // becomes the token that narrows back to the live set.
+  const { term, archived: includeArchived } = parseSearchQuery(
+    rawQ,
+    isSidebarDoneEnabled(),
+  );
 
   const limit = Math.max(1, Math.min(Number(queryParams.limit ?? 20), 100));
   const categories = parseCategories(queryParams.categories);

package/src/runtime/routes/llm-call-sites-routes.ts

@@ -1,14 +1,16 @@
 import { z } from "zod";
 
-import { CALL_SITE_DEFAULTS } from "../../config/call-site-defaults.js";
 import { getUserSelectableProfilesForProvider } from "../../config/default-profile-catalog.js";
-import { resolveDefaultProfileKey } from "../../config/llm-resolver.js";
+import {
+  resolveDefaultProfileKey,
+  resolveShippedDefaultProfileKey,
+} from "../../config/llm-resolver.js";
 import { loadConfig } from "../../config/loader.js";
 import {
   CALL_SITE_CATALOG,
   CALL_SITE_DOMAINS,
 } from "../../config/schemas/call-site-catalog.js";
-import type { LLMCallSite } from "../../config/schemas/llm.js";
+import type { LLMCallSite, LLMConfig } from "../../config/schemas/llm.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import type { RouteDefinition } from "./types.js";
 
@@ -30,7 +32,8 @@ const callSiteEntrySchema = z.object({
    * `defaultProfile` would scatter pinned or remapped sites across their
    * winners. Profileless call sites report `balanced`: the resolver's
    * fallback anchor consults the balanced remap for them, so they follow
-   * the Balanced tier like any balanced-keyed site.
+   * the Balanced tier like any balanced-keyed site. A managed-only tier is
+   * omitted when it has no body under the workspace's default provider.
    */
   shippedDefaultProfile: z.string().optional(),
 });
@@ -40,16 +43,22 @@ const callSiteCatalogResponseSchema = z.object({
   callSites: z.array(callSiteEntrySchema),
 });
 
+export function buildCallSiteCatalog(llm: LLMConfig) {
+  return CALL_SITE_CATALOG.map((entry) => ({
+    ...entry,
+    defaultProfile: resolveDefaultProfileKey(entry.id as LLMCallSite, llm),
+    shippedDefaultProfile: resolveShippedDefaultProfileKey(
+      entry.id as LLMCallSite,
+      llm,
+    ),
+  }));
+}
+
 async function handleGetCallSites() {
   const { llm } = loadConfig();
   return {
     domains: CALL_SITE_DOMAINS,
-    callSites: CALL_SITE_CATALOG.map((entry) => ({
-      ...entry,
-      defaultProfile: resolveDefaultProfileKey(entry.id as LLMCallSite, llm),
-      shippedDefaultProfile:
-        CALL_SITE_DEFAULTS[entry.id]?.profile ?? "balanced",
-    })),
+    callSites: buildCallSiteCatalog(llm),
   };
 }
 

package/src/runtime/sync/documents-sidecar-publish.test.ts

@@ -1,22 +1,32 @@
 /**
- * A scheduled, heartbeat, or background turn runs its document tools in a
- * sidecar worker, whose local hub has no SSE subscriber. The documents-changed
- * broadcast has to be handed to the daemon there, or the document edited while
- * the user was not looking stays invisible on every client.
+ * A scheduled, heartbeat, or background turn runs its document tools and its
+ * conversation writes in a sidecar worker, whose local hub has no SSE
+ * subscriber. Those broadcasts have to be handed to the daemon there, or the
+ * document edited and the conversation changed while the user was not looking
+ * stay invisible on every client.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let notifyCount = 0;
+const listHandoffs: Array<{ reason: string; conversationIds: string[] }> = [];
 
 mock.module("./worker-daemon-notify.js", () => ({
   NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD:
     "notify_conversation_persisted_externally",
+  NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD:
+    "notify_conversation_list_changed_externally",
   NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD: "notify_documents_changed_externally",
   NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD:
     "notify_activation_progress_changed_externally",
   notifyDaemonActivationProgressChanged: async () => {},
   notifyDaemonConversationPersisted: async () => {},
+  notifyDaemonConversationListChanged: async (
+    reason: string,
+    conversationIds: string[],
+  ) => {
+    listHandoffs.push({ reason, conversationIds });
+  },
   notifyDaemonDocumentsChanged: async () => {
     notifyCount++;
   },
@@ -30,6 +40,7 @@ import {
 } from "../assistant-stream-state.js";
 import {
   DOCUMENTS_CHANGED_COALESCE_MS,
+  publishConversationListAndMetadataChanged,
   publishDocumentsChanged,
 } from "./resource-sync-events.js";
 
@@ -66,6 +77,7 @@ describe("publishDocumentsChanged in a sidecar worker", () => {
   beforeEach(async () => {
     await settle();
     notifyCount = 0;
+    listHandoffs.length = 0;
     _resetStreamStateForTesting();
   });
 
@@ -102,3 +114,37 @@ describe("publishDocumentsChanged in a sidecar worker", () => {
     expect(events[0].message).toMatchObject({ type: "sync_changed" });
   });
 });
+
+describe("publishConversationListAndMetadataChanged in a sidecar worker", () => {
+  beforeEach(async () => {
+    await settle();
+    listHandoffs.length = 0;
+    _resetStreamStateForTesting();
+  });
+
+  test("hands the list invalidation to the daemon instead of publishing into a void", async () => {
+    disableStreamSeqStamping();
+
+    const events = await captureLocalPublishes(() => {
+      publishConversationListAndMetadataChanged("reordered", "conv-1");
+    });
+
+    expect(listHandoffs).toEqual([
+      { reason: "reordered", conversationIds: ["conv-1"] },
+    ]);
+    expect(events).toEqual([]);
+  });
+
+  test("publishes on the local hub in the daemon, where subscribers live", async () => {
+    const events = await captureLocalPublishes(() => {
+      publishConversationListAndMetadataChanged("reordered", "conv-1");
+    });
+
+    expect(listHandoffs).toEqual([]);
+    expect(events).toHaveLength(1);
+    expect(events[0].message).toMatchObject({
+      type: "sync_changed",
+      tags: ["conversations:list", "conversation:conv-1:metadata"],
+    });
+  });
+});

package/src/runtime/sync/resource-sync-events.ts

@@ -12,6 +12,7 @@ import { isStreamSeqStampingDisabled } from "../assistant-stream-state.js";
 import { publishSyncInvalidation } from "./sync-publisher.js";
 import {
   notifyDaemonActivationProgressChanged,
+  notifyDaemonConversationListChanged,
   notifyDaemonConversationPersisted,
   notifyDaemonDocumentsChanged,
 } from "./worker-daemon-notify.js";
@@ -236,6 +237,16 @@ export function publishConversationListAndMetadataChanged(
     ? conversationIds
     : [conversationIds];
 
+  // In a sidecar worker the local hub has no SSE subscribers, so a publish
+  // here reaches nobody and the sidebar keeps showing a list the worker has
+  // already changed. Hand off to the daemon, which republishes on the hub
+  // clients actually subscribe to. A background worker turn has no
+  // originating client, so no `originClientId` is forwarded.
+  if (isStreamSeqStampingDisabled()) {
+    void notifyDaemonConversationListChanged(reason, ids);
+    return;
+  }
+
   // Shape-changing reasons (`created`, `deleted`, `reordered`) add or
   // remove rows or change the order of the paginated window — web must
   // refetch the list, so include the `conversationsList` umbrella tag.

package/src/runtime/sync/worker-daemon-notify.test.ts

@@ -33,13 +33,43 @@ mock.module("../../ipc/cli-client.js", () => ({
 
 import {
   NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD,
+  NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD,
   NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD,
   NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD,
   notifyDaemonActivationProgressChanged,
+  notifyDaemonConversationListChanged,
   notifyDaemonConversationPersisted,
   notifyDaemonDocumentsChanged,
 } from "./worker-daemon-notify.js";
 
+describe("notifyDaemonConversationListChanged", () => {
+  beforeEach(() => {
+    calls.length = 0;
+    nextResult = { ok: true };
+    shouldThrow = false;
+  });
+
+  test("hands the reason and ids to the daemon over the shared IPC method", async () => {
+    await notifyDaemonConversationListChanged("reordered", ["conv-1"]);
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.method).toBe(NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD);
+    expect(calls[0]!.params).toEqual({
+      body: { reason: "reordered", conversationIds: ["conv-1"] },
+    });
+  });
+
+  test("swallows a thrown IPC error (best-effort, no throw)", async () => {
+    shouldThrow = true;
+
+    const result = await notifyDaemonConversationListChanged("reordered", [
+      "conv-1",
+    ]);
+    expect(result).toBeUndefined();
+    expect(calls).toHaveLength(1);
+  });
+});
+
 describe("notifyDaemonConversationPersisted", () => {
   beforeEach(() => {
     calls.length = 0;