@neuralsea/workspace-indexer 0.3.6 → 0.4.1

package/dist/{chunk-FUUQXFJQ.js → chunk-TQTWTPPG.js}

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/progress.ts
 function toHandler(progress) {
   if (!progress) return null;
@@ -2548,63 +2555,6 @@ var RepoIndexer = class {
   }
 };
 
-// src/profiles.ts
-var DEFAULT_PROFILES = {
-  search: {
-    name: "search",
-    k: 10,
-    weights: { vector: 0.65, lexical: 0.35, recency: 0 },
-    expand: { adjacentChunks: 0, followImports: 0, includeFileSynopsis: false },
-    candidates: { vectorK: 25, lexicalK: 25, maxMergedCandidates: 60 }
-  },
-  refactor: {
-    name: "refactor",
-    k: 15,
-    weights: { vector: 0.55, lexical: 0.35, recency: 0.1 },
-    expand: { adjacentChunks: 1, followImports: 2, includeFileSynopsis: true },
-    candidates: { vectorK: 60, lexicalK: 40, maxMergedCandidates: 140 }
-  },
-  review: {
-    name: "review",
-    k: 20,
-    weights: { vector: 0.45, lexical: 0.35, recency: 0.2 },
-    expand: { adjacentChunks: 1, followImports: 1, includeFileSynopsis: true },
-    candidates: { vectorK: 80, lexicalK: 60, maxMergedCandidates: 180 }
-  },
-  architecture: {
-    name: "architecture",
-    k: 20,
-    weights: { vector: 0.7, lexical: 0.2, recency: 0.1 },
-    expand: { adjacentChunks: 0, followImports: 3, includeFileSynopsis: true },
-    candidates: { vectorK: 120, lexicalK: 40, maxMergedCandidates: 220 }
-  },
-  rca: {
-    name: "rca",
-    k: 25,
-    weights: { vector: 0.5, lexical: 0.25, recency: 0.25 },
-    expand: { adjacentChunks: 2, followImports: 1, includeFileSynopsis: true },
-    candidates: { vectorK: 140, lexicalK: 80, maxMergedCandidates: 260 }
-  },
-  custom: {
-    name: "custom",
-    k: 10,
-    weights: { vector: 0.65, lexical: 0.35, recency: 0 },
-    expand: { adjacentChunks: 0, followImports: 0, includeFileSynopsis: false },
-    candidates: { vectorK: 25, lexicalK: 25, maxMergedCandidates: 60 }
-  }
-};
-function deepMergeProfile(base, patch) {
-  if (!patch) return base;
-  const merged = {
-    ...base,
-    ...patch,
-    weights: { ...base.weights, ...patch.weights ?? {} },
-    expand: { ...base.expand, ...patch.expand ?? {} },
-    candidates: { ...base.candidates, ...patch.candidates ?? {} }
-  };
-  return merged;
-}
-
 // src/indexer/repoDiscovery.ts
 import fs10 from "fs";
 import path13 from "path";
@@ -2767,9 +2717,181 @@ function mergeIndexerConfig(target, patch) {
   }
 }
 
-// src/store/workspaceStore.ts
+// src/store/workspace/db.ts
+import Database3 from "better-sqlite3";
+import fs11 from "fs";
+import path14 from "path";
+function detectFts5Support(db) {
+  try {
+    const rows = db.prepare(`PRAGMA compile_options`).all();
+    if (rows.some((r) => String(r.compile_options ?? "").includes("ENABLE_FTS5"))) return true;
+  } catch {
+  }
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS __fts5_probe USING fts5(x);
+      DROP TABLE __fts5_probe;
+    `);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var BetterSqlite3Adapter = class {
+  db;
+  capabilities;
+  constructor(dbPath) {
+    this.db = new Database3(dbPath);
+    this.capabilities = { supportsFts5: detectFts5Support(this.db) };
+  }
+  pragma(sql) {
+    this.db.pragma(sql);
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+  transaction(fn) {
+    return this.db.transaction(fn);
+  }
+  close() {
+    this.db.close();
+  }
+};
+var betterSqlite3Adapter = {
+  open(dbPath) {
+    fs11.mkdirSync(path14.dirname(dbPath), { recursive: true });
+    const db = new BetterSqlite3Adapter(dbPath);
+    db.pragma("journal_mode = WAL");
+    return db;
+  }
+};
+
+// src/store/workspace/sqlJsAdapter.ts
 import fs12 from "fs";
+import { createRequire as createRequire2 } from "module";
 import path15 from "path";
+function detectFts5Support2(db) {
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS __fts5_probe USING fts5(x);
+      DROP TABLE __fts5_probe;
+    `);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var SqlJsStatement = class {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  run(...args) {
+    this.stmt.run(args);
+    return void 0;
+  }
+  get(...args) {
+    this.stmt.bind(args);
+    const hasRow = this.stmt.step();
+    if (!hasRow) {
+      this.stmt.reset();
+      return void 0;
+    }
+    const row = this.stmt.getAsObject();
+    this.stmt.reset();
+    return row;
+  }
+  all(...args) {
+    this.stmt.bind(args);
+    const rows = [];
+    while (this.stmt.step()) rows.push(this.stmt.getAsObject());
+    this.stmt.reset();
+    return rows;
+  }
+};
+var SqlJsDbAdapter = class {
+  constructor(db, dbPath) {
+    this.db = db;
+    this.dbPath = dbPath;
+    this.capabilities = { supportsFts5: detectFts5Support2(db) };
+  }
+  capabilities;
+  pragma(sql) {
+    this.exec(`PRAGMA ${sql}`);
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  prepare(sql) {
+    return new SqlJsStatement(this.db.prepare(sql));
+  }
+  transaction(fn) {
+    return () => {
+      this.db.exec("BEGIN");
+      try {
+        const out = fn();
+        this.db.exec("COMMIT");
+        return out;
+      } catch (e) {
+        try {
+          this.db.exec("ROLLBACK");
+        } catch {
+        }
+        throw e;
+      }
+    };
+  }
+  close() {
+    if (this.dbPath && this.dbPath !== ":memory:") {
+      fs12.mkdirSync(path15.dirname(this.dbPath), { recursive: true });
+      const bytes = this.db.export();
+      fs12.writeFileSync(this.dbPath, Buffer.from(bytes));
+    }
+    this.db.close();
+  }
+};
+function defaultLocateFile(file) {
+  const spec = `sql.js/dist/${file}`;
+  try {
+    if (typeof __require === "function" && typeof __require.resolve === "function") {
+      return __require.resolve(spec);
+    }
+  } catch {
+  }
+  try {
+    const req = createRequire2(import.meta.url);
+    return req.resolve(spec);
+  } catch {
+    return file;
+  }
+}
+async function sqlJsAdapter(opts = {}) {
+  let init;
+  try {
+    const mod = await import("sql.js");
+    init = mod?.default ?? mod;
+  } catch (e) {
+    throw new Error(`sqlJsAdapter requires optional dependency 'sql.js' (install it to use this adapter): ${String(e?.message ?? e)}`);
+  }
+  const SQL = await init({
+    locateFile: opts.locateFile ?? defaultLocateFile,
+    wasmBinary: opts.wasmBinary
+  });
+  return {
+    open(dbPath) {
+      const abs = dbPath === ":memory:" ? ":memory:" : path15.resolve(dbPath);
+      const bytes = abs !== ":memory:" && fs12.existsSync(abs) ? new Uint8Array(fs12.readFileSync(abs)) : void 0;
+      const db = bytes ? new SQL.Database(bytes) : new SQL.Database();
+      return new SqlJsDbAdapter(db, abs);
+    }
+  };
+}
+
+// src/store/workspaceStore.ts
+import fs14 from "fs";
+import path17 from "path";
 
 // src/store/workspace/unitOfWork.ts
 var UnitOfWork = class {
@@ -2989,32 +3111,11 @@ var RepoLinksRepository = class {
 };
 
 // src/store/workspace/factory.ts
-import fs11 from "fs";
-import path14 from "path";
+import fs13 from "fs";
+import path16 from "path";
 
-// src/store/workspace/db.ts
-import Database3 from "better-sqlite3";
-var BetterSqlite3Adapter = class {
-  db;
-  constructor(dbPath) {
-    this.db = new Database3(dbPath);
-  }
-  pragma(sql) {
-    this.db.pragma(sql);
-  }
-  exec(sql) {
-    this.db.exec(sql);
-  }
-  prepare(sql) {
-    return this.db.prepare(sql);
-  }
-  transaction(fn) {
-    return this.db.transaction(fn);
-  }
-  close() {
-    this.db.close();
-  }
-};
+// src/store/workspace/fts5.sql
+var fts5_default = "CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(\n  id UNINDEXED,\n  repo_id UNINDEXED,\n  repo_root UNINDEXED,\n  path,\n  language,\n  kind,\n  text,\n  tokenize='unicode61'\n);\n\n";
 
 // src/store/workspace/fts.ts
 var NoopFtsStrategy = class {
@@ -3038,18 +3139,7 @@ var Fts5Strategy = class {
   enabled = true;
   ins = null;
   init(db) {
-    db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
-        id UNINDEXED,
-        repo_id UNINDEXED,
-        repo_root UNINDEXED,
-        path,
-        language,
-        kind,
-        text,
-        tokenize='unicode61'
-      );
-    `);
+    db.exec(fts5_default);
   }
   clearRepo(repoId) {
     this.db.prepare(`DELETE FROM chunks_fts WHERE repo_id = ?`).run(repoId);
@@ -3133,109 +3223,26 @@ var WorkspaceMigrator = class {
   }
 };
 
+// src/store/workspace/baseSchema.sql
+var baseSchema_default = "CREATE TABLE IF NOT EXISTS meta (\n  k TEXT PRIMARY KEY,\n  v TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS repos (\n  repo_id TEXT PRIMARY KEY,\n  repo_root TEXT NOT NULL,\n  head_commit TEXT NOT NULL,\n  head_branch TEXT NOT NULL,\n  updated_at INTEGER NOT NULL\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_repos_root ON repos(repo_root);\n\nCREATE TABLE IF NOT EXISTS files (\n  repo_id TEXT NOT NULL,\n  path TEXT NOT NULL,\n  hash TEXT NOT NULL,\n  mtime INTEGER NOT NULL,\n  language TEXT NOT NULL,\n  size INTEGER NOT NULL,\n  PRIMARY KEY(repo_id, path)\n);\n\nCREATE INDEX IF NOT EXISTS idx_files_repo ON files(repo_id);\n\nCREATE TABLE IF NOT EXISTS chunks (\n  id TEXT PRIMARY KEY,\n  repo_id TEXT NOT NULL,\n  repo_root TEXT NOT NULL,\n  path TEXT NOT NULL,\n  language TEXT NOT NULL,\n  kind TEXT NOT NULL DEFAULT 'chunk',\n  start_line INTEGER NOT NULL,\n  end_line INTEGER NOT NULL,\n  content_hash TEXT NOT NULL,\n  tokens INTEGER NOT NULL,\n  file_mtime INTEGER NOT NULL,\n  text TEXT NOT NULL,\n  embedding BLOB NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_chunks_repo_path ON chunks(repo_id, path);\nCREATE INDEX IF NOT EXISTS idx_chunks_kind_repo_path ON chunks(kind, repo_id, path);\n\nCREATE TABLE IF NOT EXISTS edges (\n  repo_id TEXT NOT NULL,\n  from_path TEXT NOT NULL,\n  kind TEXT NOT NULL,\n  value TEXT NOT NULL,\n  PRIMARY KEY(repo_id, from_path, kind, value)\n);\n\nCREATE INDEX IF NOT EXISTS idx_edges_repo_from ON edges(repo_id, from_path);\n\nCREATE TABLE IF NOT EXISTS symbols (\n  id TEXT PRIMARY KEY,\n  repo_id TEXT NOT NULL,\n  repo_root TEXT NOT NULL,\n  path TEXT NOT NULL,\n  language TEXT NOT NULL,\n  name TEXT NOT NULL,\n  kind TEXT NOT NULL,\n  start_line INTEGER NOT NULL,\n  start_char INTEGER NOT NULL,\n  end_line INTEGER NOT NULL,\n  end_char INTEGER NOT NULL,\n  container_name TEXT NOT NULL DEFAULT '',\n  detail TEXT NOT NULL DEFAULT ''\n);\n\nCREATE INDEX IF NOT EXISTS idx_symbols_repo_path ON symbols(repo_id, path);\nCREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);\n\nCREATE TABLE IF NOT EXISTS symbol_edges (\n  repo_id TEXT NOT NULL,\n  from_id TEXT NOT NULL,\n  to_id TEXT NOT NULL,\n  kind TEXT NOT NULL,\n  from_path TEXT NOT NULL,\n  to_path TEXT NOT NULL,\n  PRIMARY KEY(repo_id, from_id, to_id, kind)\n);\n\nCREATE INDEX IF NOT EXISTS idx_symbol_edges_from ON symbol_edges(repo_id, from_id);\nCREATE INDEX IF NOT EXISTS idx_symbol_edges_paths ON symbol_edges(repo_id, from_path);\n\n";
+
 // src/store/workspace/factory.ts
-function createWorkspaceDb(dbPath) {
-  fs11.mkdirSync(path14.dirname(dbPath), { recursive: true });
-  const db = new BetterSqlite3Adapter(dbPath);
-  db.pragma("journal_mode = WAL");
-  return db;
+function createWorkspaceDb(dbPath, opts = {}) {
+  fs13.mkdirSync(path16.dirname(dbPath), { recursive: true });
+  return (opts.db ?? betterSqlite3Adapter).open(dbPath);
 }
 function createWorkspaceBaseSchema(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS meta (
-      k TEXT PRIMARY KEY,
-      v TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS repos (
-      repo_id TEXT PRIMARY KEY,
-      repo_root TEXT NOT NULL,
-      head_commit TEXT NOT NULL,
-      head_branch TEXT NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_repos_root ON repos(repo_root);
-
-    CREATE TABLE IF NOT EXISTS files (
-      repo_id TEXT NOT NULL,
-      path TEXT NOT NULL,
-      hash TEXT NOT NULL,
-      mtime INTEGER NOT NULL,
-      language TEXT NOT NULL,
-      size INTEGER NOT NULL,
-      PRIMARY KEY(repo_id, path)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_files_repo ON files(repo_id);
-
-    CREATE TABLE IF NOT EXISTS chunks (
-      id TEXT PRIMARY KEY,
-      repo_id TEXT NOT NULL,
-      repo_root TEXT NOT NULL,
-      path TEXT NOT NULL,
-      language TEXT NOT NULL,
-      kind TEXT NOT NULL DEFAULT 'chunk',
-      start_line INTEGER NOT NULL,
-      end_line INTEGER NOT NULL,
-      content_hash TEXT NOT NULL,
-      tokens INTEGER NOT NULL,
-      file_mtime INTEGER NOT NULL,
-      text TEXT NOT NULL,
-      embedding BLOB NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_chunks_repo_path ON chunks(repo_id, path);
-    CREATE INDEX IF NOT EXISTS idx_chunks_kind_repo_path ON chunks(kind, repo_id, path);
-
-    CREATE TABLE IF NOT EXISTS edges (
-      repo_id TEXT NOT NULL,
-      from_path TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      value TEXT NOT NULL,
-      PRIMARY KEY(repo_id, from_path, kind, value)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_edges_repo_from ON edges(repo_id, from_path);
-
-    CREATE TABLE IF NOT EXISTS symbols (
-      id TEXT PRIMARY KEY,
-      repo_id TEXT NOT NULL,
-      repo_root TEXT NOT NULL,
-      path TEXT NOT NULL,
-      language TEXT NOT NULL,
-      name TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      start_line INTEGER NOT NULL,
-      start_char INTEGER NOT NULL,
-      end_line INTEGER NOT NULL,
-      end_char INTEGER NOT NULL,
-      container_name TEXT NOT NULL DEFAULT '',
-      detail TEXT NOT NULL DEFAULT ''
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_symbols_repo_path ON symbols(repo_id, path);
-    CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
-
-    CREATE TABLE IF NOT EXISTS symbol_edges (
-      repo_id TEXT NOT NULL,
-      from_id TEXT NOT NULL,
-      to_id TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      from_path TEXT NOT NULL,
-      to_path TEXT NOT NULL,
-      PRIMARY KEY(repo_id, from_id, to_id, kind)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_symbol_edges_from ON symbol_edges(repo_id, from_id);
-    CREATE INDEX IF NOT EXISTS idx_symbol_edges_paths ON symbol_edges(repo_id, from_path);
-  `);
+  db.exec(baseSchema_default);
 }
 function createWorkspaceFts(db, meta, opts = {}) {
   if (opts.fts === "off") {
     meta.set("fts", "0");
     return new NoopFtsStrategy();
   }
+  if (!db.capabilities.supportsFts5) {
+    meta.set("fts", "0");
+    return new NoopFtsStrategy();
+  }
   try {
     const fts = new Fts5Strategy(db);
     fts.init(db);
@@ -3252,16 +3259,31 @@ function migrateWorkspaceDb(db, meta) {
 }
 
 // src/store/workspaceStore.ts
+function createWorkspaceStore(dbPath, opts = {}) {
+  return new WorkspaceStore(dbPath, opts);
+}
+async function defaultWorkspaceDbFactory() {
+  try {
+    return await sqlJsAdapter();
+  } catch {
+    return betterSqlite3Adapter;
+  }
+}
+async function createWorkspaceStoreAsync(dbPath, opts = {}) {
+  const dbFactory = opts.db ? await Promise.resolve(opts.db) : await defaultWorkspaceDbFactory();
+  return new WorkspaceStore(dbPath, { ...opts, db: dbFactory });
+}
 var WorkspaceStore = class {
   constructor(dbPath, opts = {}) {
     this.dbPath = dbPath;
     this.opts = opts;
-    this.db = createWorkspaceDb(dbPath);
+    this.db = createWorkspaceDb(dbPath, { db: opts.db });
     this.uow = new UnitOfWork(this.db);
     createWorkspaceBaseSchema(this.db);
     this.meta = new MetaRepository(this.db);
     migrateWorkspaceDb(this.db, this.meta);
     const fts = createWorkspaceFts(this.db, this.meta, opts);
+    this.ftsEnabledInternal = fts.enabled;
     this.repoHeads = new RepoHeadsRepository(this.db);
     this.files = new FilesRepository(this.db);
     this.edges = new EdgesRepository(this.db);
@@ -3271,6 +3293,7 @@ var WorkspaceStore = class {
   }
   db;
   uow;
+  ftsEnabledInternal;
   meta;
   repoHeads;
   files;
@@ -3279,6 +3302,9 @@ var WorkspaceStore = class {
   symbols;
   chunks;
   opts;
+  get ftsEnabled() {
+    return this.ftsEnabledInternal;
+  }
   setMeta(k, v) {
     this.meta.set(k, v);
   }
@@ -3362,9 +3388,9 @@ var WorkspaceStore = class {
    * The chunk boundaries are approximate; the stored row includes start/end line.
    */
   getChunkTextFallback(row) {
-    const abs = path15.join(row.repo_root, row.path.split("/").join(path15.sep));
+    const abs = path17.join(row.repo_root, row.path.split("/").join(path17.sep));
     try {
-      const raw = fs12.readFileSync(abs, "utf8");
+      const raw = fs14.readFileSync(abs, "utf8");
       const lines = raw.split(/\r?\n/);
       const start = Math.max(1, row.start_line);
       const end = Math.max(start, row.end_line);
@@ -3379,7 +3405,7 @@ var WorkspaceStore = class {
 };
 
 // src/graph/neo4j.ts
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 async function runSession(driver, database, fn) {
   const session = driver.session(database ? { database } : void 0);
   try {
@@ -3463,13 +3489,13 @@ var Neo4jGraphStore = class {
   async runMigrations() {
     const startedAt = Date.now();
     this.opStart("migrations");
-    const { Repo, File, Symbol, External } = this.labels();
+    const { Repo, File, Symbol: Symbol2, External } = this.labels();
     let v = await this.getSchemaVersion();
     if (v < 1) {
       await runSession(this.driver, this.cfg.database, async (s) => {
         const stmts = [
           `CREATE CONSTRAINT ${Repo}_repo_id IF NOT EXISTS FOR (r:${Repo}) REQUIRE r.repo_id IS UNIQUE`,
-          `CREATE CONSTRAINT ${Symbol}_id IF NOT EXISTS FOR (s:${Symbol}) REQUIRE s.id IS UNIQUE`,
+          `CREATE CONSTRAINT ${Symbol2}_id IF NOT EXISTS FOR (s:${Symbol2}) REQUIRE s.id IS UNIQUE`,
           `CREATE CONSTRAINT ${External}_key IF NOT EXISTS FOR (e:${External}) REQUIRE e.key IS UNIQUE`,
           `CREATE CONSTRAINT ${File}_key IF NOT EXISTS FOR (f:${File}) REQUIRE f.key IS UNIQUE`
         ];
@@ -3486,7 +3512,7 @@ var Neo4jGraphStore = class {
     if (v < 2) {
       await runSession(this.driver, this.cfg.database, async (s) => {
         const stmts = [
-          `CREATE INDEX ${Symbol}_repo_path IF NOT EXISTS FOR (s:${Symbol}) ON (s.repo_id, s.path)`,
+          `CREATE INDEX ${Symbol2}_repo_path IF NOT EXISTS FOR (s:${Symbol2}) ON (s.repo_id, s.path)`,
           `CREATE INDEX ${File}_repo IF NOT EXISTS FOR (f:${File}) ON (f.repo_id)`,
           `CREATE INDEX ${External}_repo IF NOT EXISTS FOR (e:${External}) ON (e.repo_id)`
         ];
@@ -3508,7 +3534,7 @@ var Neo4jGraphStore = class {
   async setRepoHead(args) {
     const startedAt = Date.now();
     this.opStart("setRepoHead", { repoId: args.repoId });
-    const { Repo, File, Symbol, External } = this.labels();
+    const { Repo, File, Symbol: Symbol2, External } = this.labels();
     const { repoId, repoRoot, commit, branch } = args;
     await runSession(this.driver, this.cfg.database, async (s) => {
       const prev = await s.run(
@@ -3521,7 +3547,7 @@ var Neo4jGraphStore = class {
       const prevCommit = prev?.records?.[0]?.get?.("commit");
       const prevCommitStr = typeof prevCommit === "string" ? prevCommit : `${prevCommit ?? ""}`;
       if (prevCommitStr && prevCommitStr !== commit) {
-        await s.run(`MATCH (s:${Symbol} {repo_id:$repoId}) DETACH DELETE s`, { repoId });
+        await s.run(`MATCH (s:${Symbol2} {repo_id:$repoId}) DETACH DELETE s`, { repoId });
         await s.run(
           `MATCH (f:${File} {repo_id:$repoId})
            DETACH DELETE f`,
@@ -3543,9 +3569,9 @@ var Neo4jGraphStore = class {
   async deleteFile(args) {
     const startedAt = Date.now();
     this.opStart("deleteFile", { repoId: args.repoId, path: args.path });
-    const { File, Symbol } = this.labels();
+    const { File, Symbol: Symbol2 } = this.labels();
     await runSession(this.driver, this.cfg.database, async (s) => {
-      await s.run(`MATCH (s:${Symbol} {repo_id:$repoId, path:$path}) DETACH DELETE s`, args);
+      await s.run(`MATCH (s:${Symbol2} {repo_id:$repoId, path:$path}) DETACH DELETE s`, args);
       await s.run(`MATCH (f:${File} {repo_id:$repoId, path:$path}) DETACH DELETE f`, args);
     });
     this.opDone("deleteFile", startedAt, { repoId: args.repoId, path: args.path });
@@ -3553,14 +3579,14 @@ var Neo4jGraphStore = class {
   async replaceOutgoingSymbolEdgesFromFile(args) {
     const startedAt = Date.now();
     this.opStart("replaceOutgoingSymbolEdgesFromFile", { repoId: args.repoId, path: args.fromPath });
-    const { Symbol } = this.labels();
+    const { Symbol: Symbol2 } = this.labels();
     const kinds = args.edges.length > 0 ? Array.from(new Set(args.edges.map((e) => e.kind))) : ["definition", "reference", "implementation", "typeDefinition"];
     const keep = args.edges.map((e) => `${e.fromId}|${e.kind}|${e.toId}`);
     await runSession(this.driver, this.cfg.database, async (s) => {
       await s.run(
         `UNWIND $edges AS e
-         MERGE (a:${Symbol} {id:e.fromId})
-         MERGE (b:${Symbol} {id:e.toId})
+         MERGE (a:${Symbol2} {id:e.fromId})
+         MERGE (b:${Symbol2} {id:e.toId})
          ON CREATE SET b.repo_id=$repoId, b.path=coalesce(e.toPath, '')
          SET b.repo_id = coalesce(b.repo_id, $repoId),
              b.path = CASE WHEN coalesce(b.path, '') = '' AND e.toPath IS NOT NULL THEN e.toPath ELSE b.path END
@@ -3569,7 +3595,7 @@ var Neo4jGraphStore = class {
       ).catch(() => void 0);
       if (keep.length === 0) {
         await s.run(
-          `MATCH (a:${Symbol} {repo_id:$repoId, path:$fromPath})-[r:SYMBOL_EDGE]->()
+          `MATCH (a:${Symbol2} {repo_id:$repoId, path:$fromPath})-[r:SYMBOL_EDGE]->()
            WHERE r.kind IN $kinds
            DELETE r`,
           { repoId: args.repoId, fromPath: args.fromPath, kinds }
@@ -3577,7 +3603,7 @@ var Neo4jGraphStore = class {
         return;
       }
       await s.run(
-        `MATCH (a:${Symbol} {repo_id:$repoId, path:$fromPath})-[r:SYMBOL_EDGE]->(b:${Symbol})
+        `MATCH (a:${Symbol2} {repo_id:$repoId, path:$fromPath})-[r:SYMBOL_EDGE]->(b:${Symbol2})
          WHERE r.kind IN $kinds
            AND NOT (a.id + '|' + r.kind + '|' + b.id) IN $keep
          DELETE r`,
@@ -3589,7 +3615,7 @@ var Neo4jGraphStore = class {
   async replaceFileGraph(update) {
     const startedAt = Date.now();
     this.opStart("replaceFileGraph", { repoId: update.repoId, path: update.path });
-    const { Repo, File, Symbol, External } = this.labels();
+    const { Repo, File, Symbol: Symbol2, External } = this.labels();
     const symbols = update.symbols.map((s) => ({
       id: s.id,
       name: s.name,
@@ -3649,7 +3675,7 @@ var Neo4jGraphStore = class {
         await s.run(
           `MATCH (f:${File} {repo_id:$repoId, path:$path})
            UNWIND $symbols AS s
-           MERGE (n:${Symbol} {id:s.id})
+           MERGE (n:${Symbol2} {id:s.id})
            ON CREATE SET n.repo_id=$repoId
            SET n.repo_root=$repoRoot, n.path=$path,
                n.language=s.language, n.name=s.name, n.kind=s.kind,
@@ -3660,13 +3686,13 @@ var Neo4jGraphStore = class {
         );
         const ids = symbols.map((s2) => s2.id);
         await s.run(
-          `MATCH (f:${File} {repo_id:$repoId, path:$path})-[r:CONTAINS]->(n:${Symbol})
+          `MATCH (f:${File} {repo_id:$repoId, path:$path})-[r:CONTAINS]->(n:${Symbol2})
            WHERE NOT n.id IN $ids
            DELETE r`,
           { repoId: update.repoId, path: update.path, ids }
         ).catch(() => void 0);
         await s.run(
-          `MATCH (n:${Symbol} {repo_id:$repoId, path:$path})
+          `MATCH (n:${Symbol2} {repo_id:$repoId, path:$path})
            WHERE NOT n.id IN $ids
            DETACH DELETE n`,
           { repoId: update.repoId, path: update.path, ids }
@@ -3677,21 +3703,21 @@ var Neo4jGraphStore = class {
           { repoId: update.repoId, path: update.path }
         ).catch(() => void 0);
         await s.run(
-          `MATCH (n:${Symbol} {repo_id:$repoId, path:$path}) DETACH DELETE n`,
+          `MATCH (n:${Symbol2} {repo_id:$repoId, path:$path}) DETACH DELETE n`,
           { repoId: update.repoId, path: update.path }
         ).catch(() => void 0);
       }
       if (symbolEdges.length) {
         await s.run(
           `UNWIND $edges AS e
-           MERGE (a:${Symbol} {id:e.fromId})
-           MERGE (b:${Symbol} {id:e.toId})
+           MERGE (a:${Symbol2} {id:e.fromId})
+           MERGE (b:${Symbol2} {id:e.toId})
            MERGE (a)-[:SYMBOL_EDGE {kind:e.kind}]->(b)`,
           { edges: symbolEdges }
         ).catch(() => void 0);
         if (managedSymbolEdgeKinds.length > 0) {
           await s.run(
-            `MATCH (a:${Symbol} {repo_id:$repoId, path:$path})-[r:SYMBOL_EDGE]->(b:${Symbol})
+            `MATCH (a:${Symbol2} {repo_id:$repoId, path:$path})-[r:SYMBOL_EDGE]->(b:${Symbol2})
              WHERE r.kind IN $kinds
                AND NOT (a.id + '|' + r.kind + '|' + b.id) IN $keep
              DELETE r`,
@@ -3740,14 +3766,14 @@ var Neo4jGraphStore = class {
   async neighborFiles(args) {
     const startedAt = Date.now();
     this.opStart("neighborFiles");
-    const { File, Symbol } = this.labels();
+    const { File, Symbol: Symbol2 } = this.labels();
     const limit = args.limit ?? 20;
     const kinds = args.kinds && args.kinds.length > 0 ? args.kinds : null;
     const rows = [];
     await runSession(this.driver, this.cfg.database, async (s) => {
       const res = await s.run(
         `UNWIND $seeds AS seed
-         MATCH (f:${File} {repo_id:seed.repoId, path:seed.path})-[:CONTAINS]->(a:${Symbol})-[e:SYMBOL_EDGE]->(b:${Symbol})<-[:CONTAINS]-(g:${File})
+         MATCH (f:${File} {repo_id:seed.repoId, path:seed.path})-[:CONTAINS]->(a:${Symbol2})-[e:SYMBOL_EDGE]->(b:${Symbol2})<-[:CONTAINS]-(g:${File})
          WHERE (g.repo_id <> seed.repoId OR g.path <> seed.path)
            AND ($kinds IS NULL OR e.kind IN $kinds)
          RETURN g.repo_id AS repoId, g.path AS path, count(*) AS weight
@@ -3790,14 +3816,14 @@ var Neo4jGraphStore = class {
   async extractFileSubgraph(args) {
     const startedAt = Date.now();
     this.opStart("extractFileSubgraph");
-    const { File, Symbol } = this.labels();
+    const { File, Symbol: Symbol2 } = this.labels();
     const limitEdges = args.limitEdges ?? 200;
     const nodes = /* @__PURE__ */ new Map();
     const edges = [];
     await runSession(this.driver, this.cfg.database, async (s) => {
       const res = await s.run(
         `UNWIND $seeds AS seed
-         MATCH (f:${File} {repo_id:seed.repoId, path:seed.path})-[:CONTAINS]->(a:${Symbol})-[e:SYMBOL_EDGE]->(b:${Symbol})<-[:CONTAINS]-(g:${File})
+         MATCH (f:${File} {repo_id:seed.repoId, path:seed.path})-[:CONTAINS]->(a:${Symbol2})-[e:SYMBOL_EDGE]->(b:${Symbol2})<-[:CONTAINS]-(g:${File})
          RETURN f.repo_id AS fromRepoId, f.path AS fromPath, g.repo_id AS toRepoId, g.path AS toPath, e.kind AS kind
          LIMIT $limit`,
         { seeds: args.seeds, limit: limitEdges }
@@ -3820,7 +3846,7 @@ var Neo4jGraphStore = class {
 };
 async function createNeo4jGraphStore(cfg) {
   try {
-    const require2 = createRequire2(import.meta.url);
+    const require2 = createRequire3(import.meta.url);
     const neo4j = require2("neo4j-driver");
     const driver = neo4j.driver(cfg.uri, neo4j.auth.basic(cfg.user, cfg.password));
     const store = new Neo4jGraphStore(driver, cfg);
@@ -3834,11 +3860,11 @@ ${hint}`);
 }
 
 // src/indexer/workspaceLinker.ts
-import fs13 from "fs";
-import path16 from "path";
+import fs15 from "fs";
+import path18 from "path";
 function readText(absPath) {
   try {
-    return fs13.readFileSync(absPath, "utf8");
+    return fs15.readFileSync(absPath, "utf8");
   } catch {
     return null;
   }
@@ -3868,7 +3894,7 @@ var NestedRepoLinkStrategy = class {
     for (const child of sorted) {
       for (const parent of sorted) {
         if (child.repoId === parent.repoId) continue;
-        if (child.absRoot.startsWith(parent.absRoot + path16.sep)) {
+        if (child.absRoot.startsWith(parent.absRoot + path18.sep)) {
           out.push({
             fromRepoId: child.repoId,
             toRepoId: parent.repoId,
@@ -3888,7 +3914,7 @@ var NpmDependencyLinkStrategy = class {
     const out = [];
     const depSections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
     for (const r of ctx.repos) {
-      const pkg = readJson(path16.join(r.absRoot, "package.json"));
+      const pkg = readJson(path18.join(r.absRoot, "package.json"));
       if (!pkg) continue;
       for (const sec of depSections) {
         const deps = pkg?.[sec];
@@ -3906,13 +3932,13 @@ var NpmDependencyLinkStrategy = class {
   }
 };
 function parseGoModule(absRepoRoot) {
-  const raw = readText(path16.join(absRepoRoot, "go.mod"));
+  const raw = readText(path18.join(absRepoRoot, "go.mod"));
   if (!raw) return null;
   const m = raw.match(/^\s*module\s+(.+)\s*$/m);
   return m ? String(m[1]).trim() : null;
 }
 function parseGoRequires(absRepoRoot) {
-  const raw = readText(path16.join(absRepoRoot, "go.mod"));
+  const raw = readText(path18.join(absRepoRoot, "go.mod"));
   if (!raw) return [];
   const out = [];
   for (const line of raw.split(/\r?\n/)) {
@@ -3952,13 +3978,13 @@ function walkFiles(root, opts, onFile) {
     if (depth > maxDepth) return;
     let ents = [];
     try {
-      ents = fs13.readdirSync(dir, { withFileTypes: true });
+      ents = fs15.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of ents) {
       if (seen >= maxFiles) return;
-      const abs = path16.join(dir, e.name);
+      const abs = path18.join(dir, e.name);
       if (opts.shouldVisit && !opts.shouldVisit(abs, e)) continue;
       if (e.isDirectory()) {
         if (isSkippableDir(e.name)) continue;
@@ -3982,7 +4008,7 @@ function collectVsCodeLanguagesForRepo(absRepoRoot) {
       shouldVisit: (_abs, dirent) => !(dirent.isDirectory() && isSkippableDir(dirent.name))
     },
     (absPath) => {
-      if (path16.basename(absPath) !== "package.json") return;
+      if (path18.basename(absPath) !== "package.json") return;
       const pkg = readJson(absPath);
       const langs = pkg?.contributes?.languages;
       if (!Array.isArray(langs)) return;
@@ -4011,7 +4037,7 @@ function repoUsedExtensions(absRepoRoot, exts) {
       shouldVisit: (_abs, dirent) => !(dirent.isDirectory() && isSkippableDir(dirent.name))
     },
     (absPath) => {
-      const ext = path16.extname(absPath).toLowerCase();
+      const ext = path18.extname(absPath).toLowerCase();
       if (!ext) return;
       if (exts.has(ext)) used.add(ext);
     }
@@ -4083,12 +4109,12 @@ var WorkspaceLinker = class _WorkspaceLinker {
     const repos = repoRoots.map((repoRoot) => ({
       repoRoot,
       repoId: repoIdFromRoot(repoRoot),
-      absRoot: path16.resolve(repoRoot)
+      absRoot: path18.resolve(repoRoot)
     }));
     const npmNameToRepoId = /* @__PURE__ */ new Map();
     const goModuleToRepoId = /* @__PURE__ */ new Map();
     for (const r of repos) {
-      const pkg = readJson(path16.join(r.absRoot, "package.json"));
+      const pkg = readJson(path18.join(r.absRoot, "package.json"));
       const name = typeof pkg?.name === "string" ? pkg.name : null;
       if (name) npmNameToRepoId.set(name, r.repoId);
       const mod = parseGoModule(r.absRoot);
@@ -4132,14 +4158,265 @@ async function linkWorkspaceRepos(args) {
   return { repos: ctx.repos, links };
 }
 
+// src/profiles.ts
+var DEFAULT_PROFILES = {
+  search: {
+    name: "search",
+    k: 10,
+    weights: { vector: 0.65, lexical: 0.35, recency: 0 },
+    expand: { adjacentChunks: 0, followImports: 0, includeFileSynopsis: false },
+    candidates: { vectorK: 25, lexicalK: 25, maxMergedCandidates: 60 }
+  },
+  refactor: {
+    name: "refactor",
+    k: 15,
+    weights: { vector: 0.55, lexical: 0.35, recency: 0.1 },
+    expand: { adjacentChunks: 1, followImports: 2, includeFileSynopsis: true },
+    candidates: { vectorK: 60, lexicalK: 40, maxMergedCandidates: 140 }
+  },
+  review: {
+    name: "review",
+    k: 20,
+    weights: { vector: 0.45, lexical: 0.35, recency: 0.2 },
+    expand: { adjacentChunks: 1, followImports: 1, includeFileSynopsis: true },
+    candidates: { vectorK: 80, lexicalK: 60, maxMergedCandidates: 180 }
+  },
+  architecture: {
+    name: "architecture",
+    k: 20,
+    weights: { vector: 0.7, lexical: 0.2, recency: 0.1 },
+    expand: { adjacentChunks: 0, followImports: 3, includeFileSynopsis: true },
+    candidates: { vectorK: 120, lexicalK: 40, maxMergedCandidates: 220 }
+  },
+  rca: {
+    name: "rca",
+    k: 25,
+    weights: { vector: 0.5, lexical: 0.25, recency: 0.25 },
+    expand: { adjacentChunks: 2, followImports: 1, includeFileSynopsis: true },
+    candidates: { vectorK: 140, lexicalK: 80, maxMergedCandidates: 260 }
+  },
+  custom: {
+    name: "custom",
+    k: 10,
+    weights: { vector: 0.65, lexical: 0.35, recency: 0 },
+    expand: { adjacentChunks: 0, followImports: 0, includeFileSynopsis: false },
+    candidates: { vectorK: 25, lexicalK: 25, maxMergedCandidates: 60 }
+  }
+};
+function deepMergeProfile(base, patch) {
+  if (!patch) return base;
+  const merged = {
+    ...base,
+    ...patch,
+    weights: { ...base.weights, ...patch.weights ?? {} },
+    expand: { ...base.expand, ...patch.expand ?? {} },
+    candidates: { ...base.candidates, ...patch.candidates ?? {} }
+  };
+  return merged;
+}
+
 // src/indexer/workspaceIndexer.ts
-import path17 from "path";
+import path20 from "path";
+
+// src/indexer/workspaceRetrieveCandidates.ts
+import path19 from "path";
+function resolveWorkspaceProfile(config, opts) {
+  const name = opts?.profile ?? "search";
+  const base = DEFAULT_PROFILES[name] ?? DEFAULT_PROFILES.search;
+  const configPatch = config.profiles?.[name] ?? {};
+  const merged1 = deepMergeProfile(base, configPatch);
+  const merged2 = deepMergeProfile(merged1, opts?.profileOverrides);
+  const w = merged2.weights;
+  const sum = Math.max(1e-6, w.vector + w.lexical + w.recency);
+  merged2.weights = { vector: w.vector / sum, lexical: w.lexical / sum, recency: w.recency / sum };
+  return merged2;
+}
 function halfLifeDaysForProfile(profileName) {
   if (profileName === "rca") return 7;
   if (profileName === "review") return 14;
   if (profileName === "refactor") return 21;
   return 30;
 }
+function buildWorkspaceLexByRepoRoot(args) {
+  const { workspaceStore, repos, query, lexicalK, repoFilters } = args;
+  const ftq = ftsQueryFromText(query);
+  if (!ftq) return { lexByRepoRoot: /* @__PURE__ */ new Map(), count: 0 };
+  const allowRoots = repoFilters ? new Set(repoFilters.map((r) => path19.resolve(r))) : null;
+  const repoIds = allowRoots ? repos.filter((r) => allowRoots.has(path19.resolve(r.repoRoot))).map((r) => r.repoId) : void 0;
+  const rows = workspaceStore.searchFts(ftq, lexicalK, repoIds);
+  const lexByRepoRoot = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const row = workspaceStore.getChunkById(r.id);
+    if (!row) continue;
+    const rootKey = path19.resolve(row.repo_root);
+    const arr = lexByRepoRoot.get(rootKey) ?? [];
+    arr.push({ id: r.id, score: bm25ToScore01(r.bm25) });
+    lexByRepoRoot.set(rootKey, arr);
+  }
+  return { lexByRepoRoot, count: rows.length };
+}
+async function collectWorkspaceCandidates(args) {
+  const { repos, qVec, query, vectorK, lexicalK, profile, opts, lexByRepoRoot, canUseWorkspaceLex } = args;
+  const repoFilters = opts.filters?.repoRoots;
+  const langFilter = opts.filters?.language;
+  const pathPrefix = opts.filters?.pathPrefix;
+  const candidates = [];
+  let vecCount = 0;
+  let lexCount = 0;
+  for (const repo of repos) {
+    if (repoFilters && !repoFilters.includes(repo.repoRoot)) continue;
+    let includePaths = opts.scope?.includePaths?.slice();
+    if (opts.scope?.changedOnly) {
+      try {
+        const changed = await listChangedFiles(repo.repoRoot, opts.scope.baseRef ?? "HEAD~1");
+        includePaths = includePaths ? includePaths.filter((p) => changed.includes(p)) : changed;
+      } catch {
+      }
+    }
+    const [vHits, lHits] = await Promise.all([
+      repo.vectorCandidates(qVec, vectorK, includePaths),
+      canUseWorkspaceLex ? Promise.resolve(lexByRepoRoot?.get(path19.resolve(repo.repoRoot)) ?? []) : repo.lexicalCandidates(query, lexicalK, includePaths)
+    ]);
+    vecCount += vHits.length;
+    if (!canUseWorkspaceLex) lexCount += lHits.length;
+    const m = /* @__PURE__ */ new Map();
+    for (const vh of vHits) {
+      const id = vh.id;
+      const vector01 = vectorCosineToScore01(vh.score);
+      m.set(id, { repo, id, vector01, combined: 0 });
+    }
+    for (const lh of lHits) {
+      const id = lh.id;
+      const prev = m.get(id);
+      if (prev) prev.lexical01 = lh.score;
+      else m.set(id, { repo, id, lexical01: lh.score, combined: 0 });
+    }
+    const halfLife = halfLifeDaysForProfile(profile.name);
+    for (const c of m.values()) {
+      const meta = repo.getChunkMeta(c.id);
+      if (!meta) continue;
+      if (langFilter && meta.language !== langFilter) continue;
+      if (pathPrefix && !meta.path.startsWith(pathPrefix)) continue;
+      c.recency01 = profile.weights.recency > 0 ? recencyScore(meta.fileMtimeMs, halfLife) : 0;
+      let kindFactor = 1;
+      if (meta.kind === "synopsis" && profile.name === "search") kindFactor = 0.85;
+      if (meta.kind === "synopsis" && profile.name === "architecture") kindFactor = 1.05;
+      const v = c.vector01 ?? 0;
+      const l = c.lexical01 ?? 0;
+      const r = c.recency01 ?? 0;
+      c.combined = clamp(kindFactor * (profile.weights.vector * v + profile.weights.lexical * l + profile.weights.recency * r), 0, 1);
+      candidates.push(c);
+    }
+  }
+  return { candidates, vecCount, lexCount };
+}
+function rankWorkspaceCandidates(args) {
+  const { candidates, maxMerged, k } = args;
+  candidates.sort((a, b) => b.combined - a.combined);
+  const merged = candidates.slice(0, maxMerged);
+  const top = merged.slice(0, k);
+  const hits = top.map((c) => {
+    const meta = c.repo.getChunkMeta(c.id);
+    const preview = makePreview(c.repo.getChunkText(c.id));
+    return {
+      score: c.combined,
+      scoreBreakdown: { vector: c.vector01, lexical: c.lexical01, recency: c.recency01 },
+      chunk: { ...meta, preview }
+    };
+  });
+  return { merged, hits };
+}
+
+// src/indexer/workspaceRetrieveContext.ts
+async function warmSymbolGraphForHits(repos, hits) {
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const h of hits) {
+    const s = byRepo.get(h.chunk.repoRoot) ?? /* @__PURE__ */ new Set();
+    s.add(h.chunk.path);
+    byRepo.set(h.chunk.repoRoot, s);
+  }
+  for (const [repoRoot, paths] of byRepo) {
+    const repo = repos.find((r) => r.repoRoot === repoRoot);
+    if (!repo) continue;
+    await repo.warmSymbolGraphEdges(Array.from(paths), { maxFiles: 6 });
+  }
+}
+async function fetchGraphNeighborFiles(args) {
+  const { graphStore, repos, hits, profile, workspaceRoot, emitProgress } = args;
+  if (!graphStore?.neighborFiles) return [];
+  const seeds = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const h of hits) {
+    const repo = repos.find((r) => r.repoRoot === h.chunk.repoRoot);
+    if (!repo) continue;
+    const key = `${repo.repoId}:${h.chunk.path}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    seeds.push({ repoId: repo.repoId, path: h.chunk.path });
+    if (seeds.length >= 4) break;
+  }
+  if (seeds.length === 0) return [];
+  const startedAt = Date.now();
+  emitProgress({ type: "workspace/retrieve/graph/start", workspaceRoot, seeds: seeds.length });
+  try {
+    const neighbors = await graphStore.neighborFiles({
+      seeds,
+      limit: profile.name === "architecture" ? 16 : 10,
+      kinds: ["definition", "reference", "implementation", "typeDefinition"]
+    });
+    emitProgress({ type: "workspace/retrieve/graph/done", workspaceRoot, neighbors: neighbors.length, ms: Date.now() - startedAt });
+    return neighbors;
+  } catch {
+    return [];
+  }
+}
+async function buildContextBlocks(args) {
+  const { repos, hits, graphNeighborFiles, profile } = args;
+  const contextBlocks = [];
+  const seenKey = /* @__PURE__ */ new Set();
+  const addBlock = (repoRoot, filePath, startLine, endLine, text, reason) => {
+    const key = `${repoRoot}:${filePath}:${startLine}:${endLine}:${text.length}:${reason}`;
+    if (seenKey.has(key)) return;
+    seenKey.add(key);
+    if (!text.trim()) return;
+    contextBlocks.push({ repoRoot, path: filePath, startLine, endLine, text, reason });
+  };
+  try {
+    const byRepoId = /* @__PURE__ */ new Map();
+    for (const r of repos) byRepoId.set(r.repoId, r);
+    for (const n of graphNeighborFiles.slice(0, 10)) {
+      const repo = byRepoId.get(n.repoId);
+      if (!repo) continue;
+      const chunkId = await repo.getRepresentativeChunkIdForFile(n.path, true);
+      if (!chunkId) continue;
+      const meta = repo.getChunkMeta(chunkId);
+      if (!meta) continue;
+      const text = repo.getChunkText(chunkId);
+      addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, text, `graph neighbor (${n.weight})`);
+    }
+  } catch {
+  }
+  for (const h of hits) {
+    const repo = repos.find((r) => r.repoRoot === h.chunk.repoRoot);
+    if (!repo) continue;
+    const hitText = repo.getChunkText(h.chunk.id);
+    addBlock(h.chunk.repoRoot, h.chunk.path, h.chunk.startLine, h.chunk.endLine, hitText, "primary hit");
+    const expanded = await repo.expandContext(h.chunk.id, {
+      adjacentChunks: profile.expand.adjacentChunks ?? 0,
+      followImports: profile.expand.followImports ?? 0,
+      includeFileSynopsis: profile.expand.includeFileSynopsis ?? false
+    });
+    for (const ex of expanded) {
+      const meta = repo.getChunkMeta(ex.id);
+      if (!meta) continue;
+      const text = repo.getChunkText(ex.id);
+      addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, text, ex.reason);
+    }
+  }
+  return contextBlocks;
+}
+
+// src/indexer/workspaceIndexer.ts
 var WorkspaceIndexer = class {
   constructor(workspaceRoot, embedder, config = {}) {
     this.workspaceRoot = workspaceRoot;
@@ -4147,23 +4424,30 @@ var WorkspaceIndexer = class {
     this.config = { ...config };
     if (!this.config.cacheDir) this.config.cacheDir = defaultCacheDir();
     this.progress = asProgressSink(this.config.progress);
-    const wsId = sha256Hex(path17.resolve(this.workspaceRoot)).slice(0, 16);
-    const dbPath = path17.join(this.config.cacheDir, "workspace", wsId, "workspace.sqlite");
-    this.workspaceStore = new WorkspaceStore(dbPath);
-    this.workspaceStore.setMeta("workspaceRoot", path17.resolve(this.workspaceRoot));
+    const wsId = sha256Hex(path20.resolve(this.workspaceRoot)).slice(0, 16);
+    this.workspaceDbPath = path20.join(this.config.cacheDir, "workspace", wsId, "workspace.sqlite");
   }
   repos = [];
   config;
   progress = asProgressSink();
   workspaceStore = null;
   graphStore = null;
+  workspaceDbPath;
   emitProgress(event) {
     try {
       this.progress?.emit(event);
     } catch {
     }
   }
+  async ensureWorkspaceStore() {
+    if (this.workspaceStore) return this.workspaceStore;
+    const ws = await createWorkspaceStoreAsync(this.workspaceDbPath, { db: this.config.workspace?.db });
+    ws.setMeta("workspaceRoot", path20.resolve(this.workspaceRoot));
+    this.workspaceStore = ws;
+    return ws;
+  }
   async open() {
+    await this.ensureWorkspaceStore();
     if (!this.graphStore && this.config.workspace?.graph?.provider === "neo4j") {
       try {
         const n = this.config.workspace.graph.neo4j;
@@ -4235,195 +4519,49 @@ var WorkspaceIndexer = class {
   getRepoIndexers() {
     return this.repos.slice();
   }
-  resolveProfile(opts) {
-    const name = opts?.profile ?? "search";
-    const base = DEFAULT_PROFILES[name] ?? DEFAULT_PROFILES.search;
-    const configPatch = this.config.profiles?.[name] ?? {};
-    const merged1 = deepMergeProfile(base, configPatch);
-    const merged2 = deepMergeProfile(merged1, opts?.profileOverrides);
-    const w = merged2.weights;
-    const sum = Math.max(1e-6, w.vector + w.lexical + w.recency);
-    merged2.weights = { vector: w.vector / sum, lexical: w.lexical / sum, recency: w.recency / sum };
-    return merged2;
-  }
   async retrieve(query, opts = {}) {
     if (this.repos.length === 0) await this.open();
-    const profile = this.resolveProfile(opts);
+    const profile = resolveWorkspaceProfile(this.config, opts);
     const startedAt = Date.now();
     this.emitProgress({ type: "workspace/retrieve/start", workspaceRoot: this.workspaceRoot, profile: profile.name, query });
     const qVec = (await this.embedder.embed([query]))[0];
     const vectorK = profile.candidates?.vectorK ?? Math.max(profile.k * 3, 30);
     const lexicalK = profile.candidates?.lexicalK ?? Math.max(profile.k * 3, 30);
     const maxMerged = profile.candidates?.maxMergedCandidates ?? Math.max(profile.k * 8, 120);
-    const repoFilters = opts.filters?.repoRoots;
-    const langFilter = opts.filters?.language;
-    const pathPrefix = opts.filters?.pathPrefix;
-    const candidates = [];
-    let vecCount = 0;
-    let lexCount = 0;
-    const canUseWorkspaceLex = !!this.workspaceStore && this.config.storage?.ftsMode !== "off" && !opts.scope?.includePaths && !opts.scope?.changedOnly;
-    const workspaceLexByRepoRoot = /* @__PURE__ */ new Map();
-    if (canUseWorkspaceLex && profile.weights.lexical > 0) {
-      const ftq = ftsQueryFromText(query);
-      const allowRoots = repoFilters ? new Set(repoFilters.map((r) => path17.resolve(r))) : null;
-      const repoIds = allowRoots ? this.repos.filter((r) => allowRoots.has(path17.resolve(r.repoRoot))).map((r) => r.repoId) : void 0;
-      if (ftq) {
-        const rows = this.workspaceStore.searchFts(ftq, lexicalK, repoIds);
-        lexCount += rows.length;
-        for (const r of rows) {
-          const row = this.workspaceStore.getChunkById(r.id);
-          if (!row) continue;
-          const rootKey = path17.resolve(row.repo_root);
-          const arr = workspaceLexByRepoRoot.get(rootKey) ?? [];
-          arr.push({ id: r.id, score: bm25ToScore01(r.bm25) });
-          workspaceLexByRepoRoot.set(rootKey, arr);
-        }
-      }
-    }
-    for (const repo of this.repos) {
-      if (repoFilters && !repoFilters.includes(repo.repoRoot)) continue;
-      let includePaths = opts.scope?.includePaths?.slice();
-      if (opts.scope?.changedOnly) {
-        try {
-          const changed = await listChangedFiles(repo.repoRoot, opts.scope.baseRef ?? "HEAD~1");
-          includePaths = includePaths ? includePaths.filter((p) => changed.includes(p)) : changed;
-        } catch {
-        }
-      }
-      const [vHits, lHits] = await Promise.all([
-        repo.vectorCandidates(qVec, vectorK, includePaths),
-        canUseWorkspaceLex ? Promise.resolve(workspaceLexByRepoRoot.get(path17.resolve(repo.repoRoot)) ?? []) : repo.lexicalCandidates(query, lexicalK, includePaths)
-      ]);
-      vecCount += vHits.length;
-      if (!canUseWorkspaceLex) lexCount += lHits.length;
-      const m = /* @__PURE__ */ new Map();
-      for (const vh of vHits) {
-        const id = vh.id;
-        const vector01 = vectorCosineToScore01(vh.score);
-        m.set(id, { repo, id, vector01, combined: 0 });
-      }
-      for (const lh of lHits) {
-        const id = lh.id;
-        const prev = m.get(id);
-        if (prev) prev.lexical01 = lh.score;
-        else m.set(id, { repo, id, lexical01: lh.score, combined: 0 });
-      }
-      const halfLife = halfLifeDaysForProfile(profile.name);
-      for (const c of m.values()) {
-        const meta = repo.getChunkMeta(c.id);
-        if (!meta) continue;
-        if (langFilter && meta.language !== langFilter) continue;
-        if (pathPrefix && !meta.path.startsWith(pathPrefix)) continue;
-        c.recency01 = profile.weights.recency > 0 ? recencyScore(meta.fileMtimeMs, halfLife) : 0;
-        let kindFactor = 1;
-        if (meta.kind === "synopsis" && profile.name === "search") kindFactor = 0.85;
-        if (meta.kind === "synopsis" && profile.name === "architecture") kindFactor = 1.05;
-        const v = c.vector01 ?? 0;
-        const l = c.lexical01 ?? 0;
-        const r = c.recency01 ?? 0;
-        c.combined = clamp(
-          kindFactor * (profile.weights.vector * v + profile.weights.lexical * l + profile.weights.recency * r),
-          0,
-          1
-        );
-        candidates.push(c);
-      }
-    }
-    candidates.sort((a, b) => b.combined - a.combined);
-    const merged = candidates.slice(0, maxMerged);
-    const top = merged.slice(0, profile.k);
-    const hits = top.map((c) => {
-      const meta = c.repo.getChunkMeta(c.id);
-      const preview = makePreview(c.repo.getChunkText(c.id));
-      return {
-        score: c.combined,
-        scoreBreakdown: { vector: c.vector01, lexical: c.lexical01, recency: c.recency01 },
-        chunk: { ...meta, preview }
-      };
+    const canUseWorkspaceLex = !!this.workspaceStore && this.workspaceStore.ftsEnabled && this.config.storage?.ftsMode !== "off" && !opts.scope?.includePaths && !opts.scope?.changedOnly;
+    const { lexByRepoRoot, count: workspaceLexCount } = canUseWorkspaceLex && profile.weights.lexical > 0 && this.workspaceStore ? buildWorkspaceLexByRepoRoot({
+      workspaceStore: this.workspaceStore,
+      repos: this.repos,
+      query,
+      lexicalK,
+      repoFilters: opts.filters?.repoRoots
+    }) : { lexByRepoRoot: void 0, count: 0 };
+    const { candidates, vecCount, lexCount } = await collectWorkspaceCandidates({
+      repos: this.repos,
+      qVec,
+      query,
+      vectorK,
+      lexicalK,
+      profile,
+      opts,
+      lexByRepoRoot,
+      canUseWorkspaceLex
     });
+    const { merged, hits } = rankWorkspaceCandidates({ candidates, maxMerged, k: profile.k });
+    const totalLexCount = (canUseWorkspaceLex ? workspaceLexCount : 0) + lexCount;
     try {
-      const byRepo = /* @__PURE__ */ new Map();
-      for (const h of hits) {
-        const s = byRepo.get(h.chunk.repoRoot) ?? /* @__PURE__ */ new Set();
-        s.add(h.chunk.path);
-        byRepo.set(h.chunk.repoRoot, s);
-      }
-      for (const [repoRoot, paths] of byRepo) {
-        const repo = this.repos.find((r) => r.repoRoot === repoRoot);
-        if (!repo) continue;
-        await repo.warmSymbolGraphEdges(Array.from(paths), { maxFiles: 6 });
-      }
-    } catch {
-    }
-    let graphNeighborFiles = [];
-    try {
-      if (this.graphStore?.neighborFiles) {
-        const seeds = [];
-        const seen = /* @__PURE__ */ new Set();
-        for (const h of hits) {
-          const repo = this.repos.find((r) => r.repoRoot === h.chunk.repoRoot);
-          if (!repo) continue;
-          const key = `${repo.repoId}:${h.chunk.path}`;
-          if (seen.has(key)) continue;
-          seen.add(key);
-          seeds.push({ repoId: repo.repoId, path: h.chunk.path });
-          if (seeds.length >= 4) break;
-        }
-        if (seeds.length > 0) {
-          const gs = Date.now();
-          this.emitProgress({ type: "workspace/retrieve/graph/start", workspaceRoot: this.workspaceRoot, seeds: seeds.length });
-          graphNeighborFiles = await this.graphStore.neighborFiles({
-            seeds,
-            limit: profile.name === "architecture" ? 16 : 10,
-            kinds: ["definition", "reference", "implementation", "typeDefinition"]
-          });
-          this.emitProgress({ type: "workspace/retrieve/graph/done", workspaceRoot: this.workspaceRoot, neighbors: graphNeighborFiles.length, ms: Date.now() - gs });
-        }
-      }
+      await warmSymbolGraphForHits(this.repos, hits);
     } catch {
-      graphNeighborFiles = [];
-    }
-    const contextBlocks = [];
-    const seenKey = /* @__PURE__ */ new Set();
-    const addBlock = (repoRoot, path19, startLine, endLine, text, reason) => {
-      const key = `${repoRoot}:${path19}:${startLine}:${endLine}:${text.length}:${reason}`;
-      if (seenKey.has(key)) return;
-      seenKey.add(key);
-      if (!text.trim()) return;
-      contextBlocks.push({ repoRoot, path: path19, startLine, endLine, text, reason });
-    };
-    try {
-      const byRepoId = /* @__PURE__ */ new Map();
-      for (const r of this.repos) byRepoId.set(r.repoId, r);
-      for (const n of graphNeighborFiles.slice(0, 10)) {
-        const repo = byRepoId.get(n.repoId);
-        if (!repo) continue;
-        const chunkId = await repo.getRepresentativeChunkIdForFile(n.path, true);
-        if (!chunkId) continue;
-        const meta = repo.getChunkMeta(chunkId);
-        if (!meta) continue;
-        const text = repo.getChunkText(chunkId);
-        addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, text, `graph neighbor (${n.weight})`);
-      }
-    } catch {
-    }
-    for (const h of hits) {
-      const repo = this.repos.find((r) => r.repoRoot === h.chunk.repoRoot);
-      if (!repo) continue;
-      const text = repo.getChunkText(h.chunk.id);
-      addBlock(h.chunk.repoRoot, h.chunk.path, h.chunk.startLine, h.chunk.endLine, text, "primary hit");
-      const expanded = await repo.expandContext(h.chunk.id, {
-        adjacentChunks: profile.expand.adjacentChunks ?? 0,
-        followImports: profile.expand.followImports ?? 0,
-        includeFileSynopsis: profile.expand.includeFileSynopsis ?? false
-      });
-      for (const ex of expanded) {
-        const meta = repo.getChunkMeta(ex.id);
-        if (!meta) continue;
-        const t = repo.getChunkText(ex.id);
-        addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, t, ex.reason);
-      }
     }
+    const graphNeighborFiles = await fetchGraphNeighborFiles({
+      graphStore: this.graphStore,
+      repos: this.repos,
+      hits,
+      profile,
+      workspaceRoot: this.workspaceRoot,
+      emitProgress: (e) => this.emitProgress(e)
+    });
+    const contextBlocks = await buildContextBlocks({ repos: this.repos, hits, graphNeighborFiles, profile });
     const bundle = {
       hits,
       context: contextBlocks,
@@ -4432,7 +4570,7 @@ var WorkspaceIndexer = class {
         reposSearched: this.repos.length,
         candidates: {
           vector: vecCount,
-          lexical: lexCount,
+          lexical: totalLexCount,
           merged: merged.length,
           returned: hits.length
         }
@@ -4444,7 +4582,7 @@ var WorkspaceIndexer = class {
       profile: profile.name,
       ms: Date.now() - startedAt,
       hits: hits.length,
-      candidates: { vector: vecCount, lexical: lexCount, merged: merged.length }
+      candidates: { vector: vecCount, lexical: totalLexCount, merged: merged.length }
     });
     return bundle;
   }
@@ -4581,11 +4719,11 @@ var HashEmbeddingsProvider = class {
 };
 
 // src/config.ts
-import fs14 from "fs";
-import path18 from "path";
+import fs16 from "fs";
+import path21 from "path";
 function loadConfigFile(filePath) {
-  const abs = path18.resolve(filePath);
-  const raw = fs14.readFileSync(abs, "utf8");
+  const abs = path21.resolve(filePath);
+  const raw = fs16.readFileSync(abs, "utf8");
   const json = JSON.parse(raw);
   const cfg = { ...json };
   if (json.redact?.patterns && Array.isArray(json.redact.patterns)) {
@@ -4615,11 +4753,13 @@ export {
   NoopAnnIndex,
   createAnnIndex,
   RepoIndexer,
-  DEFAULT_PROFILES,
-  deepMergeProfile,
   discoverGitRepos,
   pickRepoOverride,
   mergeIndexerConfig,
+  betterSqlite3Adapter,
+  sqlJsAdapter,
+  createWorkspaceStore,
+  createWorkspaceStoreAsync,
   WorkspaceStore,
   Neo4jGraphStore,
   createNeo4jGraphStore,
@@ -4629,6 +4769,8 @@ export {
   VsCodeContributesLanguageLinkStrategy,
   WorkspaceLinker,
   linkWorkspaceRepos,
+  DEFAULT_PROFILES,
+  deepMergeProfile,
   WorkspaceIndexer,
   OllamaEmbeddingsProvider,
   OpenAIEmbeddingsProvider,