@vellumai/assistant 0.11.1-dev.202608031736.2d0bed8 → 0.11.1-dev.202608032034.aebd2da

package/eslint.config.mjs

@@ -49,14 +49,29 @@ const eslintConfig = defineConfig([
       "@typescript-eslint/no-explicit-any": "off",
     },
   },
-  // Managed-column profile resolution (`getEffectiveProfile(s)`) resolves
-  // default profiles against the vellum column only, ignoring
-  // `llm.defaultProvider`; on a BYO install that is not the body that
-  // dispatches. Runtime code must use `resolveDefaultProfileForProvider` /
-  // `getEffectiveProfilesForProvider` instead. The allowlist below is the
-  // full set of intentional managed-column consumers: the catalog itself,
-  // hatch-time seeding (writes managed stubs by design), and write-path
-  // validation.
+  // Two unrelated import bans share one `no-restricted-imports` entry on
+  // purpose: flat config replaces rule options rather than merging them, so a
+  // second block setting the same rule over overlapping files would silently
+  // drop the first one's patterns.
+  //
+  // 1. Managed-column profile resolution (`getEffectiveProfile(s)`) resolves
+  //    default profiles against the vellum column only, ignoring
+  //    `llm.defaultProvider`; on a BYO install that is not the body that
+  //    dispatches. Runtime code must use `resolveDefaultProfileForProvider` /
+  //    `getEffectiveProfilesForProvider` instead. The allowlist below is the
+  //    full set of intentional managed-column consumers: the catalog itself,
+  //    hatch-time seeding (writes managed stubs by design), and write-path
+  //    validation.
+  //
+  // 2. `cli/logger` is the plain-stdout writer for short-lived `assistant …`
+  //    invocations. It has no level filtering and no log-file routing, so a
+  //    daemon-side module reaching for it writes debug output straight to a
+  //    stdout the daemon may not own. Daemon code uses `getLogger()` from
+  //    `util/logger.js`. The pattern matches on the import specifier, so
+  //    CLI-internal files (which reach their logger relatively, as
+  //    `../logger.js`) are unaffected. The companion guard test
+  //    `src/__tests__/cli-logger-boundary-guard.test.ts` enforces the same
+  //    boundary by resolved path, independent of how a specifier is spelled.
   {
     files: ["src/**/*.ts"],
     ignores: [
@@ -77,6 +92,11 @@ const eslintConfig = defineConfig([
               message:
                 "Managed-column resolution ignores llm.defaultProvider. Use resolveDefaultProfileForProvider / getEffectiveProfilesForProvider with the parsed config's llm.defaultProvider ?? null.",
             },
+            {
+              group: ["**/cli/logger.js"],
+              message:
+                "cli/logger writes unfiltered plain text to stdout and is for src/cli/ only. Daemon and shared modules must use getLogger() from util/logger.js so output is level-filtered and routed to the log file. Within src/cli/, import the logger relatively (../logger.js).",
+            },
           ],
         },
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.1-dev.202608031736.2d0bed8",
+  "version": "0.11.1-dev.202608032034.aebd2da",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/cli-logger-boundary-guard.test.ts

@@ -0,0 +1,87 @@
+import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { Glob } from "bun";
+
+/**
+ * Guard test for the CLI-logger boundary.
+ *
+ * `src/cli/logger.ts` is the plain-stdout writer for short-lived `assistant …`
+ * invocations. It has no level filtering and no log-file routing, so a
+ * daemon-side module that reaches for it writes debug output straight to a
+ * stdout the daemon may not own. When the daemon runs detached and its
+ * spawning parent has closed the read end of the stdout pipe, those writes
+ * fail with `EPIPE` and take the process down through the fatal-error handler.
+ *
+ * Daemon and shared modules use `getLogger()` from `util/logger.js`, which
+ * routes to the rotating log file and skips stdout entirely when stdout is not
+ * a TTY.
+ *
+ * `no-restricted-imports` in `eslint.config.mjs` bans this too, but matches on
+ * the import specifier. This guard resolves each relative import to a path, so
+ * it holds regardless of how the specifier is spelled.
+ */
+
+/** Tests run from `assistant/`. */
+const ASSISTANT_ROOT = process.cwd();
+const CLI_LOGGER_PATH = resolve(ASSISTANT_ROOT, "src/cli/logger.ts");
+
+/** Modules allowed to import the CLI logger: the CLI itself, and tests. */
+function isExempt(relPath: string): boolean {
+  return (
+    relPath.startsWith("src/cli/") ||
+    relPath.includes("/__tests__/") ||
+    relPath.endsWith(".test.ts")
+  );
+}
+
+function findCliLoggerImporters(): string[] {
+  const pattern = /\b(?:from|import)\s*\(?\s*["'](\.[^"']*logger\.js)["']/g;
+  const violations = new Set<string>();
+
+  for (const relPath of new Glob("src/**/*.ts").scanSync({
+    cwd: ASSISTANT_ROOT,
+  })) {
+    if (isExempt(relPath)) {
+      continue;
+    }
+    const filePath = join(ASSISTANT_ROOT, relPath);
+    for (const match of readFileSync(filePath, "utf-8").matchAll(pattern)) {
+      // Imports carry the compiled `.js` extension; sources are `.ts`.
+      const resolved = resolve(
+        dirname(filePath),
+        match[1]!.replace(/\.js$/, ".ts"),
+      );
+      if (resolved === CLI_LOGGER_PATH) {
+        violations.add(relPath);
+        break;
+      }
+    }
+  }
+  return Array.from(violations).sort();
+}
+
+describe("CLI logger boundary", () => {
+  test("no production module outside src/cli/ imports cli/logger", () => {
+    expect(findCliLoggerImporters()).toEqual([]);
+  });
+
+  test("the guard resolves the CLI logger it is guarding", () => {
+    // A typo in CLI_LOGGER_PATH would make the guard above vacuously pass.
+    expect(readFileSync(CLI_LOGGER_PATH, "utf-8")).toContain("getCliLogger");
+  });
+
+  test("pinned-tabs logs through the daemon logger", () => {
+    // The incident site: pinned-tab mutations run inside daemon host-browser
+    // request handling, on every tab pin, select, close, and invalidation.
+    const source = readFileSync(
+      join(ASSISTANT_ROOT, "src/tools/browser/pinned-tabs.ts"),
+      "utf-8",
+    );
+
+    expect(source).toContain('from "../../util/logger.js"');
+    expect(source).toContain('getLogger("pinned-tabs")');
+    expect(source).not.toContain("cli/logger");
+  });
+});

package/src/config/__tests__/deployment-context-defaults.test.ts

@@ -52,6 +52,7 @@ afterAll(() => {
 });
 
 import { setStorePathForTesting } from "../../__tests__/encrypted-store-test-helpers.js";
+import { enableMemoryV3LiveForNewWorkspacesMigration } from "../../workspace/migrations/105-enable-memory-v3-live-for-new-workspaces.js";
 import { invalidateConfigCache, loadConfig } from "../loader.js";
 
 // ---------------------------------------------------------------------------
@@ -221,7 +222,7 @@ describe("deployment-context embedding-provider default (via loadConfig)", () =>
     expect(config.memory.qdrant.vectorSize).toBe(384);
   });
 
-  test("first launch seeds memory.v3 with only `live` — tuning knobs resolve from the schema, not disk", () => {
+  test("first launch persists nothing under memory.v3, not even `live`", () => {
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }
@@ -233,16 +234,37 @@ describe("deployment-context embedding-provider default (via loadConfig)", () =>
     expect(config.memory.v3.gate.denseThreshold).toBe(0.66);
     expect(config.memory.v3.needleK).toBe(100);
 
-    // Persisted config.json carries ONLY `live` under memory.v3 — no tuning knob
-    // is frozen to disk, so a shipped schema-default change reaches this
-    // assistant on its next load (mirrors the embedding-provider strip above).
+    // Nothing under memory.v3 is frozen to disk. Tuning knobs stay absent so a
+    // shipped schema-default change reaches this assistant on its next load
+    // (mirrors the embedding-provider strip above), and `live` stays absent so
+    // migration 105 can record the initial choice: 105 bails on any value
+    // already present, and this seed runs before workspace migrations.
     const raw = readConfig();
     const v3Raw = ((raw.memory as Record<string, unknown>).v3 ?? {}) as Record<
       string,
       unknown
     >;
-    expect(Object.keys(v3Raw)).toEqual(["live"]);
+    expect(Object.keys(v3Raw)).toEqual([]);
     expect(v3Raw.gate).toBeUndefined();
     expect(v3Raw.needleK).toBeUndefined();
   });
+
+  test("migration 105 turns v3 on for a workspace this seed just created", () => {
+    if (existsSync(CONFIG_PATH)) {
+      rmSync(CONFIG_PATH, { force: true });
+    }
+    delete process.env.IS_PLATFORM;
+
+    loadConfig();
+    enableMemoryV3LiveForNewWorkspacesMigration.run(WORKSPACE_DIR, {
+      isNewWorkspace: true,
+    });
+
+    const raw = readConfig();
+    const v3Raw = ((raw.memory as Record<string, unknown>).v3 ?? {}) as Record<
+      string,
+      unknown
+    >;
+    expect(v3Raw.live).toBe(true);
+  });
 });

package/src/config/loader.ts

@@ -1119,17 +1119,24 @@ export function loadConfig(): AssistantConfig {
         // Drop the deployment-context embedding provider so it is never
         // persisted (see above); the schema default re-applies in memory.
         delete (seed.memory.embeddings as { provider?: unknown }).provider;
-        // Memory-v3 tuning knobs are globally-shipped defaults, not per-assistant
-        // config: persist only `live` (genuine per-assistant state — some
-        // workspaces predate the v3 migration and must not be flipped on) and let
-        // every tuning knob resolve from the schema on load. This way a shipped
-        // schema-default change reaches all assistants (mirrors the
-        // embedding-provider strip above); migration
-        // 119-strip-persisted-memory-v3-tuning-defaults handles already-seeded
-        // configs.
-        seed.memory.v3 = {
-          live: seed.memory.v3.live,
-        } as (typeof seed.memory)["v3"];
+        // Nothing under memory.v3 is persisted at seed time.
+        //
+        // The tuning knobs are globally-shipped defaults: freezing them to
+        // disk would stop a shipped default change from reaching this
+        // assistant (mirrors the embedding-provider strip above; migration 119
+        // strips them from configs that already carry them).
+        //
+        // `live` stays absent because an absent leaf is the only way to
+        // express "no decision recorded". This seed runs before workspace
+        // migrations, and migration 105 defers to any value already present
+        // (`if ("live" in v3Config) return`), unable to tell a deliberate
+        // choice from a schema default. Writing the leaf here would pin a
+        // brand-new workspace to the schema default; leaving it absent lets
+        // 105 decide regardless of boot ordering. The schema default still
+        // applies in memory on every load, and a hatch-time
+        // `memory.v3.live=false` override still wins by merging after
+        // migrations.
+        seed.memory.v3 = {} as (typeof seed.memory)["v3"];
         // Strip dataDir (runtime-derived) from the persisted config
         const { dataDir: _, ...persistable } = seed;
         writeFileSync(configPath, JSON.stringify(persistable, null, 2) + "\n");

package/src/persistence/bookmark-crud.ts

@@ -1,4 +1,4 @@
-import { desc, eq } from "drizzle-orm";
+import { and, desc, eq, type SQL } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import type { DrizzleDb } from "./db-connection.js";
@@ -79,21 +79,30 @@ function rowToSummary(row: BookmarkJoinRow): BookmarkSummary {
   };
 }
 
-function selectBookmarkJoin(db: DrizzleDb) {
+/**
+ * CROSS JOIN constrains SQLite's join order to start from message_bookmarks,
+ * which the planner would otherwise skip in favor of a full messages scan
+ * because an empty table never has statistics. The join predicates live in
+ * WHERE with identical semantics; callers pass extra conditions through
+ * `filter` because chaining `.where()` would replace the predicates.
+ */
+function selectBookmarkJoin(db: DrizzleDb, filter?: SQL) {
+  const joinMatch = and(
+    eq(messages.id, messageBookmarks.messageId),
+    eq(conversations.id, messageBookmarks.conversationId),
+  );
   return db
     .select(BOOKMARK_JOIN_COLUMNS)
     .from(messageBookmarks)
-    .innerJoin(messages, eq(messages.id, messageBookmarks.messageId))
-    .innerJoin(
-      conversations,
-      eq(conversations.id, messageBookmarks.conversationId),
-    );
+    .crossJoin(messages)
+    .crossJoin(conversations)
+    .where(filter ? and(joinMatch, filter) : joinMatch);
 }
 
 /**
  * List all bookmarks newest-first, joined against `messages` and
  * `conversations`. Bookmarks whose parent message or conversation has
- * been deleted are naturally excluded by the inner-join semantics; the
+ * been deleted are naturally excluded by the join predicates; the
  * `ON DELETE CASCADE` on the FKs means rows should never end up in this
  * orphan state, but the join provides a defense-in-depth guarantee.
  */
@@ -179,7 +188,7 @@ function readBookmarkSummaryOrThrow(
   db: DrizzleDb,
   id: string,
 ): BookmarkSummary {
-  const row = selectBookmarkJoin(db).where(eq(messageBookmarks.id, id)).get();
+  const row = selectBookmarkJoin(db, eq(messageBookmarks.id, id)).get();
   if (!row) {
     // Unreachable: caller just observed (or inserted) this id.
     throw new Error(`Bookmark ${id} disappeared between insert and read`);

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

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

@@ -123,8 +123,26 @@ const fakeQdrant = {
   },
 };
 
+// The client is already initialized in this process, so the ops resolve it
+// straight from the singleton. `plugin-index-qdrant-init.test.ts` covers the
+// other side: a process where it is not.
 mock.module("../qdrant-client.js", () => ({
   getQdrantClient: () => fakeQdrant,
+  initQdrantClient: () => fakeQdrant,
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
+}));
+mock.module("../../../config/loader.js", () => ({
+  getConfig: () => ({
+    memory: {
+      qdrant: {
+        collection: "vellum_memory",
+        vectorSize: 3,
+        onDisk: true,
+        quantization: "none",
+      },
+      embeddings: { provider: "gemini" },
+    },
+  }),
 }));
 mock.module("../qdrant-circuit-breaker.js", () => ({
   withQdrantBreaker: <T>(fn: () => Promise<T>) => fn(),
@@ -137,6 +155,10 @@ mock.module("../embed.js", () => ({
   }),
 }));
 mock.module("../embedding-backend.js", () => ({
+  selectEmbeddingBackend: async () => ({
+    backend: { provider: "gemini", model: "test-embed-model" },
+    reason: null,
+  }),
   getMemoryBackendStatus: async () => ({
     enabled: true,
     degraded: false,

package/src/persistence/embeddings/plugin-index.ts

@@ -29,6 +29,7 @@
 
 import { randomUUID } from "node:crypto";
 
+import { getConfig } from "../../config/loader.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { BackendUnavailableError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
@@ -36,6 +37,7 @@ import { embedWithRetry } from "./embed.js";
 import {
   generateSparseEmbedding,
   getMemoryBackendStatus,
+  selectEmbeddingBackend,
 } from "./embedding-backend.js";
 import {
   type EmbeddingInput,
@@ -43,7 +45,12 @@ import {
   type SparseEmbedding,
 } from "./embedding-types.js";
 import { withQdrantBreaker } from "./qdrant-circuit-breaker.js";
-import { getQdrantClient } from "./qdrant-client.js";
+import {
+  getQdrantClient,
+  initQdrantClient,
+  resolveQdrantUrl,
+  type VellumQdrantClient,
+} from "./qdrant-client.js";
 
 const log = getLogger("plugin-index");
 
@@ -124,13 +131,78 @@ export interface IndexedDocument {
 
 // ── Internal helpers ───────────────────────────────────────────────────────
 
-/** The initialized Qdrant client, as a retryable unavailability if it is not up. */
-function requireQdrant(): ReturnType<typeof getQdrantClient> {
-  try {
-    return getQdrantClient();
-  } catch {
-    throw new BackendUnavailableError("Qdrant client not initialized");
+/**
+ * Config fingerprint of the client {@link resolveQdrant} last built, so a live
+ * config change is not served by a stale client. `VellumQdrantClient` captures
+ * its collection, dimension, and model identity at construction, so a client
+ * built before the change would keep writing at the old dimension (rejected by
+ * a resized collection) or quietly mix vectors from two models into one
+ * collection without triggering the sentinel migration.
+ */
+let clientConfigIdentity: string | null = null;
+
+/**
+ * The Qdrant client for the shared collection, initializing it from the live
+ * workspace config when this process has not.
+ *
+ * The eager `initQdrantClient` in `runMemoryStartup`
+ * (`plugins/defaults/memory/startup.ts`) cannot be relied on here: it runs in
+ * the daemon process only, and only while memory v1 is the live tier — on a
+ * default workspace (`memory.v2.enabled`, or `memory.v3.live`) it is skipped
+ * entirely, because no v1 lane reads or writes the collection in that state.
+ * The plugin index is not a memory tier: it is plugin-owned search that must
+ * work on every tier and in any process that runs plugin code, so it resolves
+ * the client itself rather than depending on a memory-tier decision. Mirrors
+ * `resolveLexicalIndex` in `persistence/job-handlers/message-lexical.ts`.
+ *
+ * Cheap: `initQdrantClient` only constructs a client — the collection is
+ * created lazily inside each operation — and the steady-state path is a
+ * fingerprint comparison, with the embedding-backend lookup reached only when
+ * the config it derives from has actually changed.
+ *
+ * The dense embedding identity is passed through so a collection created or
+ * reused from here keeps the same model-sentinel semantics as the v1 path: a
+ * model or dimension change recreates the collection, which is the durability
+ * contract documented at the top of this file.
+ */
+async function resolveQdrant(): Promise<VellumQdrantClient> {
+  const config = getConfig();
+  const url = resolveQdrantUrl(config);
+  const { collection, vectorSize, onDisk, quantization } = config.memory.qdrant;
+  // `memory.embeddings` rather than the resolved backend: it is what the
+  // resolution below reads, and comparing it keeps that lookup off the hot
+  // path. Over-sensitive by a field or two (a `required` flip re-inits), which
+  // costs one redundant construction and never a wrong client.
+  const identity = JSON.stringify([
+    url,
+    collection,
+    vectorSize,
+    onDisk,
+    quantization,
+    config.memory.embeddings,
+  ]);
+
+  if (identity === clientConfigIdentity) {
+    try {
+      return getQdrantClient();
+    } catch {
+      // Fingerprint outlived the singleton (another module reset it) — rebuild.
+    }
   }
+
+  const selection = await selectEmbeddingBackend(config);
+  const client = initQdrantClient({
+    url,
+    collection,
+    vectorSize,
+    onDisk,
+    quantization,
+    embeddingModel: selection.backend
+      ? `${selection.backend.provider}:${selection.backend.model}`
+      : undefined,
+  });
+  clientConfigIdentity = identity;
+  return client;
 }
 
 /** Embed a single input to a dense vector, failing loudly if no backend is up. */
@@ -208,7 +280,7 @@ export async function indexDocument(
   const normalized = normalizeEmbeddingInput(input);
   const documentId = opts?.documentId ?? randomUUID();
   const now = opts?.createdAt ?? Date.now();
-  const qdrant = requireQdrant();
+  const qdrant = await resolveQdrant();
 
   await withQdrantBreaker(() =>
     qdrant.upsert(
@@ -249,7 +321,7 @@ export async function queryIndex(
   const embedding = await embedDense(config, query);
   const sparseVector = sparseFor(query);
   const limit = opts?.limit ?? 10;
-  const qdrant = requireQdrant();
+  const qdrant = await resolveQdrant();
 
   const filter = {
     must: [
@@ -290,7 +362,7 @@ export async function getDocument(
   plugin: string,
   documentId: string,
 ): Promise<IndexedDocument | null> {
-  const qdrant = requireQdrant();
+  const qdrant = await resolveQdrant();
   const found = await withQdrantBreaker(() =>
     qdrant.getByTarget(
       PLUGIN_INDEX_TARGET_TYPE,
@@ -315,7 +387,7 @@ export async function removeDocument(
   plugin: string,
   documentId: string,
 ): Promise<void> {
-  const qdrant = requireQdrant();
+  const qdrant = await resolveQdrant();
   await withQdrantBreaker(() =>
     qdrant.deleteByTargetAndPlugin(
       PLUGIN_INDEX_TARGET_TYPE,
@@ -333,7 +405,7 @@ export async function removeDocument(
  */
 export async function purgeEmbeddingsForPlugin(plugin: string): Promise<void> {
   try {
-    const qdrant = requireQdrant();
+    const qdrant = await resolveQdrant();
     await withQdrantBreaker(() => qdrant.deleteByPlugin(plugin));
   } catch (err) {
     log.warn({ err, plugin }, "Failed to purge plugin embeddings");

package/src/persistence/planner-statistics.ts

@@ -0,0 +1,14 @@
+/**
+ * The `PRAGMA optimize` mask run by the daily maintenance sweep and by
+ * `db-init` after a boot that applied migrations.
+ *
+ * Both run on connections with no useful query history, so `0x10000` is what
+ * lets optimize look past tables missing from `sqlite_stat1` and reconsider
+ * ones whose entries have gone stale. `0x2` keeps the default "analyze where
+ * it helps" behavior and `0x10` bounds each ANALYZE with a temporary
+ * `analysis_limit`. Releases before 3.46 ignore bits they do not recognize
+ * rather than failing, so the mask is safe to send to any version.
+ *
+ * https://sqlite.org/lang_analyze.html#recommended_usage_patterns
+ */
+export const PLANNER_OPTIMIZE_PRAGMA = "PRAGMA optimize=0x10012";

package/src/plugins/defaults/memory/__tests__/bookmark-crud.test.ts

@@ -261,4 +261,38 @@ describe("bookmark-crud", () => {
       /Message ghost not found/,
     );
   });
+
+  test("listBookmarks drives the join from message_bookmarks even with planner stats that predate the table", () => {
+    const sqlite = new Database(":memory:");
+    sqlite.exec("PRAGMA foreign_keys = ON");
+    const captured: string[] = [];
+    const db = drizzle(sqlite, {
+      schema,
+      logger: { logQuery: (query: string) => captured.push(query) },
+    });
+    const raw = getSqliteFrom(db);
+    bootstrapMessageTables(raw);
+    migrateMessageBookmarks(db);
+    for (let i = 0; i < 30; i++) {
+      seedConversationAndMessage(raw, {
+        conversationId: `conv-${i}`,
+        messageId: `msg-${i}`,
+      });
+    }
+    // ANALYZE writes no sqlite_stat1 rows for an empty table, leaving
+    // message_bookmarks without statistics while messages gets them. This is
+    // the production state that made the planner scan messages.
+    raw.exec("ANALYZE");
+
+    listBookmarks(db);
+    const sql = captured.at(-1);
+    expect(sql).toBeDefined();
+    const plan = raw.query(`EXPLAIN QUERY PLAN ${sql}`).all() as Array<{
+      detail: string;
+    }>;
+    expect(plan[0]?.detail ?? "").toMatch(/^SCAN message_bookmarks/);
+    expect(plan.some((row) => row.detail.includes("SCAN messages"))).toBe(
+      false,
+    );
+  });
 });

package/src/tools/browser/pinned-tabs.ts

@@ -14,7 +14,9 @@
  * `host_browser_session_invalidated`.
  */
 
-import { log } from "../../cli/logger.js";
+import { getLogger } from "../../util/logger.js";
+
+const log = getLogger("pinned-tabs");
 
 const pinnedTabs = new Map<string, Map<string, string>>();