@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/daemon/__tests__/auto-profile-router.test.ts

@@ -0,0 +1,228 @@
+import { describe, expect, test } from "bun:test";
+
+import type { ProfileEntry } from "../../config/schemas/llm.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../../providers/types.js";
+import {
+  AUTO_PROFILE_FALLBACK,
+  autoProfileCandidates,
+  autoProfileFallback,
+  recentConversationForRouter,
+  routeAutoProfile,
+} from "../auto-profile-router.js";
+
+function text(role: "user" | "assistant", body: string): Message {
+  return { role, content: [{ type: "text", text: body }] };
+}
+
+function jevResponse(answers: Record<string, unknown>): ProviderResponse {
+  return {
+    content: [{ type: "text", text: JSON.stringify(answers) }],
+    model: "jev-latest",
+    usage: { inputTokens: 1, outputTokens: 1 },
+    stopReason: "end_turn",
+    rawResponse: { model: "jev-latest", answers },
+  };
+}
+
+function fakeProvider(
+  respond: (
+    messages: Message[],
+    options?: SendMessageOptions,
+  ) => Promise<ProviderResponse>,
+): Provider {
+  return { name: "typesafe", sendMessage: respond } as Provider;
+}
+
+const managed = (label: string, status?: "disabled"): ProfileEntry => ({
+  source: "managed",
+  provider: "vellum",
+  model: "m",
+  label,
+  ...(status ? { status } : {}),
+});
+
+const profiles: Record<string, ProfileEntry> = {
+  auto: managed("Auto"),
+  balanced: managed("Balanced"),
+  "quality-optimized": managed("Quality"),
+  "cost-optimized": managed("Budget"),
+  "latency-optimized": managed("Fast"),
+};
+
+const base = {
+  conversationId: "conv-1",
+  history: [text("user", "hi"), text("assistant", "hello")],
+  userMessage: "Refactor the auth module and fix the race in token refresh",
+  profiles,
+};
+
+describe("autoProfileCandidates", () => {
+  test("offers the default profiles that exist and are not disabled", () => {
+    expect(
+      autoProfileCandidates({
+        ...profiles,
+        "cost-optimized": managed("Budget", "disabled"),
+      }),
+    ).toEqual(["balanced", "quality-optimized", "latency-optimized"]);
+    expect(autoProfileCandidates({ balanced: managed("Balanced") })).toEqual([
+      "balanced",
+    ]);
+  });
+});
+
+describe("recentConversationForRouter", () => {
+  test("drops injected blocks and the current message, keeps roles", () => {
+    const history: Message[] = [
+      text("user", "hey"),
+      { role: "user", content: [{ type: "text", text: "<memory>x</memory>" }] },
+      text("assistant", "Hi there"),
+      text("user", "do it"),
+    ];
+    expect(recentConversationForRouter(history, "do it")).toBe(
+      "user: hey\nassistant: Hi there",
+    );
+  });
+});
+
+describe("routeAutoProfile", () => {
+  test("pins the turn to Jev's choice and sends the candidates as criteria", async () => {
+    let sent: unknown;
+    const route = await routeAutoProfile({
+      ...base,
+      resolveProvider: async () =>
+        fakeProvider(async (messages) => {
+          const block = messages[0]?.content[0];
+          sent = JSON.parse(block?.type === "text" ? block.text : "{}");
+          return jevResponse({
+            profile: {
+              type: "choice",
+              choice: "quality-optimized",
+              confidence: 0.8,
+              probabilities: { "quality-optimized": 0.85, balanced: 0.15 },
+            },
+          });
+        }),
+    });
+    expect(route).toMatchObject({
+      profile: "quality-optimized",
+      outcome: "routed",
+      confidence: 0.8,
+    });
+    const request = sent as {
+      state: Record<string, string>;
+      questions: {
+        profile: { type: string; criteria: Record<string, string> };
+      };
+    };
+    expect(request.state.latest_user_message).toBe(base.userMessage);
+    expect(request.state.recent_conversation).toBe(
+      "user: hi\nassistant: hello",
+    );
+    expect(request.questions.profile.type).toBe("choice");
+    expect(Object.keys(request.questions.profile.criteria)).toEqual([
+      "balanced",
+      "quality-optimized",
+      "cost-optimized",
+      "latency-optimized",
+    ]);
+    expect(
+      request.questions.profile.criteria.balanced.startsWith("Balanced: "),
+    ).toBe(true);
+  });
+
+  test("falls back to Balanced when the choice names no candidate", async () => {
+    const route = await routeAutoProfile({
+      ...base,
+      resolveProvider: async () =>
+        fakeProvider(async () =>
+          jevResponse({ profile: { type: "choice", choice: "auto" } }),
+        ),
+    });
+    expect(route).toMatchObject({
+      profile: AUTO_PROFILE_FALLBACK,
+      outcome: "error",
+    });
+  });
+
+  test("falls back to Balanced when no TypeSafe route resolves", async () => {
+    const route = await routeAutoProfile({
+      ...base,
+      resolveProvider: async () => null,
+    });
+    expect(route).toEqual({
+      profile: AUTO_PROFILE_FALLBACK,
+      outcome: "unavailable",
+      latencyMs: expect.any(Number),
+    });
+  });
+
+  test("falls back to Balanced on timeout", async () => {
+    const route = await routeAutoProfile({
+      ...base,
+      timeoutMs: 5,
+      resolveProvider: async () =>
+        fakeProvider(
+          (_messages, options) =>
+            new Promise((_resolve, reject) => {
+              options?.signal?.addEventListener("abort", () =>
+                reject(new Error("aborted")),
+              );
+            }),
+        ),
+    });
+    expect(route.profile).toBe(AUTO_PROFILE_FALLBACK);
+    expect(route.outcome).toBe("timeout");
+  });
+
+  test("does not ask when fewer than two candidates remain", async () => {
+    let asked = false;
+    const route = await routeAutoProfile({
+      ...base,
+      profiles: { auto: managed("Auto"), balanced: managed("Balanced") },
+      resolveProvider: async () => {
+        asked = true;
+        return null;
+      },
+    });
+    expect(asked).toBe(false);
+    expect(route).toEqual({
+      profile: AUTO_PROFILE_FALLBACK,
+      outcome: "fallback",
+      latencyMs: 0,
+    });
+  });
+
+  test("falls back to an enabled candidate when Balanced is disabled", async () => {
+    const withoutBalanced = {
+      ...profiles,
+      balanced: managed("Balanced", "disabled"),
+    };
+    expect(autoProfileFallback(autoProfileCandidates(withoutBalanced))).toBe(
+      "quality-optimized",
+    );
+    const unavailable = await routeAutoProfile({
+      ...base,
+      profiles: withoutBalanced,
+      resolveProvider: async () => null,
+    });
+    expect(unavailable.profile).toBe("quality-optimized");
+    const single = await routeAutoProfile({
+      ...base,
+      profiles: {
+        auto: managed("Auto"),
+        balanced: managed("Balanced", "disabled"),
+        "cost-optimized": managed("Budget"),
+      },
+    });
+    expect(single).toMatchObject({
+      profile: "cost-optimized",
+      outcome: "fallback",
+    });
+    expect(autoProfileFallback([])).toBe(AUTO_PROFILE_FALLBACK);
+  });
+});

package/src/daemon/auto-profile-router.ts

@@ -0,0 +1,220 @@
+/**
+ * Picks which default profile answers a turn that runs on the Auto profile.
+ *
+ * The agent loop asks TypeSafe's System One model (Jev) one choice question
+ * over the user's latest message, with the recent conversation for context,
+ * and pins the turn to the answer. Every other outcome (no managed Jev route,
+ * provider error, timeout, an answer naming no candidate) pins the turn to
+ * Balanced, which is also the Auto profile's own body, so a turn the router
+ * cannot judge runs exactly as a Balanced turn would.
+ */
+
+import {
+  AUTO_PROFILE_ROUTER_CALL_SITE,
+  DEFAULT_PROFILE_KEYS,
+  type DefaultProfileKey,
+  isDefaultProfileKey,
+} from "../config/default-profile-names.js";
+import type { ProfileEntry } from "../config/schemas/llm.js";
+import { askTypesafe } from "../providers/jev/ask.js";
+import type { ContentBlock, Message, Provider } from "../providers/types.js";
+import { getLogger } from "../util/logger.js";
+import { safeStringSlice } from "../util/unicode.js";
+
+const log = getLogger("auto-profile-router");
+
+export const AUTO_PROFILE_FALLBACK: DefaultProfileKey = "balanced";
+
+/**
+ * The profile a turn runs on when the router cannot judge it: Balanced while
+ * it is a candidate, else the first candidate the user left enabled, else
+ * Balanced (the Auto body itself) when nothing is enabled.
+ */
+export function autoProfileFallback(
+  candidates: readonly DefaultProfileKey[],
+): DefaultProfileKey {
+  if (candidates.includes(AUTO_PROFILE_FALLBACK)) {
+    return AUTO_PROFILE_FALLBACK;
+  }
+  return candidates[0] ?? AUTO_PROFILE_FALLBACK;
+}
+
+/**
+ * Budget before the turn proceeds on Balanced. The router runs before the
+ * turn's first provider call, so a Jev outage costs at most this much
+ * time-to-first-token per Auto turn and never blocks the reply. Jev's
+ * measured round trip sits well under it (the voice judge runs on 800ms).
+ */
+export const AUTO_PROFILE_ROUTER_TIMEOUT_MS = 1_000;
+
+const HISTORY_TURNS = 6;
+const HISTORY_TURN_MAX_CHARS = 600;
+const MESSAGE_MAX_CHARS = 4_000;
+
+/**
+ * What each default profile is for, phrased so the options exclude each
+ * other. The picker copy on the profiles describes a tier to a person;
+ * these describe the kind of message that belongs on it.
+ */
+const ROUTING_CRITERIA: Record<DefaultProfileKey, string> = {
+  balanced:
+    "Everyday requests: questions, drafting, summaries, ordinary coding, tasks that use tools. The choice when nothing else clearly applies.",
+  "quality-optimized":
+    "Hard problems: multi-step reasoning, subtle debugging, large or delicate code changes, careful analysis, writing where quality matters most.",
+  "cost-optimized":
+    "Simple, mechanical work: short factual answers, reformatting, extraction, small edits where a modest model is plenty.",
+  "latency-optimized":
+    "Quick conversational replies: greetings, acknowledgements, one-line answers where speed matters more than depth.",
+};
+
+const ROUTING_INSTRUCTIONS =
+  "Which model profile should answer the user's latest message? Judge the work the reply needs, using the recent conversation to interpret short follow-ups. Pick the cheapest profile that will still produce a good answer.";
+
+export type AutoProfileRouteOutcome =
+  | "routed"
+  | "unavailable"
+  | "timeout"
+  | "error"
+  | "fallback";
+
+export interface AutoProfileRoute {
+  profile: DefaultProfileKey;
+  outcome: AutoProfileRouteOutcome;
+  /** Jev's confidence in the pick, when it answered. */
+  confidence?: number;
+  latencyMs: number;
+}
+
+/** A message's spoken text: its text blocks minus injected `<...>` blocks. */
+export function plainTextOf(content: readonly ContentBlock[]): string {
+  return content
+    .map((block) => (block.type === "text" ? block.text : ""))
+    .filter(
+      (text) => text.trim().length > 0 && !text.trimStart().startsWith("<"),
+    )
+    .join(" ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/**
+ * The router's view of the conversation: the last few turns as plain text,
+ * without injected context blocks, tool traffic, or the current message
+ * (which the router receives on its own).
+ */
+export function recentConversationForRouter(
+  history: readonly Message[],
+  userMessage: string,
+): string {
+  const lines: string[] = [];
+  for (const message of history) {
+    const text = plainTextOf(message.content);
+    if (text.length === 0) {
+      continue;
+    }
+    lines.push(
+      `${message.role}: ${safeStringSlice(text, 0, HISTORY_TURN_MAX_CHARS)}`,
+    );
+  }
+  const current = `user: ${userMessage.replace(/\s+/g, " ").trim()}`;
+  if (lines.length > 0 && lines[lines.length - 1] === current) {
+    lines.pop();
+  }
+  return lines.slice(-HISTORY_TURNS).join("\n");
+}
+
+/**
+ * The default profiles the router may pick from: the ones the conversation
+ * view offers and the user has not disabled.
+ */
+export function autoProfileCandidates(
+  profiles: Readonly<Record<string, ProfileEntry>>,
+): DefaultProfileKey[] {
+  return DEFAULT_PROFILE_KEYS.filter((key) => {
+    const entry = profiles[key];
+    return entry != null && entry.status !== "disabled";
+  });
+}
+
+/**
+ * Route one turn. Never rejects: every failure returns the fallback profile.
+ */
+export async function routeAutoProfile(args: {
+  conversationId: string;
+  history: readonly Message[];
+  userMessage: string;
+  profiles: Readonly<Record<string, ProfileEntry>>;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  /** Provider resolver, injectable for tests. */
+  resolveProvider?: () => Promise<Provider | null>;
+}): Promise<AutoProfileRoute> {
+  const userMessage = args.userMessage.trim();
+  const candidates = autoProfileCandidates(args.profiles);
+  const fallback = autoProfileFallback(candidates);
+  // A choice needs two options; with fewer there is nothing to route.
+  if (userMessage.length === 0 || candidates.length < 2) {
+    return { profile: fallback, outcome: "fallback", latencyMs: 0 };
+  }
+  const criteria = Object.fromEntries(
+    candidates.map((key) => [
+      key,
+      `${args.profiles[key]?.label ?? key}: ${ROUTING_CRITERIA[key]}`,
+    ]),
+  );
+  const result = await askTypesafe({
+    callSite: AUTO_PROFILE_ROUTER_CALL_SITE,
+    conversationId: args.conversationId,
+    state: {
+      recent_conversation:
+        recentConversationForRouter(args.history, userMessage) ||
+        "(start of conversation)",
+      latest_user_message: safeStringSlice(userMessage, 0, MESSAGE_MAX_CHARS),
+    },
+    questions: {
+      profile: {
+        type: "choice",
+        instructions: ROUTING_INSTRUCTIONS,
+        criteria,
+      },
+    },
+    timeoutMs: args.timeoutMs ?? AUTO_PROFILE_ROUTER_TIMEOUT_MS,
+    ...(args.signal ? { signal: args.signal } : {}),
+    ...(args.resolveProvider ? { resolveProvider: args.resolveProvider } : {}),
+  });
+  if (result.outcome !== "answered") {
+    return {
+      profile: fallback,
+      outcome: result.outcome,
+      latencyMs: result.latencyMs,
+    };
+  }
+  const answer = result.answers?.profile;
+  const choice =
+    typeof answer === "object" && answer !== null && "choice" in answer
+      ? (answer as { choice?: unknown }).choice
+      : undefined;
+  const confidence =
+    typeof answer === "object" && answer !== null && "confidence" in answer
+      ? (answer as { confidence?: unknown }).confidence
+      : undefined;
+  if (
+    typeof choice !== "string" ||
+    !isDefaultProfileKey(choice) ||
+    !candidates.includes(choice)
+  ) {
+    log.warn(
+      { conversationId: args.conversationId, choice },
+      "Auto profile router answered with no candidate profile",
+    );
+    return { profile: fallback, outcome: "error", latencyMs: result.latencyMs };
+  }
+  // Argmax with no confidence floor. A floor belongs here if flat
+  // distributions turn out to send trivial messages to Quality.
+  return {
+    profile: choice,
+    outcome: "routed",
+    ...(typeof confidence === "number" ? { confidence } : {}),
+    latencyMs: result.latencyMs,
+  };
+}

package/src/daemon/conversation-agent-loop.ts

@@ -25,6 +25,8 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
+import { getConversationProfilesForProvider } from "../config/default-profile-catalog.js";
+import { AUTO_PROFILE_KEY } from "../config/default-profile-names.js";
 import {
   contextWindowConfigFromEffective,
   type EffectiveContextWindow,
@@ -99,6 +101,11 @@ import {
   DEFAULT_TURN_COMMIT_MAX_WAIT_MS,
 } from "./abort-watchdog.js";
 import { cleanAssistantContent } from "./assistant-attachments.js";
+import {
+  type AutoProfileRoute,
+  plainTextOf,
+  routeAutoProfile,
+} from "./auto-profile-router.js";
 import { conversationSupportsDynamicUi } from "./channel-ui-capability.js";
 import type { Conversation } from "./conversation.js";
 import {
@@ -647,16 +654,82 @@ export async function runAgentLoopImpl(
   // live conversation (hydrated on load, kept current by the HTTP setters and
   // the expiry reaper), so the derivation reads `ctx` rather than re-fetching
   // the row.
-  const userExplicitOverride =
-    options?.overrideProfile ?? resolveOverrideProfile(ctx);
-
   const config = getConfig();
 
+  // With no explicit override, the resolver's own chain (the active profile
+  // for the main agent, then the call site's pin) may still select the Auto
+  // profile. That winner is named here so the router below covers every path
+  // that would otherwise dispatch the Auto body.
+  const readRequestedOverrideProfile = (): string | undefined => {
+    const explicit = options?.overrideProfile ?? resolveOverrideProfile(ctx);
+    if (explicit !== undefined) {
+      return explicit;
+    }
+    const winner = selectWinningProfile(inferenceCallSite, config.llm, {
+      selectionSeed: ctx.conversationId,
+    }).profileName;
+    return winner === AUTO_PROFILE_KEY ? AUTO_PROFILE_KEY : undefined;
+  };
+
+  // The Auto profile is a selection over the default profiles, made once per
+  // turn: the routed profile stands in for the Auto name on every read, so
+  // the whole turn (and any subagent inheriting the override) runs on one
+  // profile. A user profile that shadows the managed name is a profile of
+  // its own and is not routed. Nothing here may throw: the turn's processing
+  // state is already held and its release lives in the loop's `finally`
+  // further down, so a routing failure degrades to the Auto body instead.
+  const routeAutoProfileForTurn =
+    async (): Promise<AutoProfileRoute | null> => {
+      try {
+        const profiles = getConversationProfilesForProvider(
+          config.llm.profiles,
+          config.llm.defaultProvider ?? null,
+        );
+        if (profiles[AUTO_PROFILE_KEY]?.source !== "managed") {
+          return null;
+        }
+        const route = await routeAutoProfile({
+          conversationId: ctx.conversationId,
+          history: ctx.messages,
+          userMessage: plainTextOf(
+            getMessageById(userMessageId)?.content ?? [],
+          ),
+          profiles,
+          signal: abortController.signal,
+        });
+        rlog.info(
+          {
+            outcome: route.outcome,
+            profile: route.profile,
+            confidence: route.confidence ?? null,
+            latencyMs: route.latencyMs,
+          },
+          "Auto profile routed the turn",
+        );
+        return route;
+      } catch (err) {
+        rlog.warn(
+          { err },
+          "Auto profile routing failed; running the Auto body",
+        );
+        return null;
+      }
+    };
+  const requestedOverrideProfile = readRequestedOverrideProfile();
+  const autoRoute =
+    requestedOverrideProfile === AUTO_PROFILE_KEY
+      ? await routeAutoProfileForTurn()
+      : null;
+  const withAutoRoute = (profile: string | undefined): string | undefined =>
+    profile === AUTO_PROFILE_KEY && autoRoute ? autoRoute.profile : profile;
+
+  const userExplicitOverride = withAutoRoute(requestedOverrideProfile);
+
   const turnOverrideProfile = userExplicitOverride;
   const forceOverrideProfile = options?.forceOverrideProfile === true;
 
   const readCurrentOverrideProfile = (): string | undefined =>
-    options?.overrideProfile ?? resolveOverrideProfile(ctx);
+    withAutoRoute(readRequestedOverrideProfile());
 
   // Best-effort attribution for error classification: names the resolved
   // connection and profile so credential/connection errors point at the

package/src/daemon/conversation-slash.ts

@@ -1,5 +1,5 @@
 import type { InterfaceId } from "../channels/types.js";
-import { getUserSelectableProfilesForProvider } from "../config/default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "../config/default-profile-catalog.js";
 import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import {
@@ -148,7 +148,7 @@ async function resolveModelCommand(
   parse: ModelCommandParse,
 ): Promise<SlashResolution> {
   const config = getConfig();
-  const profiles = getUserSelectableProfilesForProvider(
+  const profiles = getConversationProfilesForProvider(
     config.llm.profiles,
     config.llm.defaultProvider ?? null,
   );

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/dictation-text-processing.ts

@@ -1,8 +1,8 @@
 /**
  * Pure text-processing functions for dictation profiles.
  *
- * - expandSnippets: pre-LLM, dictation mode only
- * - applyDictionary: post-LLM, dictation + command modes (including fallback paths)
+ * - expandSnippets: dictation mode only
+ * - applyDictionary: dictation and selected-text edits (including fallback paths)
  */
 
 import type {
@@ -33,7 +33,7 @@ function wrapWordBoundary(
 }
 
 /**
- * Expand snippet triggers in text before sending to the LLM.
+ * Expand user-configured snippet triggers in dictated text.
  *
  * - Only enabled snippets are considered
  * - Sorted by trigger length descending (longest match wins)
@@ -80,7 +80,7 @@ export function expandSnippets(
 }
 
 /**
- * Apply dictionary normalization to text after LLM processing (or on raw fallback).
+ * Apply user-configured dictionary replacements to dictated or edited text.
  *
  * - Sorted by spoken length descending
  * - Respects wholeWord (default true) and caseSensitive (default false) per entry

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",
+    ]);
+  });
+});