@vellumai/assistant 0.12.3 → 0.12.4-staging.2

package/src/runtime/question-resolution.ts

@@ -2,7 +2,7 @@
  * Shared resolution core for pending `ask_question` interactions.
  *
  * A pending `question` interaction (registered by {@link QuestionPrompter}) can
- * be resolved from two places:
+ * be resolved from three places:
  *
  *  - `POST /v1/question-response` — an app/web client submits the user's
  *    batched selection (see `routes/question-routes.ts`).
@@ -10,8 +10,11 @@
  *    or bare-text answer routes through the guardian reply router to the
  *    `pending_question` resolver, which builds the submission (see
  *    `approvals/guardian-request-resolvers.ts`).
+ *  - the enqueue path: a message typed into the chat while the card is open
+ *    answers the parked question as free text (see
+ *    `daemon/handlers/conversations.ts`).
  *
- * Both funnel through {@link resolvePendingQuestion} so the validate → consume
+ * All funnel through {@link resolvePendingQuestion} so the validate → consume
  * → `rpcResolve` sequence has a single implementation. The helper is
  * transport-agnostic: it returns a discriminated outcome rather than throwing
  * route errors, so each caller maps the outcome to its own surface (HTTP status
@@ -28,12 +31,20 @@ import {
 import * as pendingInteractions from "./pending-interactions.js";
 
 /**
- * How to resolve a pending question: a batched submission (one entry per
- * question) or a close (every question reported as `skipped`).
+ * How to resolve a pending question:
+ *
+ *  - `submit`: a batched submission, one entry per question.
+ *  - `close`: the card was dismissed; every question is reported as
+ *    `skipped`.
+ *  - `chat_reply`: the user typed a message into the chat while the card was
+ *    open. The text answers the first question as free text and the rest stay
+ *    `skipped`; the result is flagged so the tool tells the model where the
+ *    answer came from.
  */
 export type QuestionResolutionInput =
   | { kind: "submit"; submissions: QuestionBatchSubmission[] }
-  | { kind: "close" };
+  | { kind: "close" }
+  | { kind: "chat_reply"; text: string };
 
 /**
  * Outcome of {@link resolvePendingQuestion}.
@@ -57,9 +68,10 @@ export type QuestionResolutionOutcome =
   | { status: "invalid"; message: string };
 
 /**
- * Resolve a pending `question` interaction with a batched submission or a
- * close. Validation runs BEFORE the interaction is consumed, so an `invalid`
- * outcome leaves the pending prompt (and its timer) intact for a retry.
+ * Resolve a pending `question` interaction with a batched submission, a close,
+ * or a chat reply. Validation runs BEFORE the interaction is consumed, so an
+ * `invalid` outcome leaves the pending prompt (and its timer) intact for a
+ * retry.
  */
 export function resolvePendingQuestion(
   requestId: string,
@@ -81,6 +93,8 @@ export function resolvePendingQuestion(
         })),
         overall: "closed",
       };
+    } else if (input.kind === "chat_reply") {
+      result = buildChatReplyResult(input.text, interaction);
     } else {
       result = buildCompletedResult(input.submissions, interaction);
     }
@@ -136,6 +150,38 @@ function buildCompletedResult(
   return { entries, overall: "completed" };
 }
 
+/**
+ * Build the result for a chat reply: the typed text answers the first question
+ * as free text, every other question stays `skipped`.
+ *
+ * The daemon holds no partial per-question state (the card keeps the user's
+ * in-progress answers locally until the whole batch is posted), so the first
+ * question is by construction the first unanswered one. Which question the
+ * text really speaks to is the model's call, not the daemon's: the flag on the
+ * result tells it the answer came from the chat rather than the card, and it
+ * maps the reply onto the batch from there.
+ */
+function buildChatReplyResult(
+  text: string,
+  interaction: ReturnType<typeof pendingInteractions.get>,
+): QuestionPromptResult {
+  const { orderedIds } = readBatchMetadata(interaction);
+  if (orderedIds.length === 0) {
+    throw new QuestionBatchValidationError(
+      "No registered question ids for this batch",
+    );
+  }
+  return {
+    entries: orderedIds.map((id, index) =>
+      index === 0
+        ? { questionId: id, decision: "free_text" as const, text }
+        : { questionId: id, decision: "skipped" as const },
+    ),
+    overall: "completed",
+    answeredInChat: true,
+  };
+}
+
 /**
  * Pull the prompter-stashed batch bookkeeping off a pending interaction.
  * Returns empty defaults if the metadata is absent.

package/src/runtime/routes/__tests__/conversation-list-routes.test.ts

@@ -1302,3 +1302,149 @@ describe("GET /v1/conversations/sections", () => {
     expect(sections.some((s) => s.kind === "pinned")).toBe(false);
   });
 });
+
+describe("GET /v1/conversations, conversationType=all", () => {
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  function setLastMessageAt(id: string, at: number): void {
+    rawRun(
+      "test:setLastMessageAt",
+      "UPDATE conversations SET last_message_at = ? WHERE id = ?",
+      at,
+      id,
+    );
+  }
+
+  test("returns the standard listing and the background umbrella together", async () => {
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    const result = (await invoke({ conversationType: "all" })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "bg-1",
+      "foreground-1",
+      "sched-1",
+    ]);
+  });
+
+  test("with archiveStatus=all one page spans live and done rows of every type", async () => {
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    seedArchived("archived-1");
+    const archivedBackground = createConversation({
+      title: "archived-bg",
+      conversationType: "background",
+    });
+    rawRun(
+      "test:archiveConversation",
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      archivedBackground.id,
+    );
+
+    const result = (await invoke({
+      conversationType: "all",
+      archiveStatus: "all",
+    })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "archived-1",
+      "archived-bg",
+      "bg-1",
+      "foreground-1",
+    ]);
+    expect(result.hasMore).toBe(false);
+  });
+
+  test("orders by last message time descending across the types it merges", async () => {
+    const oldest = createConversation("oldest-foreground");
+    const middle = createConversation({
+      title: "middle-background",
+      conversationType: "background",
+    });
+    const newest = createConversation("newest-foreground");
+    setLastMessageAt(oldest.id, 1000);
+    setLastMessageAt(middle.id, 2000);
+    setLastMessageAt(newest.id, 3000);
+
+    const result = (await invoke({ conversationType: "all" })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title)).toEqual([
+      "newest-foreground",
+      "middle-background",
+      "oldest-foreground",
+    ]);
+  });
+
+  test("excludes legacy private rows and subagent runs", async () => {
+    createConversation("foreground-1");
+    const legacyPrivate = createConversation("legacy-private");
+    rawRun(
+      "test:legacyPrivateRow",
+      "UPDATE conversations SET conversation_type = 'private', group_id = 'system:background' WHERE id = ?",
+      legacyPrivate.id,
+    );
+    const subagent = createConversation({
+      title: "subagent-run",
+      conversationType: "background",
+    });
+    rawRun(
+      "test:subagentRun",
+      "UPDATE conversations SET source = 'subagent' WHERE id = ?",
+      subagent.id,
+    );
+
+    const result = (await invoke({ conversationType: "all" })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title)).toEqual(["foreground-1"]);
+  });
+
+  test("never appends pinned rows outside the page", async () => {
+    // Pinned injection is the compatibility shim for the default sidebar
+    // read. A whole-history page already contains the pinned row in recency
+    // order, so appending it would duplicate it and put hasMore out of step
+    // with the count.
+    const pinned = createConversation("pinned-1");
+    rawRun(
+      "test:pinConversation",
+      "UPDATE conversations SET is_pinned = 1, group_id = 'system:pinned' WHERE id = ?",
+      pinned.id,
+    );
+    const newer = createConversation("newer-1");
+    setLastMessageAt(pinned.id, 1000);
+    setLastMessageAt(newer.id, 2000);
+
+    const result = (await invoke({
+      conversationType: "all",
+      limit: "1",
+    })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title)).toEqual(["newer-1"]);
+    expect(result.hasMore).toBe(true);
+  });
+
+  test("hasMore describes the combined total, so pagination drains it", async () => {
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    const first = (await invoke({
+      conversationType: "all",
+      limit: "2",
+    })) as ListResponse;
+    expect(first.conversations).toHaveLength(2);
+    expect(first.hasMore).toBe(true);
+
+    const second = (await invoke({
+      conversationType: "all",
+      limit: "2",
+      offset: String(first.nextOffset),
+    })) as ListResponse;
+    expect(second.conversations).toHaveLength(1);
+    expect(second.hasMore).toBe(false);
+  });
+});

package/src/runtime/routes/__tests__/dictation-processing.test.ts

@@ -0,0 +1,174 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { DictationProfile } from "../../../daemon/dictation-profile-store.js";
+
+let profile: DictationProfile;
+let nextToolInput: { mode?: string; text?: string } | null;
+let providerAvailable: boolean;
+let providerFails: boolean;
+let providerResolutions: number;
+let requestedProperties: Record<string, unknown> | undefined;
+
+mock.module("../../../providers/provider-send-message.js", () => ({
+  getConfiguredProvider: async () => {
+    providerResolutions += 1;
+    if (!providerAvailable) {
+      return null;
+    }
+    return {
+      sendMessage: async (
+        _messages: unknown,
+        options: {
+          tools: Array<{
+            input_schema: { properties: Record<string, unknown> };
+          }>;
+        },
+      ) => {
+        if (providerFails) {
+          throw new Error("Provider unavailable");
+        }
+        requestedProperties = options.tools[0]?.input_schema.properties;
+        return {
+          content: nextToolInput
+            ? [{ type: "tool_use", input: nextToolInput }]
+            : [{ type: "text", text: "Rewritten text." }],
+        };
+      },
+    };
+  },
+  extractToolUse: (response: { content: Array<{ type: string }> }) =>
+    response.content.find((block) => block.type === "tool_use"),
+  userMessage: (text: string) => ({ role: "user", content: text }),
+  createTimeout: () => ({ signal: undefined, cleanup: () => undefined }),
+}));
+
+mock.module("../../../daemon/dictation-profile-store.js", () => ({
+  resolveProfile: () => ({ profile, source: "default" }),
+}));
+
+const { ROUTES, computeMaxTokens } = await import("../diagnostics-routes.js");
+const route = ROUTES.find((entry) => entry.operationId === "dictation_post")!;
+
+async function dictate(
+  transcription: string,
+  context: { cursorInTextField?: boolean; selectedText?: string } = {
+    cursorInTextField: true,
+  },
+) {
+  return (await route.handler({
+    body: { transcription, context },
+  } as unknown as Parameters<typeof route.handler>[0])) as {
+    text: string;
+    mode: string;
+    actionPlan?: string;
+  };
+}
+
+beforeEach(() => {
+  profile = { id: "general", name: "General" };
+  nextToolInput = { mode: "dictation", text: "We should ship it." };
+  providerAvailable = true;
+  providerFails = false;
+  providerResolutions = 0;
+  requestedProperties = undefined;
+});
+
+describe("dictation preserves recognized words", () => {
+  test.each([
+    "I think we probably shouldn't ship it, at least not yet.",
+    "Um, I don't, I don't want to say yes. Maybe next week?",
+    "First onions, then tomatoes. Actually, no tomatoes.",
+    "  Please don't send that.\nI mean it.  ",
+    "send me the draft, but don't send it to anyone else",
+  ])(
+    "preserves text-field dictation despite an attempted model rewrite: %s",
+    async (words) => {
+      expect(await dictate(words)).toMatchObject({
+        mode: "dictation",
+        text: words,
+      });
+      expect(providerResolutions).toBe(1);
+    },
+  );
+
+  test("a style profile cannot automatically rewrite ordinary dictation", async () => {
+    profile.stylePrompt = "Make every sentence confident and professional.";
+    const words = "I guess maybe we shouldn't do this.";
+
+    expect(await dictate(words)).toMatchObject({ text: words });
+    expect(providerResolutions).toBe(1);
+  });
+
+  test("whitespace-only selection is ordinary dictation", async () => {
+    expect(
+      await dictate("Don't change my words.", {
+        cursorInTextField: true,
+        selectedText: "  \n ",
+      }),
+    ).toMatchObject({ mode: "dictation", text: "Don't change my words." });
+    expect(providerResolutions).toBe(1);
+  });
+
+  test("keeps explicitly configured snippet and dictionary replacements", async () => {
+    profile.snippets = [
+      { trigger: "my sign off", expansion: "Thanks, user one" },
+    ];
+    profile.dictionary = [{ spoken: "user one", written: "Example User" }];
+
+    expect(await dictate("Maybe later. my sign off")).toMatchObject({
+      mode: "dictation",
+      text: "Maybe later. Thanks, Example User",
+    });
+    expect(providerResolutions).toBe(1);
+  });
+
+  test("classification outside a text field cannot supply replacement text", async () => {
+    const words = "I think we probably shouldn't ship it.";
+
+    expect(await dictate(words, {})).toMatchObject({
+      mode: "dictation",
+      text: words,
+    });
+    expect(providerResolutions).toBe(1);
+    expect(Object.keys(requestedProperties ?? {})).toEqual(["mode"]);
+  });
+
+  test.each([true, false])(
+    "action classification preserves the original command with cursorInTextField=%s",
+    async (cursorInTextField) => {
+      nextToolInput = { mode: "action", text: "Send the files." };
+      profile.snippets = [{ trigger: "files", expansion: "all files" }];
+      const words = "Send the files, but not the private ones.";
+
+      expect(await dictate(words, { cursorInTextField })).toMatchObject({
+        mode: "action",
+        text: words,
+        actionPlan: `User wants to: ${words}`,
+      });
+    },
+  );
+
+  test.each([
+    "missing-provider",
+    "provider-error",
+    "missing-tool",
+    "invalid-mode",
+  ])("classification fallback preserves words when %s", async (failure) => {
+    providerAvailable = failure !== "missing-provider";
+    providerFails = failure === "provider-error";
+    nextToolInput = failure === "missing-tool" ? null : { mode: "invalid" };
+    const words = "I don't think that's what I meant, you know?";
+
+    expect(await dictate(words, {})).toMatchObject({
+      mode: "dictation",
+      text: words,
+    });
+  });
+});
+
+describe("selected-text output budget", () => {
+  test("reserves space for the edit and tool-call JSON", () => {
+    expect(computeMaxTokens(900)).toBeGreaterThan(600);
+    expect(computeMaxTokens(5)).toBe(512);
+  });
+});

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

@@ -8,7 +8,10 @@
  *
  * Also covers the search-query parser: `is:archived` and its synonyms in the
  * `q` string flip the conversation arm to `includeArchived: true`, and the
- * filter token is stripped from the term before any backend is called.
+ * filter token is stripped from the term before any backend is called. Under
+ * the `sidebar-done` flag the unfiltered default is `true` instead and
+ * `is:unarchived` is the opt-out, so the flag-on twins assert the mirror
+ * image of the default ones.
  */
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -30,9 +33,13 @@ const searchConversationsMock = mock(
   },
 );
 
+let sidebarDoneEnabled = false;
+
 const actualContactStore = await import("../../../contacts/contact-store.js");
 const actualConvQueries =
   await import("../../../persistence/conversation-queries.js");
+const actualSidebarDoneGate =
+  await import("../../../config/sidebar-done-gate.js");
 
 mock.module("../../../contacts/contact-store.js", () => ({
   ...actualContactStore,
@@ -42,6 +49,10 @@ mock.module("../../../persistence/conversation-queries.js", () => ({
   ...actualConvQueries,
   searchConversations: searchConversationsMock,
 }));
+mock.module("../../../config/sidebar-done-gate.js", () => ({
+  ...actualSidebarDoneGate,
+  isSidebarDoneEnabled: () => sidebarDoneEnabled,
+}));
 
 const { ROUTES } = await import("../global-search-routes.js");
 
@@ -69,6 +80,7 @@ afterEach(() => {
   searchConversationsCalls = [];
   searchConversationsResult = [];
   searchConversationsMock.mockClear();
+  sidebarDoneEnabled = false;
 });
 
 describe("global-search contacts recency source", () => {
@@ -268,3 +280,64 @@ describe("global-search q parser", () => {
     expect(result.queryTokens).toEqual(["alpha", "beta"]);
   });
 });
+
+describe("global-search q parser under sidebar-done", () => {
+  test("plain term reaches done chats by default", async () => {
+    sidebarDoneEnabled = true;
+
+    await handler({
+      queryParams: { q: "shema", categories: "conversations" },
+    });
+
+    expect(searchConversationsCalls[0]?.query).toBe("shema");
+    expect(searchConversationsCalls[0]?.opts).toMatchObject({
+      includeArchived: true,
+    });
+  });
+
+  test("is:unarchived (and archive:no / archive:false) narrows back to live chats", async () => {
+    for (const filter of ["is:unarchived", "archive:no", "archive:false"]) {
+      sidebarDoneEnabled = true;
+      searchConversationsCalls = [];
+      searchConversationsMock.mockClear();
+
+      await handler({
+        queryParams: {
+          q: `${filter} shema`,
+          categories: "conversations",
+        },
+      });
+
+      expect(searchConversationsCalls[0]?.query).toBe("shema");
+      expect(searchConversationsCalls[0]?.opts).toMatchObject({
+        includeArchived: false,
+      });
+    }
+  });
+
+  test("is:archived stays a no-op the term is still stripped of", async () => {
+    sidebarDoneEnabled = true;
+
+    await handler({
+      queryParams: { q: "is:archived shema", categories: "conversations" },
+    });
+
+    expect(searchConversationsCalls[0]?.query).toBe("shema");
+    expect(searchConversationsCalls[0]?.opts).toMatchObject({
+      includeArchived: true,
+    });
+  });
+
+  test("unknown filter tokens stay in the term and do not narrow the default", async () => {
+    sidebarDoneEnabled = true;
+
+    await handler({
+      queryParams: { q: "is:starred shema", categories: "conversations" },
+    });
+
+    expect(searchConversationsCalls[0]?.query).toBe("is:starred shema");
+    expect(searchConversationsCalls[0]?.opts).toMatchObject({
+      includeArchived: true,
+    });
+  });
+});

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

@@ -4,8 +4,9 @@ import { CALL_SITE_DEFAULTS } from "../../../config/call-site-defaults.js";
 import {
   type LLMCallSite,
   LLMCallSiteEnum,
+  LLMSchema,
 } from "../../../config/schemas/llm.js";
-import { ROUTES } from "../llm-call-sites-routes.js";
+import { buildCallSiteCatalog, ROUTES } from "../llm-call-sites-routes.js";
 
 const route = ROUTES.find((r) => r.operationId === "llm_call_sites_list")!;
 
@@ -89,6 +90,20 @@ describe("llm-call-sites-routes", () => {
     }
   });
 
+  test("omits an unavailable managed-only shipped default under BYOK", () => {
+    const managed = buildCallSiteCatalog(LLMSchema.parse({})).find(
+      ({ id }) => id === "voiceEscalationJudge",
+    );
+    expect(managed?.defaultProfile).toBe("jev-managed");
+    expect(managed?.shippedDefaultProfile).toBe("jev-managed");
+
+    const byok = buildCallSiteCatalog(
+      LLMSchema.parse({ defaultProvider: { provider: "anthropic" } }),
+    ).find(({ id }) => id === "voiceEscalationJudge");
+    expect(byok?.defaultProfile).toBeUndefined();
+    expect(byok?.shippedDefaultProfile).toBeUndefined();
+  });
+
   test("domains have non-empty id and displayName", async () => {
     const result = (await route.handler({})) as {
       domains: Array<{ id: string; displayName: string }>;

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

@@ -31,16 +31,14 @@ import {
 import { resolveConversationId } from "../../persistence/conversation-key-store.js";
 import {
   type ConversationListFilter,
+  type ConversationListTypeFilter,
   countConversations,
   countConversationSections,
   countUnreadConversations,
   listConversations,
   listPinnedConversations,
 } from "../../persistence/conversation-queries.js";
-import {
-  ASSISTANT_INITIATED_GROUP_ID,
-  type ConversationType,
-} from "../../persistence/conversation-types.js";
+import { ASSISTANT_INITIATED_GROUP_ID } from "../../persistence/conversation-types.js";
 import { getBindingsForConversations } from "../../persistence/external-conversation-store.js";
 import { listGroups } from "../../persistence/group-crud.js";
 import { UserError } from "../../util/errors.js";
@@ -252,12 +250,14 @@ function handleListConversations({
   const limit = Number(queryParams.limit ?? 50);
   const offset = Number(queryParams.offset ?? 0);
   // "background" is the back-compat umbrella (background + scheduled); newer
-  // clients can pass "scheduled" to load only the Scheduled section. Absent
-  // defaults to the standard foreground list.
-  const conversationType: ConversationType =
+  // clients can pass "scheduled" to load only the Scheduled section, or "all"
+  // to page a user's whole history in one cursor. Absent defaults to the
+  // standard foreground list.
+  const conversationType: ConversationListTypeFilter =
     parseEnumQueryParam(queryParams, "conversationType", [
       "background",
       "scheduled",
+      "all",
     ]) ?? "standard";
   // Defaults to `active` so sidebar restores no longer pull archived rows.
   // The Archive page opts into `archived` to render only archived rows
@@ -294,7 +294,9 @@ function handleListConversations({
      read withholds them, so they appear in their own section and nowhere
      else. Confined to `standard`: the background and scheduled buckets are
      back-compat umbrellas addressed by conversation type, and narrowing them
-     by source would drop rows their callers still page through. Confined to
+     by source would drop rows their callers still page through, while `all`
+     is a whole-history read with no second section to defer those rows to,
+     so withholding there would simply lose them. Confined to
      active reads too: the Archive view asks `archiveStatus=archived` with no
      `groupId`, and the section only ever lists active rows, so withholding
      there would leave an archived section thread visible nowhere. */
@@ -584,10 +586,7 @@ function handleMarkUnread({ body = {}, headers }: RouteHandlerArgs) {
   }
 }
 
-function handleGetConversation({
-  pathParams = {},
-  headers,
-}: RouteHandlerArgs) {
+function handleGetConversation({ pathParams = {}, headers }: RouteHandlerArgs) {
   const detail = buildConversationDetailResponse(
     pathParams.id!,
     localeFromAcceptLanguage(headers?.["accept-language"]),
@@ -633,8 +632,11 @@ export const ROUTES: RouteDefinition[] = [
         type: "string",
         required: false,
         description:
-          'Filter by conversation type. Pass "background" to list background and scheduled conversations together (the back-compat umbrella), or "scheduled" to list only scheduled conversations.',
-        schema: { type: "string", enum: ["background", "scheduled"] },
+          'Filter by conversation type. Pass "background" to list background and scheduled conversations together (the back-compat umbrella), "scheduled" to list only scheduled conversations, or "all" for the union of the standard listing and that umbrella, so one paginated cursor spans every type. Combine "all" with archiveStatus=all for a whole-history read; rows are recency-ordered (COALESCE(last_message_at, updated_at) descending) like every other list read, and pinned rows are never appended to it.',
+        schema: {
+          type: "string",
+          enum: ["background", "scheduled", "all"],
+        },
       },
       {
         name: "archiveStatus",

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

@@ -65,6 +65,7 @@ import {
 } from "../../config/schemas/llm.js";
 import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
 import { ServiceModeSchema } from "../../config/schemas/services.js";
+import { isSidebarDoneEnabled } from "../../config/sidebar-done-gate.js";
 import {
   describeShadowedConfigSet,
   findSubstrateShadowing,
@@ -2108,6 +2109,9 @@ async function handleSearchConversations({
     query: q,
     limit,
     maxMessagesPerConversation: maxMessages,
+    // Under `sidebar-done` a done chat is filed rather than hidden, so the
+    // agent's own history search reaches it the same way the user's does.
+    includeArchived: isSidebarDoneEnabled(),
   });
   return { query: q, results };
 }

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

@@ -42,7 +42,7 @@ import {
   supportsHostProxy,
 } from "../../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getUserSelectableProfilesForProvider } from "../../config/default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "../../config/default-profile-catalog.js";
 import { isHttpAuthDisabled } from "../../config/env.js";
 import { getConfig } from "../../config/loader.js";
 import { isModeSessionRecoveryHealthy } from "../../config/session-groups-gate.js";
@@ -1754,7 +1754,9 @@ export async function handleSendMessage(
   }
   if (requestedInferenceProfile !== undefined) {
     const { llm } = getConfig();
-    const profiles = getUserSelectableProfilesForProvider(
+    // The conversation view: a sticky pin runs the main agent's turns, so a
+    // profile whose model returns verdicts rather than text is not offered.
+    const profiles = getConversationProfilesForProvider(
       llm.profiles,
       llm.defaultProvider ?? null,
     );