@vellumai/assistant 0.12.3-staging.2 → 0.12.4-staging.1

package/src/__tests__/secret-routes-platform-proxy.test.ts

@@ -25,6 +25,7 @@ const MANAGED_PROVIDERS = [
   "gemini",
   "fireworks",
   "together",
+  "typesafe",
 ] as const;
 
 let platformBaseUrlOverride: string | undefined;

package/src/__tests__/send-endpoint-busy.test.ts

@@ -302,8 +302,10 @@ function makePendingApprovalConversation(
 // Tests
 // ---------------------------------------------------------------------------
 
-const TEST_TOKEN = "test-bearer-token-send";
-const AUTH_HEADERS = { Authorization: `Bearer ${TEST_TOKEN}` };
+// This suite mocks isHttpAuthDisabled() to true, so a request carrying no
+// bearer authenticates through the dev bypass. A bearer that is present is
+// verified against the signing key, which these tests do not set up.
+const AUTH_HEADERS: Record<string, string> = {};
 
 describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
   let server: RuntimeHttpServer;

package/src/__tests__/steer-on-enqueue-question.test.ts

@@ -1,45 +1,62 @@
 /**
- * Enqueue-steer contract: when a chat message is enqueued while an
- * `ask_question` prompt is open for the same conversation, the user has chosen
- * to move on rather than answer it. `steerOnEnqueuedMessageIfQuestionParked`
- * steers to that message — aborting the parked turn (which settles the open
- * question via its turn-abort signal) and draining the message — instead of
- * stranding it behind a prompt no one will answer.
+ * Enqueue contract for a message typed while an `ask_question` card is open.
  *
- * Only `kind: "question"` interactions trigger the steer; pending confirmations
- * are handled separately by the enqueue path's auto-deny.
+ * The message is read as the answer: `answerParkedQuestionWithEnqueuedMessage`
+ * resolves the parked prompt with the typed text as free text and consumes the
+ * queued message, so the parked turn keeps running and the model reads the
+ * answer once, in the tool result.
+ *
+ * Everything a single free-text answer cannot honestly stand in for falls back
+ * to `steerOnEnqueuedMessageIfQuestionParked`, which supersedes the prompt by
+ * aborting the parked turn and draining the message instead. Confirmations and
+ * secrets are separate interaction kinds and are untouched by both paths.
  */
 import { afterEach, describe, expect, test } from "bun:test";
 
 import type { Conversation } from "../daemon/conversation.js";
+import type { QueuedMessage } from "../daemon/conversation-queue-manager.js";
 import {
   deleteConversation,
   setConversation,
 } from "../daemon/conversation-registry.js";
 import {
+  answerParkedQuestionWithEnqueuedMessage,
   steerOnEnqueuedMessageIfQuestionParked,
   supersedePendingInteractionsOnEnqueue,
 } from "../daemon/handlers/conversations.js";
+import type { QuestionPromptResult } from "../permissions/question-prompter.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 
 interface ParkedTurn {
   abortCount: () => number;
   fake: { pendingSteerRepair: boolean };
+  /** Queue entries still waiting, by request id. */
+  queuedIds: () => string[];
+  /** Event types emitted through the queued message's own sink. */
+  emittedTypes: () => string[];
+  enqueue: (message: Partial<QueuedMessage> & { requestId: string }) => void;
 }
 
 /**
  * Register a fake conversation whose in-flight turn is parked. The fake exposes
- * just the surface `steerToMessage` touches: a processing flag, a queue whose
- * messages can be looked up and promoted, an abort controller that records
+ * just the surface the enqueue paths touch: a processing flag, a queue that can
+ * be looked up, promoted and removed from, an abort controller that records
  * aborts, and the confirmation-deny hook.
  */
 function registerParkedTurn(id: string): ParkedTurn {
   let abortCount = 0;
+  const emitted: string[] = [];
+  const queue = new Map<string, QueuedMessage>();
   const fake = {
     isProcessing: () => true,
     queue: {
-      findByRequestId: (requestId: string) => ({ requestId }),
-      promoteToHead: (requestId: string) => ({ requestId }),
+      findByRequestId: (requestId: string) => queue.get(requestId),
+      promoteToHead: (requestId: string) => queue.get(requestId),
+    },
+    removeQueuedMessage: (requestId: string) => {
+      const item = queue.get(requestId);
+      queue.delete(requestId);
+      return item;
     },
     pendingSteerRepair: false,
     abortController: {
@@ -51,23 +68,249 @@ function registerParkedTurn(id: string): ParkedTurn {
     denyAllPendingConfirmations: () => {},
   };
   setConversation(id, fake as unknown as Conversation);
-  return { abortCount: () => abortCount, fake };
+  const enqueue = (
+    message: Partial<QueuedMessage> & { requestId: string },
+  ): void => {
+    queue.set(message.requestId, {
+      content: "",
+      attachments: [],
+      onEvent: (event) => {
+        emitted.push(event.type);
+      },
+      sentAt: 0,
+      ...message,
+    } as QueuedMessage);
+  };
+  // Every case needs a queued message to act on; the plain typed reply is the
+  // common one, and cases that need other content re-enqueue over it.
+  enqueue({ requestId: "msg-1", content: "next tuesday works" });
+  return {
+    abortCount: () => abortCount,
+    fake,
+    queuedIds: () => [...queue.keys()],
+    emittedTypes: () => [...emitted],
+    enqueue,
+  };
 }
 
 const registeredRequestIds: string[] = [];
 function registerInteraction(
   conversationId: string,
-  kind: "question" | "confirmation",
-): void {
-  const requestId = `pending-${kind}-${conversationId}`;
-  pendingInteractions.register(requestId, { conversationId, kind });
+  kind: "question" | "confirmation" | "secret",
+  options: { requestId?: string; questionIds?: string[] } = {},
+): { requestId: string; result: () => QuestionPromptResult | undefined } {
+  const requestId =
+    options.requestId ?? `pending-${kind}-${conversationId}-${Date.now()}`;
+  let result: QuestionPromptResult | undefined;
+  const questionIds = options.questionIds ?? ["q1"];
+  pendingInteractions.register(requestId, {
+    conversationId,
+    kind,
+    ...(kind === "question"
+      ? {
+          metadata: {
+            orderedIds: questionIds,
+            optionsById: Object.fromEntries(
+              questionIds.map((id) => [id, ["opt-a"]]),
+            ),
+          },
+          rpcResolve: (value: unknown) => {
+            result = value as QuestionPromptResult;
+          },
+        }
+      : {}),
+  });
   registeredRequestIds.push(requestId);
+  return { requestId, result: () => result };
 }
 
 const QUESTION_CONV = "steer-enqueue-question";
 const CONFIRMATION_CONV = "steer-enqueue-confirmation";
 const NONE_CONV = "steer-enqueue-none";
 
+describe("a typed reply answers a parked question", () => {
+  afterEach(() => {
+    for (const id of registeredRequestIds) {
+      pendingInteractions.resolve(id, "cancelled");
+    }
+    registeredRequestIds.length = 0;
+    deleteConversation(QUESTION_CONV);
+    deleteConversation(CONFIRMATION_CONV);
+    deleteConversation(NONE_CONV);
+  });
+
+  test("resolves a single parked question with the typed text", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question");
+
+    const answered = answerParkedQuestionWithEnqueuedMessage(
+      QUESTION_CONV,
+      "msg-1",
+    );
+
+    expect(answered).toBe(true);
+    expect(question.result()).toEqual({
+      entries: [
+        { questionId: "q1", decision: "free_text", text: "next tuesday works" },
+      ],
+      overall: "completed",
+      answeredInChat: true,
+    });
+    // The parked turn keeps running: no abort, no tool-result repair.
+    expect(conv.abortCount()).toBe(0);
+    expect(conv.fake.pendingSteerRepair).toBe(false);
+    // The message reaches the model through the tool result, so it is consumed
+    // rather than run as a turn of its own, and the client's queued row is
+    // retired the way a queue delete retires it.
+    expect(conv.queuedIds()).toEqual([]);
+    expect(conv.emittedTypes()).toEqual(["message_queued_deleted"]);
+  });
+
+  test("answers the first question of a batch and leaves the rest unanswered", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question", {
+      questionIds: ["q1", "q2", "q3"],
+    });
+
+    const answered = answerParkedQuestionWithEnqueuedMessage(
+      QUESTION_CONV,
+      "msg-1",
+    );
+
+    expect(answered).toBe(true);
+    expect(question.result()).toEqual({
+      entries: [
+        { questionId: "q1", decision: "free_text", text: "next tuesday works" },
+        { questionId: "q2", decision: "skipped" },
+        { questionId: "q3", decision: "skipped" },
+      ],
+      overall: "completed",
+      answeredInChat: true,
+    });
+    expect(conv.abortCount()).toBe(0);
+  });
+
+  test("supersedes instead when the message carries an attachment", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question");
+    conv.enqueue({
+      requestId: "msg-1",
+      content: "here it is",
+      attachments: [
+        {
+          id: "att-1",
+          filename: "notes.txt",
+          mimeType: "text/plain",
+          data: "",
+        },
+      ],
+    });
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(question.result()).toBeUndefined();
+    expect(conv.abortCount()).toBe(1);
+    expect(conv.queuedIds()).toEqual(["msg-1"]);
+  });
+
+  test("supersedes instead when the message is a slash command", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question");
+    conv.enqueue({ requestId: "msg-1", content: "/compact" });
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(question.result()).toBeUndefined();
+    expect(conv.abortCount()).toBe(1);
+  });
+
+  test("supersedes instead when the message is blank", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question");
+    conv.enqueue({ requestId: "msg-1", content: "   " });
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(question.result()).toBeUndefined();
+    expect(conv.abortCount()).toBe(1);
+  });
+
+  test("supersedes instead when the send is automated rather than typed", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question");
+    conv.enqueue({
+      requestId: "msg-1",
+      content: "scheduled follow-up",
+      metadata: { automated: true },
+    });
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(question.result()).toBeUndefined();
+    expect(conv.abortCount()).toBe(1);
+  });
+
+  test("supersedes instead when two questions are parked at once", () => {
+    // Which prompt the text answers would be a guess, so the old behavior
+    // stands: abort the turn and run the message as its own turn.
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const first = registerInteraction(QUESTION_CONV, "question", {
+      requestId: "question-a",
+    });
+    const second = registerInteraction(QUESTION_CONV, "question", {
+      requestId: "question-b",
+    });
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(first.result()).toBeUndefined();
+    expect(second.result()).toBeUndefined();
+    expect(conv.abortCount()).toBe(1);
+  });
+
+  test("leaves a parked secret alone while answering the question", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const secret = registerInteraction(QUESTION_CONV, "secret");
+    const question = registerInteraction(QUESTION_CONV, "question");
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(question.result()?.overall).toBe("completed");
+    expect(conv.abortCount()).toBe(0);
+    expect(pendingInteractions.get(secret.requestId)?.kind).toBe("secret");
+  });
+
+  test("does not answer from a pending confirmation (not a question)", () => {
+    const conv = registerParkedTurn(CONFIRMATION_CONV);
+    registerInteraction(CONFIRMATION_CONV, "confirmation");
+
+    const answered = answerParkedQuestionWithEnqueuedMessage(
+      CONFIRMATION_CONV,
+      "msg-1",
+    );
+    const steered = steerOnEnqueuedMessageIfQuestionParked(
+      CONFIRMATION_CONV,
+      "msg-1",
+    );
+
+    expect(answered).toBe(false);
+    expect(steered).toBe(false);
+    expect(conv.abortCount()).toBe(0);
+    // The message is left on the queue to run as its own turn.
+    expect(conv.queuedIds()).toEqual(["msg-1"]);
+  });
+
+  test("does nothing when no prompt is parked", () => {
+    const conv = registerParkedTurn(NONE_CONV);
+
+    supersedePendingInteractionsOnEnqueue(NONE_CONV, "msg-1");
+
+    expect(conv.abortCount()).toBe(0);
+    expect(conv.queuedIds()).toEqual(["msg-1"]);
+    expect(conv.emittedTypes()).toEqual([]);
+  });
+});
+
 describe("steerOnEnqueuedMessageIfQuestionParked", () => {
   afterEach(() => {
     for (const id of registeredRequestIds) {
@@ -134,27 +377,15 @@ describe("steerOnEnqueuedMessageIfQuestionParked", () => {
     expect(steered).toBe(false);
     expect(conv.abortCount()).toBe(0);
   });
-
-  test("supersedePendingInteractionsOnEnqueue steers a parked question", () => {
-    // The centralized routine is invoked by both the HTTP send handler and the
-    // CLI signal path. With no pending confirmation it steers a parked question
-    // — the behavior the CLI signal path previously lacked.
-    const conv = registerParkedTurn(QUESTION_CONV);
-    registerInteraction(QUESTION_CONV, "question");
-
-    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
-
-    expect(conv.abortCount()).toBe(1);
-    expect(conv.fake.pendingSteerRepair).toBe(true);
-  });
 });
 
 describe("removeByConversation preserves question interactions", () => {
   // The enqueue path's confirmation auto-deny calls removeByConversation before
-  // the steer runs. Questions must survive it — they are settled instead by the
-  // steer's turn abort — or, when an ask_question and a confirmation are pending
-  // concurrently, the queued message would strand behind a question whose entry
-  // was cleared (and whose Promise was never settled) before the steer fired.
+  // the question is answered or steered to. Questions must survive it (they
+  // are settled instead by the answer or by the steer's turn abort) or, when
+  // an ask_question and a confirmation are pending concurrently, the queued
+  // message would strand behind a question whose entry was cleared (and whose
+  // Promise was never settled) before either path fired.
   const CONV = "remove-by-conv-preserve-question";
   const ids: string[] = [];
   function register(kind: "question" | "confirmation"): void {

package/src/cli/commands/channel-verification-sessions.help.ts

@@ -44,7 +44,11 @@ Examples:
           description:
             "Destination address for outbound verification (handle, phone number, user ID, or email address)",
         },
-        { flags: "--rebind", description: "Replace existing guardian binding" },
+        {
+          flags: "--rebind",
+          description:
+            "Create a code although the channel already has a guardian (see below)",
+        },
         {
           flags: "--conversation-id <conversationId>",
           description: "Conversation ID for inbound challenges",
@@ -74,7 +78,13 @@ Routes between three creation modes based on the provided options:
   2. Outbound: --channel <ch> --destination <dest>
      Sends a verification code to the given destination. Supports telegram
      (handle or chat ID), phone (E.164 number), slack and discord (user ID),
-     and email. Use --rebind to replace an existing guardian binding.
+     and email.
+
+--rebind creates a code although the channel already has a guardian. On
+telegram, slack, discord and email, only the account already bound can redeem
+that code, which is how the same guardian verifies again. A code never moves
+the guardian to a different account there: run "revoke" first, then create
+without --rebind. On phone, an outbound code replaces the bound number.
 
   3. Inbound: --channel <ch> (no --destination)
      Generates a challenge secret for the guardian to send back on the

package/src/cli/lib/bundled-marketplace.json

@@ -176,16 +176,16 @@
       "icon": "\ud83d\udcbb"
     },
     {
-      "name": "ecommerce-wismo-supporter",
+      "name": "ecommerce-order-supporter",
       "description": "Resolves ecommerce Where-Is-My-Order (WISMO) support inquiries, cross-checks real-time carrier tracking milestones, flags delivery exceptions, and stages customer update drafts without helpdesk seat taxes.",
       "category": "commerce",
       "icon": "📦",
       "license": "MIT",
-      "homepage": "https://github.com/ZeebBoyBlue/ecommerce-wismo-supporter",
+      "homepage": "https://github.com/ZeebBoyBlue/ecommerce-order-supporter",
       "source": {
         "source": "github",
-        "repo": "ZeebBoyBlue/ecommerce-wismo-supporter",
-        "ref": "9218c23d325c749500d59b6ae651f38264a43cd1"
+        "repo": "ZeebBoyBlue/ecommerce-order-supporter",
+        "ref": "35e2165a14447a897aee750a198c3f166458226b"
       }
     },
     {

package/src/config/feature-flag-registry.json

@@ -170,14 +170,6 @@
       "description": "Enable Anthropic fast mode for Opus models (4.6, 4.7, 4.8), delivering up to 2.5x higher output tokens per second at premium pricing",
       "defaultEnabled": false
     },
-    {
-      "id": "teleport",
-      "scope": "client",
-      "key": "teleport",
-      "label": "Teleport",
-      "description": "Enable the local-to-platform teleport UI in General settings. Platform-to-local teleport is GA and not gated by this flag",
-      "defaultEnabled": false
-    },
     {
       "id": "apple-container",
       "scope": "client",
@@ -559,6 +551,14 @@
       "label": "Assistant Inbox",
       "description": "Shows an Assistant Inbox entry above Preferences in the web sidebar and the /assistant/inbox page it opens: a mailbox for the assistant's managed vellum.me address (received and sent, with a reading pane), the inline email setup card for entitled orgs with no address yet, and an upgrade card for orgs without the managed_email entitlement. Off hides the entry and redirects the route to chat.",
       "defaultEnabled": false
+    },
+    {
+      "id": "sidebar-done",
+      "scope": "both",
+      "key": "sidebar-done",
+      "label": "Sidebar Done",
+      "description": "Turns archiving a chat into marking it done: the sidebar row carries a Done check instead of the overflow menu, an Old chats page lists the full history, and done chats stay findable in search by default. Off keeps today's Archive wording, the overflow menu, and search that hides archived rows unless the query asks for them.",
+      "defaultEnabled": false
     }
   ]
 }

package/src/config/sidebar-done-gate.ts

@@ -0,0 +1,27 @@
+import { isAssistantFeatureFlagEnabled } from "./assistant-feature-flags.js";
+import type { AssistantConfig } from "./schema.js";
+
+export const SIDEBAR_DONE_FLAG_KEY = "sidebar-done" as const;
+
+/**
+ * Whether archiving a chat means marking it done.
+ *
+ * The flag is `both`-scoped: clients gate the Done affordances and the Old
+ * chats page on it, and the daemon gates the halves the feature needs. Done is
+ * `archived_at`, so no row changes shape in either state.
+ *
+ * On the daemon side there are two. The first is search reach: off, an
+ * archived conversation is hidden from search unless the query names it
+ * (`is:archived`); on, a done chat is findable by default and `is:unarchived`
+ * is the opt-out, because a chat the user marked done is filed, not deleted,
+ * and search is how they get back to it.
+ *
+ * The second is that a done chat keeps working. Off, an archived conversation
+ * rejects every wake and nothing but the unarchive route clears the column, so
+ * marking a chat done silently kills its schedule or its channel thread. On, a
+ * wake still runs on it, and a message the user reads landing in it brings the
+ * conversation back to the list.
+ */
+export function isSidebarDoneEnabled(config?: AssistantConfig): boolean {
+  return isAssistantFeatureFlagEnabled(SIDEBAR_DONE_FLAG_KEY, config);
+}

package/src/daemon/conversation-turn-finalize.ts

@@ -40,6 +40,7 @@ import {
   getConversation,
   getMessageById,
   parseMessageMetadata,
+  resurfaceArchivedConversation,
 } from "../persistence/conversation-crud.js";
 import { getResolvedConversationDirPath } from "../persistence/conversation-directories.js";
 import { syncMessageToDisk } from "../persistence/conversation-disk-view.js";
@@ -150,6 +151,17 @@ export function buildDeferredFinalizeEffect(params: {
         "Failed to project assistant message for attention tracking (non-fatal)",
       );
     }
+    // The row this turn reserved was empty at insert, so this is where its
+    // content becomes readable and a Done conversation earns its way back to
+    // the list. A run that never got this far produced nothing to read.
+    try {
+      resurfaceArchivedConversation(conversationId, finalizedRow.createdAt);
+    } catch (err) {
+      rlog.warn(
+        { err, conversationId, messageId: assistantMessageId },
+        "Failed to resurface Done conversation after finalize (non-fatal)",
+      );
+    }
   };
 }
 

package/src/daemon/handlers/__tests__/conversation-history-search.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Tests for the `includeArchived` option on the agent-facing conversation
+ * history search.
+ *
+ * The `"*"` wildcard takes its own branch (FTS reads `*` as a literal), so it
+ * has to honor the option through the list read rather than through
+ * `searchConversations`, which has its own coverage in
+ * `persistence/__tests__/conversation-queries-search.test.ts`.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { createConversation } from "../../../persistence/conversation-crud.js";
+import { getDb } from "../../../persistence/db-connection.js";
+import { initializeDb } from "../../../persistence/db-init.js";
+import { rawRun } from "../../../persistence/raw-query.js";
+import { conversations } from "../../../persistence/schema/index.js";
+import { performConversationSearch } from "../conversation-history.js";
+
+await initializeDb();
+
+function seedArchived(title: string): string {
+  const conv = createConversation({ title });
+  rawRun(
+    "test:archiveConversation",
+    "UPDATE conversations SET archived_at = ? WHERE id = ?",
+    Date.now(),
+    conv.id,
+  );
+  return conv.id;
+}
+
+describe("performConversationSearch · wildcard listing", () => {
+  beforeEach(() => {
+    getDb().delete(conversations).run();
+  });
+
+  test("omits archived conversations by default", async () => {
+    createConversation("live-1");
+    seedArchived("archived-1");
+
+    const results = await performConversationSearch({ query: "*" });
+
+    expect(results.map((r) => r.conversationTitle)).toEqual(["live-1"]);
+  });
+
+  test("includeArchived reaches archived conversations", async () => {
+    createConversation("live-1");
+    seedArchived("archived-1");
+
+    const results = await performConversationSearch({
+      query: "*",
+      includeArchived: true,
+    });
+
+    expect(results.map((r) => r.conversationTitle).sort()).toEqual([
+      "archived-1",
+      "live-1",
+    ]);
+  });
+});

package/src/daemon/handlers/config-channels.ts

@@ -156,7 +156,9 @@ export async function createInboundChallenge(
       success: false,
       error: "already_bound",
       message:
-        "A guardian is already bound for this channel. Revoke the existing binding first, or set rebind: true to replace.",
+        resolvedChannel === "phone"
+          ? "A guardian is already bound for this channel. On phone, verify through an outbound call with rebind: true. To a new number, it replaces the bound number once the code is entered. To the bound number, it confirms that number again and leaves the binding as it is. An inbound challenge cannot be completed by phone: a call collects a six-digit code, which an inbound challenge does not issue."
+          : "A guardian is already bound for this channel. To verify a different account, revoke the existing binding first. Set rebind: true only to verify the same account again.",
       channel: resolvedChannel,
     };
   }

package/src/daemon/handlers/conversation-history.ts

@@ -14,6 +14,12 @@ export interface ConversationSearchParams {
   query: string;
   limit?: number;
   maxMessagesPerConversation?: number;
+  /**
+   * Reach archived conversations as well as live ones. Defaults to false, so
+   * this search matches what the sidebar shows. Callers opt in where an
+   * archived chat is a filed chat rather than a hidden one.
+   */
+  includeArchived?: boolean;
 }
 
 /** Search conversations and return results (no transport dependency). */
@@ -22,7 +28,10 @@ export async function performConversationSearch(
 ) {
   // Treat "*" as a list-all wildcard — FTS treats it as a literal character.
   if (params.query.trim() === "*") {
-    const rows = listConversations({ limit: params.limit });
+    const rows = listConversations({
+      limit: params.limit,
+      archiveStatus: params.includeArchived ? "all" : "active",
+    });
     return rows.map((r) => ({
       conversationId: r.id,
       conversationTitle: r.title,
@@ -33,6 +42,7 @@ export async function performConversationSearch(
   return searchConversations(params.query, {
     limit: params.limit,
     maxMessagesPerConversation: params.maxMessagesPerConversation,
+    includeArchived: params.includeArchived,
   });
 }