@vellumai/assistant 0.11.1 → 0.11.2-staging.2

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/__tests__/worker-script-version.test.ts

@@ -0,0 +1,76 @@
+/**
+ * Tripwire coupling the generated worker scripts to the cache-invalidation
+ * version that ships them.
+ *
+ * `isReady()` short-circuits `ensureInstalled()` whenever the on-disk manifest
+ * matches RUNTIME_VERSION, and the worker scripts are only written from
+ * `install()`. So editing a generator without bumping the trailing
+ * `_workers-vN` suffix leaves every existing install running the old scripts,
+ * and the change silently does nothing for anyone who already downloaded the
+ * runtime. That is a shipped no-op with green CI, which is why it needs a
+ * mechanical check rather than reviewer memory.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  generateRerankWorkerScript,
+  generateWorkerScript,
+  RUNTIME_VERSION,
+} from "../embedding-runtime-manager.js";
+
+/**
+ * Fingerprint of the two generated scripts. Update this together with the
+ * `_workers-vN` bump below, never on its own.
+ */
+const EXPECTED_WORKER_SCRIPTS_HASH = "4f85253eaebd315";
+
+/** Suffix the fingerprint above was taken at. */
+const EXPECTED_WORKERS_VERSION = "workers-v4";
+
+function workerScriptsHash(): string {
+  // The two scripts are joined by a NUL, written as an escape so this file
+  // stays ASCII text rather than tripping git's binary heuristic. NUL cannot
+  // occur inside either generated script, so text moving from one worker to
+  // the other can never hash the same as the unchanged pair.
+  return Bun.hash(
+    generateWorkerScript() + "\u0000" + generateRerankWorkerScript(),
+  ).toString(16);
+}
+
+describe("worker script cache invalidation", () => {
+  test("a change to either generator comes with a _workers-vN bump", () => {
+    const actual = workerScriptsHash();
+    expect(
+      actual,
+      [
+        "The generated worker scripts changed.",
+        "",
+        "Existing installs only regenerate these scripts when RUNTIME_VERSION",
+        "changes, so bump the trailing `_workers-vN` suffix in",
+        "embedding-runtime-manager.ts, then update both constants in this test:",
+        "",
+        `  EXPECTED_WORKER_SCRIPTS_HASH = "${actual}"`,
+        `  EXPECTED_WORKERS_VERSION     = "workers-v<N+1>"`,
+        "",
+        "Skipping the bump ships a silent no-op for every existing install.",
+      ].join("\n"),
+    ).toBe(EXPECTED_WORKER_SCRIPTS_HASH);
+  });
+
+  test("RUNTIME_VERSION carries the workers suffix the hash was taken at", () => {
+    expect(RUNTIME_VERSION.endsWith(`_${EXPECTED_WORKERS_VERSION}`)).toBe(true);
+  });
+
+  test("both workers read the intra-op thread cap the host sets", () => {
+    // Guards the JARVIS-1398 wiring specifically: the host computing a cap is
+    // useless if the scripts on disk never consult it.
+    for (const script of [
+      generateWorkerScript(),
+      generateRerankWorkerScript(),
+    ]) {
+      expect(script).toContain("VELLUM_ONNX_INTRA_OP_THREADS");
+      expect(script).toContain("session_options: sessionOptions");
+    }
+  });
+});

package/src/persistence/embeddings/embedding-local.ts

@@ -15,6 +15,7 @@ import {
   getEmbedWorkerPidPath,
 } from "../../util/platform.js";
 import { PromiseGuard } from "../../util/promise-guard.js";
+import { workerComputeEnv } from "../../util/worker-compute.js";
 import { workerMemoryEnv } from "../../util/worker-memory.js";
 import { EmbeddingRuntimeManager } from "./embedding-runtime-manager.js";
 import {
@@ -509,7 +510,7 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
 
     const proc = Bun.spawn({
       cmd: [bunPath, "--smol", workerPath, this.model, modelCacheDir],
-      env: workerMemoryEnv(),
+      env: { ...workerMemoryEnv(), ...workerComputeEnv() },
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe",

package/src/persistence/embeddings/embedding-runtime-manager.ts

@@ -43,8 +43,13 @@ const JINJA_VERSION = "0.5.5";
  * `_workers-vN` suffix forces existing installs to regenerate the worker
  * scripts when the worker IPC contract or spawn-args list changes (without
  * requiring an `@huggingface/transformers` version bump).
+ *
+ * v4: workers read `VELLUM_ONNX_INTRA_OP_THREADS` and pass
+ * `session_options.intraOpNumThreads` (JARVIS-1398). The environment the host
+ * spawns them with counts as part of the contract, so an install that keeps
+ * the v3 scripts would silently ignore the cap.
  */
-const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}_workers-v3`;
+export const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}_workers-v4`;
 
 const WORKER_FILENAME = "embed-worker.mjs";
 const RERANK_WORKER_FILENAME = "rerank-worker.mjs";
@@ -116,7 +121,7 @@ async function downloadAndExtract(
 
 // ── Worker script content ───────────────────────────────────────────
 
-function generateWorkerScript(): string {
+export function generateWorkerScript(): string {
   // This script is run by a standalone bun process (not the compiled daemon).
   // Because it runs in a real bun runtime, bare specifier resolution works
   // normally — node_modules/ in the same directory is found automatically.
@@ -130,9 +135,19 @@ const model = process.argv[2];
 const cacheDir = process.argv[3];
 if (cacheDir && env) env.cacheDir = cacheDir;
 
+// Cap the ONNX intra-op thread pool. Left unset, ONNX takes one thread per
+// physical core for the whole batch and starves foreground work; the host
+// computes the cap in util/worker-compute.ts and passes it in the environment.
+// A missing or unparseable value means no cap, i.e. the ONNX default.
+const intraOpNumThreads = Number(process.env.VELLUM_ONNX_INTRA_OP_THREADS);
+const sessionOptions =
+  Number.isInteger(intraOpNumThreads) && intraOpNumThreads > 0
+    ? { intraOpNumThreads }
+    : undefined;
+
 let extractor;
 try {
-  extractor = await pipeline('feature-extraction', model, { dtype: 'fp32' });
+  extractor = await pipeline('feature-extraction', model, { dtype: 'fp32', session_options: sessionOptions });
   process.stdout.write(JSON.stringify({ type: 'ready' }) + '\\n');
 } catch (err) {
   process.stdout.write(JSON.stringify({ type: 'error', error: err.message || String(err) }) + '\\n');
@@ -177,7 +192,7 @@ process.stdin.on('end', () => process.exit(0));
 `;
 }
 
-function generateRerankWorkerScript(): string {
+export function generateRerankWorkerScript(): string {
   // Cross-encoder rerank worker. Loads a sequence-classification model and
   // scores paired (queries[i], passages[i]) tuples in one batched ONNX
   // inference call. Mirrors the embed worker's lifecycle (ready signal,
@@ -204,11 +219,20 @@ const cacheDir = process.argv[3];
 const dtype = process.argv[4] || 'q8';
 if (cacheDir && env) env.cacheDir = cacheDir;
 
+// Cap the ONNX intra-op thread pool. See the embed worker for the rationale;
+// the host computes the cap in util/worker-compute.ts and passes it in the
+// environment. A missing or unparseable value means no cap, i.e. the default.
+const intraOpNumThreads = Number(process.env.VELLUM_ONNX_INTRA_OP_THREADS);
+const sessionOptions =
+  Number.isInteger(intraOpNumThreads) && intraOpNumThreads > 0
+    ? { intraOpNumThreads }
+    : undefined;
+
 let tokenizer;
 let session;
 try {
   tokenizer = await AutoTokenizer.from_pretrained(model);
-  session = await AutoModelForSequenceClassification.from_pretrained(model, { dtype });
+  session = await AutoModelForSequenceClassification.from_pretrained(model, { dtype, session_options: sessionOptions });
   process.stdout.write(JSON.stringify({ type: 'ready' }) + '\\n');
 } catch (err) {
   process.stdout.write(JSON.stringify({ type: 'error', error: err.message || String(err) }) + '\\n');

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/migrations/360-add-document-workspace-path.test.ts

@@ -0,0 +1,110 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateAddDocumentWorkspacePath } from "./360-add-document-workspace-path.js";
+
+/** Pre-360 shape: the documents table exactly as core tables created it. */
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE documents (
+      surface_id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    INSERT INTO conversations (id, created_at) VALUES ('conv-1', 1000);
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function columnInfo(sqlite: Database) {
+  return sqlite.query("PRAGMA table_info(documents)").all() as Array<{
+    name: string;
+    notnull: number;
+  }>;
+}
+
+function insertDocument(
+  sqlite: Database,
+  surfaceId: string,
+  workspacePath: string | null,
+): void {
+  sqlite
+    .query(
+      /*sql*/ `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at, workspace_path)
+       VALUES (?, 'conv-1', 'Doc', '', 0, 1000, 1000, ?)`,
+    )
+    .run(surfaceId, workspacePath);
+}
+
+describe("migration 360: documents.workspace_path", () => {
+  test("adds the nullable column to an existing database", () => {
+    const { sqlite, db } = createTestDb();
+    expect(columnInfo(sqlite).map((c) => c.name)).not.toContain(
+      "workspace_path",
+    );
+
+    migrateAddDocumentWorkspacePath(db);
+
+    const column = columnInfo(sqlite).find((c) => c.name === "workspace_path");
+    expect(column).toBeDefined();
+    expect(column?.notnull).toBe(0);
+  });
+
+  test("rows written before the column existed read back null", () => {
+    const { sqlite, db } = createTestDb();
+    sqlite.exec(/*sql*/ `
+      INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at)
+      VALUES ('doc-old', 'conv-1', 'Old', 'body', 1, 1000, 1000)
+    `);
+
+    migrateAddDocumentWorkspacePath(db);
+
+    const row = sqlite
+      .query(
+        "SELECT workspace_path FROM documents WHERE surface_id = 'doc-old'",
+      )
+      .get() as { workspace_path: unknown };
+    expect(row.workspace_path).toBeNull();
+  });
+
+  test("rejects a second document bound to the same file", () => {
+    const { sqlite, db } = createTestDb();
+    migrateAddDocumentWorkspacePath(db);
+
+    insertDocument(sqlite, "doc-a", "notes/plan.md");
+
+    expect(() => insertDocument(sqlite, "doc-b", "notes/plan.md")).toThrow();
+  });
+
+  test("leaves file-less documents unconstrained", () => {
+    const { sqlite, db } = createTestDb();
+    migrateAddDocumentWorkspacePath(db);
+
+    insertDocument(sqlite, "doc-a", null);
+    expect(() => insertDocument(sqlite, "doc-b", null)).not.toThrow();
+  });
+
+  test("is idempotent: re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateAddDocumentWorkspacePath(db);
+    expect(() => migrateAddDocumentWorkspacePath(db)).not.toThrow();
+
+    const names = columnInfo(sqlite).map((c) => c.name);
+    expect(names.filter((n) => n === "workspace_path")).toHaveLength(1);
+  });
+});

package/src/persistence/migrations/360-add-document-workspace-path.ts

@@ -0,0 +1,39 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+
+const COLUMN_NAME = "workspace_path";
+const COLUMN_DEFINITION = "workspace_path TEXT";
+
+/**
+ * Add `workspace_path` to `documents` and enforce one document per file.
+ *
+ * The column holds the workspace-relative path of the markdown file a document
+ * is bound to. It is set when a client opens a workspace `.md` file through
+ * `POST /v1/documents/for-workspace-file`, which gives the file a document
+ * identity so comments, assistant iteration, and PDF export — all keyed off a
+ * document id — work on it. Documents that have no file behind them (assistant
+ * drafts, client-created surfaces) stay NULL.
+ *
+ * The unique index is partial (`WHERE workspace_path IS NOT NULL`) so the many
+ * NULL rows stay unconstrained while a given file resolves to exactly one
+ * document. The find-or-create route depends on that uniqueness for its
+ * idempotency.
+ *
+ * Nullable with no backfill: nothing recorded a file binding before this
+ * column existed, so pre-existing rows correctly stay NULL.
+ *
+ * Idempotent: the column add is guarded with `tableHasColumn` and the index
+ * with `IF NOT EXISTS`, so a crash between the two does not break the next
+ * boot.
+ */
+export function migrateAddDocumentWorkspacePath(database: DrizzleDb): void {
+  if (!tableHasColumn(database, "documents", COLUMN_NAME)) {
+    database.run(`ALTER TABLE documents ADD COLUMN ${COLUMN_DEFINITION}`);
+  }
+
+  database.run(/*sql*/ `
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_documents_workspace_path
+    ON documents(workspace_path)
+    WHERE workspace_path IS NOT NULL
+  `);
+}

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/persistence/schema/documents.ts

@@ -1,24 +1,39 @@
+import { sql } from "drizzle-orm";
 import {
   index,
   integer,
   primaryKey,
   sqliteTable,
   text,
+  uniqueIndex,
 } from "drizzle-orm/sqlite-core";
 
 import { conversations } from "./conversations.js";
 
-export const documents = sqliteTable("documents", {
-  surfaceId: text("surface_id").primaryKey(),
-  conversationId: text("conversation_id")
-    .notNull()
-    .references(() => conversations.id, { onDelete: "cascade" }),
-  title: text("title").notNull(),
-  content: text("content").notNull(),
-  wordCount: integer("word_count").notNull().default(0),
-  createdAt: integer("created_at").notNull(),
-  updatedAt: integer("updated_at").notNull(),
-});
+export const documents = sqliteTable(
+  "documents",
+  {
+    surfaceId: text("surface_id").primaryKey(),
+    conversationId: text("conversation_id")
+      .notNull()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    content: text("content").notNull(),
+    wordCount: integer("word_count").notNull().default(0),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+    // Workspace-relative path of the markdown file this document is bound to.
+    // NULL for documents with no file behind them.
+    workspacePath: text("workspace_path"),
+  },
+  (table) => [
+    // Partial so the many file-less documents stay unconstrained while a given
+    // file resolves to exactly one document.
+    uniqueIndex("idx_documents_workspace_path")
+      .on(table.workspacePath)
+      .where(sql`workspace_path IS NOT NULL`),
+  ],
+);
 
 // Junction table mapping a document surface to every conversation it appears in.
 export const documentConversations = sqliteTable(

package/src/persistence/steps.ts

@@ -467,6 +467,7 @@ import { migrateAddSubagentParentToolUseId } from "./migrations/356-add-subagent
 import { migrateMoveMemorySegmentsToMemoryDb } from "./migrations/357-move-memory-segments-to-memory-db.js";
 import { migrateMoveMemoryEmbeddingsToMemoryDb } from "./migrations/358-move-memory-embeddings-to-memory-db.js";
 import { migrateMoveMemorySummariesToMemoryDb } from "./migrations/359-move-memory-summaries-to-memory-db.js";
+import { migrateAddDocumentWorkspacePath } from "./migrations/360-add-document-workspace-path.js";
 import type { MigrationStep } from "./migrations/run-migrations.js";
 
 export const migrationSteps: MigrationStep[] = [
@@ -1541,4 +1542,5 @@ export const migrationSteps: MigrationStep[] = [
       "migrateMemorySummariesScopeUpdatedIndex",
     ],
   },
+  migrateAddDocumentWorkspacePath,
 ];