@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/persistence/conversation-title-service.ts

@@ -18,6 +18,11 @@ import type { Provider, ToolDefinition } from "../providers/types.js";
 import { publishConversationTitleChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
 import { Mutex } from "../util/mutex.js";
+import {
+  normalizeTitle,
+  stripThinkingTags,
+  truncateTitle,
+} from "../util/short-title.js";
 import {
   getConversation,
   getMessages,
@@ -577,176 +582,6 @@ function logRetryableFallback(
   );
 }
 
-const META_FAILURE_TITLES = new Set([
-  "missing context",
-  "no context",
-  "insufficient context",
-  "unclear context",
-  "empty context",
-  "no topic",
-  "unclear topic",
-  "unclear request",
-  "unclear message",
-  "empty conversation",
-  "empty message",
-  "no content",
-]);
-
-const MAX_TITLE_LENGTH = 40;
-const MAX_TITLE_WORDS = 7;
-
-function truncateTitle(title: string): string {
-  if (title.length <= MAX_TITLE_LENGTH) {
-    return title;
-  }
-  const words = title.split(/\s+/);
-  if (words.length <= MAX_TITLE_WORDS) {
-    // Long words but few of them — truncate to char limit at word boundary
-    let result = "";
-    for (const word of words) {
-      const candidate = result ? result + " " + word : word;
-      if (candidate.length > MAX_TITLE_LENGTH) {
-        break;
-      }
-      result = candidate;
-    }
-    return result || title.slice(0, MAX_TITLE_LENGTH);
-  }
-  // Too many words — trim to 5 words
-  return words.slice(0, 5).join(" ");
-}
-
-function normalizeTitle(raw: string): string {
-  let title = raw.trim().replace(/^["']|["']$/g, "");
-  title = stripMarkdown(title);
-  title = stripThinkingTags(title).trim();
-  if (!title) {
-    return "";
-  }
-  // Reject outputs that are the model reasoning aloud or continuing the
-  // conversation instead of naming it (e.g. "I need to generate a…", "I'll
-  // work through these files…"). Callers fall back to a deterministic title.
-  if (looksLikeLeakedProse(title)) {
-    return "";
-  }
-  if (META_FAILURE_TITLES.has(title.toLowerCase())) {
-    return "";
-  }
-  return truncateTitle(title);
-}
-
-/** Reasoning/sentence openers that never start a legitimate topic title. */
-const LEAKED_PROSE_PREFIXES = [
-  "i need to",
-  "i needed to",
-  "i should",
-  "i will",
-  "i'll",
-  "i can ",
-  "i can't",
-  "i cannot",
-  "i'm ",
-  "i am ",
-  "i've ",
-  "i have ",
-  "i'd ",
-  "i would",
-  "let me",
-  "looking at",
-  "based on",
-  "given the",
-  "to generate",
-  "to summarize",
-  "to title",
-  // Subject-led reasoning openers. A bare noun phrase ("The User Interface
-  // Redesign", "The Conversation API") is a valid title, so each subject only
-  // counts as leaked prose when a verb or possessive follows it — marking the
-  // output as a sentence rather than a topic.
-  "the user wants",
-  "the user asked",
-  "the user is",
-  "the user wanted",
-  "the user needs",
-  "the user said",
-  "the user has",
-  "the user would",
-  "the user's request",
-  "the conversation is",
-  "this conversation is",
-  "the conversation appears",
-  "the conversation seems",
-  "the conversation covers",
-  "the conversation discusses",
-  "the assistant should",
-  "the assistant is",
-  "the assistant wants",
-  "the assistant needs",
-  "the title should",
-  "the title is",
-  "the title would",
-  "the title for",
-  "here's ",
-  "here is ",
-  "here are ",
-  "sure,",
-  "okay,",
-  "ok,",
-];
-
-/**
- * Heuristic guard for title outputs that are clearly prose — the model
- * reasoning aloud or replying to the conversation rather than naming it. A real
- * title is a single-line short noun phrase, so we reject multi-line output,
- * embedded transcript markers, leading reasoning openers, and sentence-shaped
- * clauses. Deliberately tight: a false reject only costs a deterministic
- * fallback title, while a false accept persists a broken one.
- */
-function looksLikeLeakedProse(title: string): boolean {
-  if (/\n/.test(title)) {
-    return true;
-  }
-  if (/\b(?:user|assistant)\s*:/i.test(title)) {
-    return true;
-  }
-  const lower = title.toLowerCase();
-  if (LEAKED_PROSE_PREFIXES.some((prefix) => lower.startsWith(prefix))) {
-    return true;
-  }
-  // Sentence-shaped: terminal punctuation on a multi-word clause.
-  if (/[.?!]$/.test(title) && title.split(/\s+/).length > 5) {
-    return true;
-  }
-  return false;
-}
-
-/** Strip thinking tags so they don't bleed into generated titles. */
-function stripThinkingTags(text: string): string {
-  return text
-    .replace(/<thinking>[\s\S]*?<\/thinking>/gi, "")
-    .replace(/<thought>[\s\S]*?<\/thought>/gi, "")
-    .replace(/<think>[\s\S]*?<\/think>/gi, "")
-    .replace(/<thought>/gi, "")
-    .replace(/<\/thought>/gi, "")
-    .replace(/<thinking>/gi, "")
-    .replace(/<\/thinking>/gi, "")
-    .replace(/<think>/gi, "")
-    .replace(/<\/think>/gi, "")
-    .replace(/<:[^>]*>/gi, "");
-}
-
-/** Strip common markdown formatting so titles render as plain text. */
-function stripMarkdown(text: string): string {
-  return text
-    .replace(/\*\*(.+?)\*\*/g, "$1") // **bold**
-    .replace(/__(.+?)__/g, "$1") // __bold__
-    .replace(/\*(.+?)\*/g, "$1") // *italic*
-    .replace(/(?<!\w)_(.+?)_(?!\w)/g, "$1") // _italic_ (word-boundary-aware to preserve snake_case)
-    .replace(/~~(.+?)~~/g, "$1") // ~~strikethrough~~
-    .replace(/`(.+?)`/g, "$1") // `code`
-    .replace(/\[(.+?)\]\(.+?\)/g, "$1") // [link](url)
-    .replace(/^#{1,6}\s+/gm, ""); // # headings
-}
-
 function deriveFallbackTitle(context?: TitleContext): string | null {
   if (!context) {
     return null;

package/src/persistence/conversation-types.ts

@@ -3,7 +3,20 @@
 // `conversation-crud.ts`, the notification pipeline, and read-side filters
 // share one declaration without importing the heavy CRUD module. Also provides
 // the shared "is this a non-interactive / background conversation?" predicate
-// used by notification-feed and memory filters.
+// used by notification-feed and memory filters, the source-aware
+// `resolveConversationKind` classifier, and the pure predicates over a
+// persisted message's `metadata` record.
+
+import { parseChannelId } from "../channels/types.js";
+
+/**
+ * Canonical `conversations.source` string for background memory v2
+ * consolidation runs. A persisted column value, so it lives with the rest of
+ * the conversation vocabulary rather than inside the memory plugin that
+ * writes it (persistence must not depend on a plugin).
+ */
+// FROZEN: persisted `conversations.source` value. Never rename it.
+export const MEMORY_V2_CONSOLIDATION_SOURCE = "memory_v2_consolidation";
 
 /** How a conversation was created / its execution mode. */
 export type ConversationCreateType = "standard" | "background" | "scheduled";
@@ -29,3 +42,181 @@ export function isBackgroundConversationType(
 ): boolean {
   return (BACKGROUND_CONVERSATION_TYPES as readonly string[]).includes(t ?? "");
 }
+
+/**
+ * Who or what drove a conversation, folding the `source` and `conversationType`
+ * columns into one label.
+ */
+export type ConversationKind =
+  | "user"
+  | "background"
+  | "background_memory_consolidation"
+  | "scheduled";
+
+/**
+ * Single classifier shared by the LLM-context routes and the notification
+ * producers, so a new background source or conversation type lands in every
+ * consumer at once.
+ */
+export function resolveConversationKind(
+  source: string,
+  conversationType: string,
+): ConversationKind {
+  if (source === MEMORY_V2_CONSOLIDATION_SOURCE) {
+    return "background_memory_consolidation";
+  }
+  if (conversationType === "background") {
+    return "background";
+  }
+  if (conversationType === "scheduled") {
+    return "scheduled";
+  }
+  return "user";
+}
+
+/**
+ * Shared predicate for the transcript-suppression flag on user-message
+ * metadata (the `hidden` field of the persisted `metadata` column). One
+ * definition so the sites that must agree (echo suppression, list-messages
+ * filtering, queued-snapshot filtering, indexing exclusion, and downstream
+ * consumers of message text) cannot drift.
+ */
+export function isHiddenMessageMetadata(
+  metadata: Record<string, unknown> | null | undefined,
+): boolean {
+  return metadata?.hidden === true;
+}
+
+/**
+ * True when the row is a persisted `<background_event source="...">` trigger.
+ * Every wake, scheduled run, and backgrounded-tool completion stamps one (see
+ * `persistWakeTriggerMessage`). The permission mode such a turn ran under
+ * varies (most run interactive; clientless/headless wakes do not) and is
+ * recorded separately in `backgroundEventInteractive`; this predicate only
+ * identifies the row as a background event.
+ */
+export function isBackgroundEventMetadata(
+  metadata: Record<string, unknown> | undefined,
+): boolean {
+  return typeof metadata?.backgroundEventSource === "string";
+}
+
+/**
+ * True when a role-`"user"` row is internal scaffolding rather than a person's
+ * prompt: a daemon-injected run lifecycle notification (subagent
+ * `subagentNotification`, ACP run `acpNotification`, or any wake trigger, the
+ * persisted `<background_event source="...">` row every wake reads), or a row
+ * explicitly flagged `hidden` (e.g. a hidden `POST /messages` send that queued
+ * behind an in-flight turn, like the channel-setup wizard-close marker).
+ *
+ * These rows are persisted so the orchestrator wakes and reads the trigger,
+ * but the user sees the wake through its inline card ("Conversation Woke", or
+ * a terminal card for a backgrounded bash run), not a chat turn. One
+ * definition so the sites that must agree cannot drift: the
+ * `user_message_echo` broadcast (never render a live user bubble), the retry
+ * route's hidden-prompt re-run, and {@link isReplyPushIneligibleUserMessage}
+ * (a turn opened by one of these rows is not a user prompt awaiting a reply).
+ */
+export function isEchoSuppressedUserMessage(
+  metadata: Record<string, unknown> | undefined,
+): boolean {
+  return (
+    isHiddenMessageMetadata(metadata) ||
+    metadata?.subagentNotification != null ||
+    metadata?.acpNotification != null ||
+    isBackgroundEventMetadata(metadata)
+  );
+}
+
+/**
+ * True when a role-`"user"` row was persisted by the voice bridge for a live
+ * phone call or in-app voice session (every row `startVoiceTurn` persists, see
+ * `calls/voice-session-bridge.ts`).
+ *
+ * The reply to such a turn is spoken back over the still-open session, so any
+ * consumer that treats a finished reply as something the user has yet to see
+ * must skip it rather than push a notification for audio the user is hearing
+ * right now.
+ *
+ * This marker is the only durable signal for that: the channel/interface fields
+ * cannot stand in, because an in-app live-voice turn persists as
+ * `vellum`/`macos`, indistinguishable from a typed desktop send.
+ */
+export function isVoiceSessionUserMessage(
+  metadata: Record<string, unknown> | undefined,
+): boolean {
+  return metadata?.voiceSessionTurn === true;
+}
+
+/**
+ * True when the row that opened the turn arrived over an external messaging
+ * surface (Slack, Telegram, WhatsApp, email, a phone call) rather than the
+ * native app.
+ *
+ * An absent (or unrecognized) channel counts as in-app: every external ingress
+ * path stamps its channel via buildChannelMetadata, so the rows that omit the
+ * field are daemon-internal persists on native-app conversations (for example
+ * the deliberate omission in calls/call-pointer-messages.ts).
+ */
+function isChannelOriginatedUserMessage(
+  metadata: Record<string, unknown> | undefined,
+): boolean {
+  const channel = parseChannelId(metadata?.userMessageChannel);
+  return channel != null && channel !== "vellum";
+}
+
+/**
+ * True when the reply to this row reaches the user over the surface the row
+ * arrived on rather than the app: a messaging channel the finished reply is
+ * delivered back to, or a still-open voice session that speaks it aloud.
+ *
+ * Both reasons describe where a reply lands, not what the row is, so they hold
+ * only for a turn that keeps the row's original delivery orchestration.
+ */
+function isReplyDeliveredOffApp(
+  metadata: Record<string, unknown> | undefined,
+): boolean {
+  return (
+    isVoiceSessionUserMessage(metadata) ||
+    isChannelOriginatedUserMessage(metadata)
+  );
+}
+
+/**
+ * True when a finished reply to this row must not raise a
+ * `chat.assistant_reply` push. Five independent reasons, one predicate so the
+ * producer's own gating and the batch-drain selection of the row it reads
+ * cannot disagree: picking a row the producer then suppresses would swallow the
+ * push for a genuine prompt coalesced into the same batch.
+ *
+ * - `automated`: a scheduled or background prompt injected into an ordinary
+ *   user conversation, which has its own producer (e.g. `schedule.notify`).
+ * - Echo-suppressed: internal scaffolding, nobody's prompt awaiting a reply.
+ * - Voice-session: the reply is spoken back over the still-open session.
+ * - Channel-originated: the finished reply is delivered back to the
+ *   originating messaging surface (`finalizeEventDelivery`), so the sender
+ *   already has it and a push would duplicate it on their phone.
+ * - `pointerInstruction`: `runPointerMessageTurn` fact-checks the rows the turn
+ *   generated only after the turn ends, and deletes them when validation fails
+ *   so deterministic fallback copy takes their place. A push at turn end would
+ *   already have carried the rejected text.
+ *
+ * `replyDeliveredInAppOnly` marks a turn whose reply streams to the app and
+ * nowhere else: `POST /conversations/:id/retry` re-runs the anchor row through
+ * the agent loop with no channel-delivery orchestration and no voice session
+ * attached, so the two delivery-surface reasons ({@link isReplyDeliveredOffApp})
+ * no longer describe it and suppressing the push would leave the user without a
+ * copy anywhere. The other three reasons are properties of the row itself and
+ * stand either way.
+ */
+export function isReplyPushIneligibleUserMessage(
+  metadata: Record<string, unknown> | undefined,
+  options?: { replyDeliveredInAppOnly?: boolean },
+): boolean {
+  return (
+    metadata?.automated === true ||
+    metadata?.pointerInstruction === true ||
+    isEchoSuppressedUserMessage(metadata) ||
+    (!options?.replyDeliveredInAppOnly && isReplyDeliveredOffApp(metadata))
+  );
+}

package/src/persistence/db-init.ts

@@ -3,9 +3,10 @@ import { existsSync } from "node:fs";
 import { getLogger } from "../util/logger.js";
 import { getDbPath } from "../util/platform.js";
 import { runAsyncSqlite } from "./db-async-query.js";
-import { getDb } from "./db-connection.js";
+import { getDb, getSqliteFrom } from "./db-connection.js";
 import { runMigrationSteps } from "./migrations/run-migrations.js";
 import { validateMigrationState } from "./migrations/validate-migration-state.js";
+import { PLANNER_OPTIMIZE_PRAGMA } from "./planner-statistics.js";
 import { migrationSteps } from "./steps.js";
 
 /**
@@ -101,6 +102,18 @@ export async function initializeDb(): Promise<{ migrationsOk: boolean }> {
     "DB migration steps complete",
   );
 
+  // An index a migration creates has no sqlite_stat1 entry until something
+  // analyzes it, which SQLite calls out as a case to handle after a schema
+  // change. Only boots that applied a step pay for it, and optimize analyzes
+  // just the tables that need it.
+  if (applied.length > 0) {
+    try {
+      getSqliteFrom(database).exec(PLANNER_OPTIMIZE_PRAGMA);
+    } catch (err) {
+      log.warn({ err }, "Post-migration PRAGMA optimize failed (non-fatal)");
+    }
+  }
+
   if (failed.length > 0) {
     log.error(
       { failedMigrations: failed, count: failed.length },

package/src/persistence/db-maintenance.ts

@@ -8,6 +8,7 @@ import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import { getLastInteractiveUserMessageTimestamp } from "./conversation-crud.js";
 import { runAsyncSqlite } from "./db-async-query.js";
 import { getSqlite } from "./db-connection.js";
+import { PLANNER_OPTIMIZE_PRAGMA } from "./planner-statistics.js";
 
 const log = getLogger("db-maintenance");
 
@@ -80,11 +81,11 @@ async function runDbMaintenance(): Promise<void> {
     log.warn({ err }, "Workflow run pruning failed (non-fatal)");
   }
 
-  // Refresh the query planner's statistics. PRAGMA optimize is cheap; it is
-  // routed through the async path for consistency and to keep it off the main
-  // thread when the sqlite3 CLI backend is available.
+  // Refresh the query planner's statistics (see PLANNER_OPTIMIZE_PRAGMA for
+  // what the mask buys here). Routed through the async path to keep it off the
+  // main thread when the sqlite3 CLI backend is available.
   const optimizeResult = await runAsyncSqlite(
-    "PRAGMA optimize",
+    PLANNER_OPTIMIZE_PRAGMA,
     "db-maintenance:optimize",
   );
   if (!optimizeResult.ok) {

package/src/persistence/embeddings/__tests__/plugin-index-qdrant-init.test.ts

@@ -0,0 +1,219 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { SparseEmbedding } from "../embedding-types.js";
+
+// ---------------------------------------------------------------------------
+// Regression: the plugin index must not depend on the memory tier — or on the
+// daemon — having initialized the shared Qdrant client.
+//
+// `runMemoryStartup` calls `initQdrantClient` only in the daemon process, and
+// only while memory v1 is the live tier; on a default workspace
+// (`memory.v2.enabled` defaults true, or `memory.v3.live`) it is skipped, so
+// `getQdrantClient()` throws and every plugin Index op used to fail with
+// `BackendUnavailableError: Qdrant client not initialized`. The ops must
+// initialize the client themselves from the live workspace config, and rebuild
+// it when that config changes rather than serving a stale one.
+//
+// The fake singleton below behaves like the real one — absent until
+// `initQdrantClient` sets it — where `plugin-index.test.ts` mocks a client that
+// is already up. Each test file runs in its own Bun process (see
+// scripts/test.ts), so the two mocks cannot collide.
+// ---------------------------------------------------------------------------
+
+interface InitCall {
+  url: string;
+  collection: string;
+  vectorSize: number;
+  onDisk: boolean;
+  quantization: string;
+  embeddingModel?: string;
+}
+
+const calls = {
+  init: [] as InitCall[],
+  upserts: [] as Array<{ targetType: string; targetId: string }>,
+  get: [] as Array<{ targetId: string }>,
+  deleteScoped: [] as Array<{ targetId: string }>,
+};
+
+const fakeQdrant = {
+  async upsert(targetType: string, targetId: string) {
+    calls.upserts.push({ targetType, targetId });
+  },
+  async getByTarget(_targetType: string, targetId: string) {
+    calls.get.push({ targetId });
+    return null;
+  },
+  async deleteByTargetAndPlugin(_targetType: string, targetId: string) {
+    calls.deleteScoped.push({ targetId });
+  },
+  async hybridSearch() {
+    return [];
+  },
+  async search() {
+    return [];
+  },
+};
+
+/** Stands in for the module singleton in `qdrant-client.ts`: null until set. */
+let instance: typeof fakeQdrant | null = null;
+
+mock.module("../qdrant-client.js", () => ({
+  getQdrantClient: () => {
+    if (!instance) {
+      throw new Error("Qdrant client not initialized. Call initQdrantClient()");
+    }
+    return instance;
+  },
+  initQdrantClient: (cfg: InitCall) => {
+    calls.init.push(cfg);
+    instance = fakeQdrant;
+    return instance;
+  },
+  resolveQdrantUrl: () => "http://127.0.0.1:7777",
+}));
+mock.module("../qdrant-circuit-breaker.js", () => ({
+  withQdrantBreaker: <T>(fn: () => Promise<T>) => fn(),
+}));
+mock.module("../embed.js", () => ({
+  embedWithRetry: async () => ({
+    provider: "gemini",
+    model: "test-embed-model",
+    vectors: [[0.1, 0.2, 0.3]],
+  }),
+}));
+mock.module("../embedding-backend.js", () => ({
+  selectEmbeddingBackend: async () => ({
+    backend: { provider: "gemini", model: liveConfig.memory.embeddings.model },
+    reason: null,
+  }),
+  getMemoryBackendStatus: async () => ({
+    enabled: true,
+    degraded: false,
+    provider: "gemini",
+    model: liveConfig.memory.embeddings.model,
+    reason: null,
+  }),
+  generateSparseEmbedding: (): SparseEmbedding => ({
+    indices: [1, 2],
+    values: [0.5, 0.5],
+  }),
+}));
+
+/** The workspace config `getConfig()` returns; mutated to simulate a reload. */
+let liveConfig = {
+  memory: {
+    qdrant: {
+      collection: "vellum_memory",
+      vectorSize: 768,
+      onDisk: true,
+      quantization: "scalar",
+    },
+    embeddings: { provider: "gemini", model: "test-embed-model" },
+  },
+};
+
+mock.module("../../../config/loader.js", () => ({
+  getConfig: () => liveConfig,
+}));
+
+const { indexDocument, queryIndex, getDocument, removeDocument } =
+  await import("../plugin-index.js");
+
+beforeEach(() => {
+  calls.init.length = 0;
+  calls.upserts.length = 0;
+  calls.get.length = 0;
+  calls.deleteScoped.length = 0;
+});
+
+afterAll(() => {
+  mock.restore();
+});
+
+describe("plugin index without a pre-initialized Qdrant client", () => {
+  test("indexDocument initializes the client from config instead of throwing", async () => {
+    const res = await indexDocument(
+      liveConfig as never,
+      "ledger",
+      "Morning coffee",
+    );
+
+    expect(res.documentId).toBeTruthy();
+    expect(calls.upserts).toEqual([
+      { targetType: "plugin_index", targetId: `ledger:${res.documentId}` },
+    ]);
+    // Same shared collection, same dimension, and the dense model identity so
+    // the collection keeps its create/migrate semantics.
+    expect(calls.init).toEqual([
+      {
+        url: "http://127.0.0.1:7777",
+        collection: "vellum_memory",
+        vectorSize: 768,
+        onDisk: true,
+        quantization: "scalar",
+        embeddingModel: "gemini:test-embed-model",
+      },
+    ]);
+  });
+
+  test("query/get/remove also work without a pre-initialized client", async () => {
+    await expect(
+      queryIndex(liveConfig as never, "ledger", "coffee"),
+    ).resolves.toEqual([]);
+    await expect(getDocument("ledger", "doc-1")).resolves.toBeNull();
+    await expect(removeDocument("ledger", "doc-1")).resolves.toBeUndefined();
+
+    expect(calls.get).toEqual([{ targetId: "ledger:doc-1" }]);
+    expect(calls.deleteScoped).toEqual([{ targetId: "ledger:doc-1" }]);
+  });
+
+  test("an unchanged config reuses the client instead of rebuilding it", async () => {
+    await indexDocument(liveConfig as never, "ledger", "one");
+    await indexDocument(liveConfig as never, "ledger", "two");
+    await getDocument("ledger", "doc-1");
+
+    expect(calls.upserts).toHaveLength(2);
+    expect(calls.init).toHaveLength(0); // already built by an earlier test
+  });
+
+  test("a live embedding-config change rebuilds the client", async () => {
+    await indexDocument(liveConfig as never, "ledger", "before");
+    expect(calls.init).toHaveLength(0);
+
+    // A model swap at the same dimension: the client's captured model identity
+    // is now wrong, so reusing it would mix two models' vectors in one
+    // collection without tripping the sentinel migration.
+    liveConfig = {
+      memory: {
+        ...liveConfig.memory,
+        embeddings: { provider: "gemini", model: "swapped-embed-model" },
+      },
+    };
+    await indexDocument(liveConfig as never, "ledger", "after");
+
+    expect(calls.init).toEqual([
+      {
+        url: "http://127.0.0.1:7777",
+        collection: "vellum_memory",
+        vectorSize: 768,
+        onDisk: true,
+        quantization: "scalar",
+        embeddingModel: "gemini:swapped-embed-model",
+      },
+    ]);
+  });
+
+  test("a dimension change rebuilds the client", async () => {
+    liveConfig = {
+      memory: {
+        ...liveConfig.memory,
+        qdrant: { ...liveConfig.memory.qdrant, vectorSize: 1536 },
+      },
+    };
+    await indexDocument(liveConfig as never, "ledger", "resized");
+
+    expect(calls.init).toHaveLength(1);
+    expect(calls.init[0].vectorSize).toBe(1536);
+  });
+});