@vortex-os/memory-extended 0.5.1

package/dist/vector/types.d.ts

@@ -0,0 +1,109 @@
+/**
+ * `vector` namespace types — semantic similarity over markdown memories.
+ *
+ * Phase 11c, operator decisions (2026-05-29 afternoon):
+ *
+ *  - **Decision 1 (embedder)** — host-injected `EmbedFn`. A default local
+ *    embedder (`createLocalEmbedder`, `@huggingface/transformers` MiniLM)
+ *    ships with this package and loads lazily on first use; operators can
+ *    swap it for an API embedder by passing their own `EmbedFn`.
+ *  - **Decision 2 (backend)** — default is in-process brute-force cosine
+ *    (`BruteForceBackend`), no native vector engine. The `VectorBackend`
+ *    interface keeps sqlite-vec / Qdrant as drop-in upgrades once the
+ *    corpus outgrows brute force (≈10k+ vectors). This intentionally
+ *    deviates from the design doc's original sqlite-vec default — see
+ *    `docs/memory-extended-design.md` §vector namespace revision.
+ *  - **Decision 3 (storage)** — vectors live in the *same* `memory.sqlite`
+ *    as a plain `memory_vectors` table (Float32 BLOB). No extension, no
+ *    second file; one DB, one rebuild path.
+ *  - **Decision 5 (scope)** — `source` discriminates `"memory"` vs
+ *    `"session-archive"`. This cycle populates `"memory"` only; the
+ *    session-archive column is plumbing for a later cycle.
+ */
+/** A dense embedding. Either form is accepted; the store normalizes to Float32Array. */
+export type EmbedVector = Float32Array | readonly number[];
+/**
+ * Whether a text is being embedded as an indexed document (`passage`) or as
+ * a search query (`query`). Most embedders ignore this, but asymmetric
+ * retrieval models (the e5 family) require a different instruction prefix
+ * for each side. `undefined` is treated as `passage` (the indexing path).
+ */
+export type EmbedKind = "query" | "passage";
+/**
+ * Host-supplied embedding function: text in, dense vector out.
+ *
+ * Mirrors the `LLMJudge` / `TranscriptAdapter` host-injection pattern —
+ * the namespace does not hard-depend on any particular embedding runtime.
+ * The default `createLocalEmbedder()` satisfies this signature; an OpenAI /
+ * Voyage adapter would too.
+ *
+ * The optional `kind` lets asymmetric models (e5) prefix query vs passage
+ * differently. Indexing call sites omit it (→ passage); only the recall
+ * query path passes `"query"`. Symmetric models ignore the argument.
+ *
+ * Implementations should return a vector of stable dimensionality for a
+ * given configuration. The store records each vector's `dim` and refuses
+ * to compare across mismatched dimensions (a model change is surfaced as a
+ * rebuild signal rather than silently producing garbage similarities).
+ */
+export type EmbedFn = (text: string, kind?: EmbedKind) => Promise<EmbedVector>;
+/** Which corpus a vector belongs to. `memory` is populated this cycle. */
+export type VectorSource = "memory" | "session-archive";
+/** One stored vector row. */
+export interface VectorRow {
+    readonly id: string;
+    readonly source: VectorSource;
+    readonly dim: number;
+    readonly vector: Float32Array;
+}
+/** A search result: id + cosine similarity (1 = identical direction). */
+export interface VectorSearchHit {
+    readonly id: string;
+    readonly source: VectorSource;
+    readonly score: number;
+}
+/** Options for a vector search. */
+export interface VectorSearchOptions {
+    /** Max hits to return. Default 10. */
+    readonly k?: number;
+    /** Restrict to one source. Omit to search all sources. */
+    readonly source?: VectorSource;
+    /**
+     * Optional id allowlist — restrict the search to these ids. Used by the
+     * `recall` engine to apply a SQLite hard-filter before semantic rerank.
+     * Omit to search the whole index.
+     */
+    readonly ids?: ReadonlySet<string>;
+}
+/**
+ * Pluggable storage + similarity backend.
+ *
+ * The default `BruteForceBackend` persists vectors in a SQLite table and
+ * computes cosine in JavaScript. A future `SqliteVecBackend` or
+ * `QdrantBackend` implements the same interface; `MemoryVectorStore` is
+ * backend-agnostic.
+ */
+export interface VectorBackend {
+    /** Insert or replace a vector for (id, source). */
+    upsert(row: VectorRow): void;
+    /** Remove a vector. Returns true if a row was deleted. */
+    delete(id: string, source?: VectorSource): boolean;
+    /** Brute-force / ANN search for the query vector. Synchronous. */
+    search(query: Float32Array, options?: VectorSearchOptions): readonly VectorSearchHit[];
+    /** Ids currently indexed (for drift / rebuild bookkeeping). */
+    listIds(source?: VectorSource): readonly string[];
+    /** Number of vectors indexed. */
+    count(source?: VectorSource): number;
+    /** Release any held resources (DB handle). */
+    close(): void;
+}
+/** Result of {@link MemoryVectorStore.rebuild}. */
+export interface VectorRebuildResult {
+    /** Memories embedded + written. */
+    readonly indexed: number;
+    /** Memories skipped (empty text after trim). */
+    readonly skipped: number;
+    /** Stale vectors removed (id present in index but no longer in source). */
+    readonly pruned: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/vector/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/vector/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wFAAwF;AACxF,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,SAAS,MAAM,EAAE,CAAC;AAE3D;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAE5C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;AAE/E,0EAA0E;AAC1E,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,iBAAiB,CAAC;AAExD,6BAA6B;AAC7B,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,mCAAmC;AACnC,MAAM,WAAW,mBAAmB;IAClC,sCAAsC;IACtC,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,MAAM,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IAC7B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC;IACnD,kEAAkE;IAClE,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,SAAS,eAAe,EAAE,CAAC;IACvF,+DAA+D;IAC/D,OAAO,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,SAAS,MAAM,EAAE,CAAC;IAClD,iCAAiC;IACjC,KAAK,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC;IACrC,8CAA8C;IAC9C,KAAK,IAAI,IAAI,CAAC;CACf;AAED,mDAAmD;AACnD,MAAM,WAAW,mBAAmB;IAClC,mCAAmC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB"}

package/dist/vector/types.js

@@ -0,0 +1,24 @@
+/**
+ * `vector` namespace types — semantic similarity over markdown memories.
+ *
+ * Phase 11c, operator decisions (2026-05-29 afternoon):
+ *
+ *  - **Decision 1 (embedder)** — host-injected `EmbedFn`. A default local
+ *    embedder (`createLocalEmbedder`, `@huggingface/transformers` MiniLM)
+ *    ships with this package and loads lazily on first use; operators can
+ *    swap it for an API embedder by passing their own `EmbedFn`.
+ *  - **Decision 2 (backend)** — default is in-process brute-force cosine
+ *    (`BruteForceBackend`), no native vector engine. The `VectorBackend`
+ *    interface keeps sqlite-vec / Qdrant as drop-in upgrades once the
+ *    corpus outgrows brute force (≈10k+ vectors). This intentionally
+ *    deviates from the design doc's original sqlite-vec default — see
+ *    `docs/memory-extended-design.md` §vector namespace revision.
+ *  - **Decision 3 (storage)** — vectors live in the *same* `memory.sqlite`
+ *    as a plain `memory_vectors` table (Float32 BLOB). No extension, no
+ *    second file; one DB, one rebuild path.
+ *  - **Decision 5 (scope)** — `source` discriminates `"memory"` vs
+ *    `"session-archive"`. This cycle populates `"memory"` only; the
+ *    session-archive column is plumbing for a later cycle.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/vector/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/vector/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@vortex-os/memory-extended",
+  "version": "0.5.1",
+  "description": "Add-on cluster — extended memory namespaces (sqlite, vector, sessionArchive, recall, consolidate) layered on @vortex-os/base.",
+  "license": "MIT",
+  "author": "vortex-os-project",
+  "homepage": "https://github.com/vortex-os-project/vortex#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vortex-os-project/vortex.git",
+    "directory": "modules/memory-extended"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./sessionArchive": {
+      "types": "./dist/sessionArchive/index.d.ts",
+      "default": "./dist/sessionArchive/index.js"
+    },
+    "./consolidate": {
+      "types": "./dist/consolidate/index.d.ts",
+      "default": "./dist/consolidate/index.js"
+    },
+    "./sqlite": {
+      "types": "./dist/sqlite/index.d.ts",
+      "default": "./dist/sqlite/index.js"
+    },
+    "./vector": {
+      "types": "./dist/vector/index.d.ts",
+      "default": "./dist/vector/index.js"
+    },
+    "./recall": {
+      "types": "./dist/recall/index.d.ts",
+      "default": "./dist/recall/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp/index.d.ts",
+      "default": "./dist/mcp/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "scripts/rebuild-memory-sqlite.mjs",
+    "scripts/rebuild-memory-vector.mjs",
+    "scripts/mcp-stdio.mjs",
+    "README.md"
+  ],
+  "bin": {
+    "rebuild-memory-sqlite": "scripts/rebuild-memory-sqlite.mjs",
+    "rebuild-memory-vector": "scripts/rebuild-memory-vector.mjs",
+    "vortex-mcp-recall": "scripts/mcp-stdio.mjs"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "verify": "node scripts/verify.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "yaml": "^2.6.0"
+  },
+  "_releaseNote": "@vortex-os/base (^0.3.0 || ^0.4.0) is the only @vortex-os peer; it is published. The proactive-curator surface this add-on used is inlined (src/internal/proactive-curator-helpers.ts), so no separate @vortex-os/proactive-curator dependency is needed. better-sqlite3 / classic-level are native peers.",
+  "peerDependencies": {
+    "@vortex-os/base": "^0.3.0 || ^0.4.0",
+    "better-sqlite3": "^12.0.0",
+    "classic-level": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@vortex-os/base": {
+      "optional": false
+    },
+    "better-sqlite3": {
+      "optional": false
+    },
+    "classic-level": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@huggingface/transformers": "^3.0.0",
+    "@modelcontextprotocol/sdk": "^1.21.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "better-sqlite3": "^12.10.0",
+    "classic-level": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/mcp-stdio.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * vortex-mcp-recall — MCP recall surface for memory-extended.
+ *
+ * Two modes:
+ *
+ *   1. Serve (default) — run the stdio server. Usually launched by an MCP host
+ *      such as Claude Desktop, not by hand:
+ *        npx vortex-mcp-recall [--data-dir <path>]
+ *      Resolves the data dir (--data-dir flag, VORTEX_DATA_DIR, or cwd), builds
+ *      the local embedder once, opens the recall stores under <dataDir>/_indexes/,
+ *      and serves MCP over stdio. NEVER writes to stdout (the protocol channel);
+ *      diagnostics go to stderr. Requires the optional `@modelcontextprotocol/sdk`.
+ *
+ *   2. Install — register this server in Claude Desktop's config (slice 2):
+ *        npx vortex-mcp-recall install --data-dir <path> [options]
+ *      Merges our one server entry into claude_desktop_config.json WITHOUT
+ *      touching any other server. Options:
+ *        --data-dir <path>   (required) instance data dir
+ *        --config <path>     override the config file location
+ *        --key <name>        server key (default "vortex-recall")
+ *        --command <cmd>     launcher (default "npx")
+ *        --dry-run           show what would change; write nothing
+ *        --print             print the merged config to stdout; write nothing
+ */
+import { join } from "node:path";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, copyFileSync } from "node:fs";
+import { vector, mcp } from "../dist/index.js";
+
+function getFlag(argv, name) {
+  const i = argv.indexOf(name);
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : undefined;
+}
+function hasFlag(argv, name) {
+  return argv.includes(name);
+}
+
+function resolveDataDir(argv, env) {
+  return getFlag(argv, "--data-dir") ?? env.VORTEX_DATA_DIR?.trim() ?? process.cwd();
+}
+
+function resolveDbPath(dataDir) {
+  return join(dataDir, "_indexes", "memory.sqlite");
+}
+
+// ── serve mode ──────────────────────────────────────────────────────────────
+async function serve(argv, env) {
+  const dataDir = resolveDataDir(argv, env);
+  const dbPath = resolveDbPath(dataDir);
+
+  // Build the embedder once: the model load is the only heavy cost; reusing the
+  // returned function keeps every subsequent recall fast.
+  const embed = vector.createLocalEmbedder();
+  const server = await mcp.createRecallServer({ embed, dbPath, dataDir });
+
+  // The transport is also part of the optional SDK — resolved at runtime.
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  await server.connect(new StdioServerTransport());
+
+  process.stderr.write(`[vortex-mcp-recall] recall server ready (db: ${dbPath})\n`);
+}
+
+// ── install mode ────────────────────────────────────────────────────────────
+function install(argv, env) {
+  const dataDir = getFlag(argv, "--data-dir") ?? env.VORTEX_DATA_DIR?.trim();
+  if (!dataDir) {
+    process.stderr.write(
+      "[vortex-mcp-recall] install: --data-dir <path> is required " +
+        "(the absolute path to your instance data directory).\n",
+    );
+    process.exit(1);
+  }
+
+  const configPath = getFlag(argv, "--config") ?? mcp.claudeDesktopConfigPath();
+  const key = getFlag(argv, "--key") ?? mcp.DEFAULT_SERVER_KEY;
+  const command = getFlag(argv, "--command");
+  const dryRun = hasFlag(argv, "--dry-run");
+  const printOnly = hasFlag(argv, "--print");
+
+  const entry = mcp.buildRecallServerEntry(command ? { dataDir, command } : { dataDir });
+
+  // Read + parse existing config (empty/missing → fresh {}; malformed → abort).
+  let existingText = null;
+  if (existsSync(configPath)) {
+    existingText = readFileSync(configPath, "utf8");
+  }
+  let existingConfig;
+  try {
+    existingConfig = mcp.parseExistingConfig(existingText);
+  } catch (e) {
+    process.stderr.write(`[vortex-mcp-recall] install: ${e.message}\n  config: ${configPath}\n`);
+    process.exit(1);
+  }
+
+  const { config, action, preservedKeys } = mcp.mergeServerEntry(existingConfig, entry, key);
+  const serialized = mcp.serializeConfig(config);
+
+  if (printOnly) {
+    process.stdout.write(serialized);
+    return;
+  }
+
+  if (dryRun) {
+    process.stderr.write(
+      `[vortex-mcp-recall] install --dry-run\n` +
+        `  config:    ${configPath}\n` +
+        `  action:    ${action} server "${key}"\n` +
+        `  command:   ${entry.command} ${entry.args.join(" ")}\n` +
+        `  preserved: ${preservedKeys.length ? preservedKeys.join(", ") : "(none)"}\n` +
+        `  (no files written)\n`,
+    );
+    return;
+  }
+
+  // Write: ensure dir, back up an existing file, then write merged config.
+  mkdirSync(join(configPath, ".."), { recursive: true });
+  if (existsSync(configPath)) {
+    copyFileSync(configPath, `${configPath}.vortex-backup`);
+  }
+  writeFileSync(configPath, serialized, "utf8");
+
+  process.stderr.write(
+    `[vortex-mcp-recall] installed: ${action} server "${key}"\n` +
+      `  config:    ${configPath}\n` +
+      `  command:   ${entry.command} ${entry.args.join(" ")}\n` +
+      `  preserved: ${preservedKeys.length ? preservedKeys.join(", ") : "(none)"}\n` +
+      `  Restart Claude Desktop to load the recall tool.\n`,
+  );
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "install") {
+    install(argv.slice(1), process.env);
+    return;
+  }
+  await serve(argv, process.env);
+}
+
+main().catch((err) => {
+  process.stderr.write(`[vortex-mcp-recall] fatal: ${err?.message ?? err}\n`);
+  process.exit(1);
+});

package/scripts/rebuild-memory-sqlite.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+// One-shot CLI — rebuild the memory sqlite index from data/_memory/*.md.
+// Usage from a vortex instance root:
+//   npx rebuild-memory-sqlite                       # default paths
+//   npx rebuild-memory-sqlite --memory-dir <p> --db <p>
+//
+// Operator decision 4 (2026-05-29): rebuild is a one-shot CLI, not a
+// filesystem watcher. Watcher waits until Phase 11c lands and we know
+// whether reactive update is needed for the recall pipeline.
+
+import { resolve } from "node:path";
+import { MemorySqliteStore, rebuildFromMemoryDir } from "../dist/sqlite/index.js";
+
+const args = process.argv.slice(2);
+let memoryDir = resolve(process.cwd(), "data/_memory");
+let dbPath = resolve(process.cwd(), "data/_indexes/memory.sqlite");
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--memory-dir" && i + 1 < args.length) {
+    memoryDir = resolve(args[++i]);
+  } else if (args[i] === "--db" && i + 1 < args.length) {
+    dbPath = resolve(args[++i]);
+  } else if (args[i] === "--help" || args[i] === "-h") {
+    console.log("Usage: rebuild-memory-sqlite [--memory-dir <p>] [--db <p>]");
+    process.exit(0);
+  }
+}
+
+console.log(`[rebuild] memory dir: ${memoryDir}`);
+console.log(`[rebuild] sqlite db:  ${dbPath}`);
+
+const store = new MemorySqliteStore(dbPath);
+try {
+  const result = await rebuildFromMemoryDir(store, memoryDir);
+  console.log(
+    `[rebuild] scanned=${result.scanned} upserted=${result.upserted} skipped=${result.skipped}`,
+  );
+} finally {
+  store.close();
+}

package/scripts/rebuild-memory-vector.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// One-shot CLI — rebuild the memory vector index (and optionally session vectors).
+// Usage from a vortex instance root:
+//   npx rebuild-memory-vector                    # memory vectors only
+//   npx rebuild-memory-vector --sessions         # memory + session-archive vectors
+//   npx rebuild-memory-vector --sessions-only    # session vectors only
+//   npx rebuild-memory-vector --data-dir <p> --db <p>
+//
+// Phase 11c + follow-up (2026-05-29): memory and session vectors share the
+// same memory.sqlite (operator decision 3). Session vectors are topic chunks
+// found by embedding-similarity segmentation. The default local embedder
+// downloads its model (~470 MB multilingual) on first run and caches it.
+// Run `rebuild-memory-sqlite` first if the sqlite store is empty/stale.
+
+import { resolve, join } from "node:path";
+import { MemorySqliteStore } from "../dist/sqlite/index.js";
+import { MemoryVectorStore, createLocalEmbedder } from "../dist/vector/index.js";
+import { SessionArchiveStore } from "../dist/sessionArchive/index.js";
+
+const args = process.argv.slice(2);
+let dataDir = resolve(process.cwd(), "data");
+let dbPath = null;
+let doSessions = false;
+let sessionsOnly = false;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--data-dir" && i + 1 < args.length) dataDir = resolve(args[++i]);
+  else if (args[i] === "--db" && i + 1 < args.length) dbPath = resolve(args[++i]);
+  else if (args[i] === "--sessions") doSessions = true;
+  else if (args[i] === "--sessions-only") { doSessions = true; sessionsOnly = true; }
+  else if (args[i] === "--help" || args[i] === "-h") {
+    console.log("Usage: rebuild-memory-vector [--sessions | --sessions-only] [--data-dir <p>] [--db <p>]");
+    process.exit(0);
+  }
+}
+if (!dbPath) dbPath = join(dataDir, "_indexes", "memory.sqlite");
+
+console.log(`[rebuild-vector] data dir:  ${dataDir}`);
+console.log(`[rebuild-vector] sqlite db: ${dbPath}`);
+console.log(`[rebuild-vector] embedder:  local (downloads model on first run)`);
+
+const embed = createLocalEmbedder();
+const vector = new MemoryVectorStore({ db: dbPath });
+try {
+  if (!sessionsOnly) {
+    const sqlite = new MemorySqliteStore(dbPath);
+    try {
+      const r = await vector.rebuild(sqlite, embed);
+      console.log(`[rebuild-vector] memory: indexed=${r.indexed} skipped=${r.skipped} pruned=${r.pruned}`);
+    } finally {
+      sqlite.close();
+    }
+  }
+  if (doSessions) {
+    const sessions = new SessionArchiveStore(dataDir);
+    try {
+      const r = await vector.rebuildSessions(sessions, embed);
+      console.log(`[rebuild-vector] sessions: sessions=${r.sessions} chunks=${r.chunks} pruned=${r.prunedSessions}`);
+    } finally {
+      sessions.close();
+    }
+  }
+} finally {
+  vector.close();
+}