@qtv/anchorkit 1.2.5-beta.3.1 → 1.2.6-beta.3.1

package/dist/cli.mjs

@@ -143,7 +143,7 @@ var init_debugLog = __esm(() => {
   init_paths();
 });
 
-// src/vault/indexer/manifests.ts
+// src/core/vault/indexing/manifests.ts
 import { existsSync as existsSync6, readFileSync as readFileSync4, readdirSync } from "node:fs";
 import { join as join7, relative } from "node:path";
 function detectFramework(deps, devDeps) {
@@ -336,13 +336,7 @@ var init_manifests = __esm(() => {
   ];
 });
 
-// src/vault/indexer/index.ts
-var exports_indexer = {};
-__export(exports_indexer, {
-  indexCodebase: () => indexCodebase,
-  countFiles: () => countFiles,
-  SKIP_DIRS: () => SKIP_DIRS
-});
+// src/core/vault/indexing/codebase.ts
 import { execSync } from "node:child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "node:fs";
 import { extname, join as join8 } from "node:path";
@@ -659,7 +653,7 @@ async function indexCodebase(projectRoot) {
   };
 }
 var SKIP_DIRS, LARGE_REPO_THRESHOLD = 1e4;
-var init_indexer = __esm(() => {
+var init_codebase = __esm(() => {
   init_manifests();
   SKIP_DIRS = new Set([
     "node_modules",
@@ -681,6 +675,66 @@ var init_indexer = __esm(() => {
   ]);
 });
 
+// src/core/vault/indexing/vault-walk.ts
+import { existsSync as existsSync8, readdirSync as readdirSync3, statSync } from "node:fs";
+import { join as join9 } from "node:path";
+function* walkVaultNoteFiles(vaultPath) {
+  if (!existsSync8(vaultPath))
+    return;
+  for (const folder of NOTE_FOLDERS) {
+    const dir = join9(vaultPath, folder);
+    if (!existsSync8(dir))
+      continue;
+    let entries;
+    try {
+      entries = readdirSync3(dir);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (!name.endsWith(".md"))
+        continue;
+      if (name.startsWith("_"))
+        continue;
+      const abs = join9(dir, name);
+      try {
+        if (!statSync(abs).isFile())
+          continue;
+      } catch {
+        continue;
+      }
+      yield { folder, abs };
+    }
+  }
+}
+var NOTE_FOLDERS;
+var init_vault_walk = __esm(() => {
+  NOTE_FOLDERS = [
+    "knowledge",
+    "maps",
+    "decisions",
+    "flows",
+    "incidents",
+    "archive"
+  ];
+});
+
+// src/core/vault/indexing/index.ts
+var exports_indexing = {};
+__export(exports_indexing, {
+  walkVaultNoteFiles: () => walkVaultNoteFiles,
+  indexCodebase: () => indexCodebase,
+  detectManifests: () => detectManifests,
+  countFiles: () => countFiles,
+  SKIP_DIRS: () => SKIP_DIRS,
+  NOTE_FOLDERS: () => NOTE_FOLDERS
+});
+var init_indexing = __esm(() => {
+  init_codebase();
+  init_manifests();
+  init_vault_walk();
+});
+
 // src/vault/mapper/analyze/edges.ts
 import path from "node:path";
 function buildEdges(candidates, importsByModule) {
@@ -826,8 +880,8 @@ var init_buildEdges = __esm(() => {
 });
 
 // src/vault/mapper/discover/enumerate.ts
-import { readdirSync as readdirSync3 } from "node:fs";
-import { dirname as dirname5, extname as extname2, join as join9, relative as relative2 } from "node:path";
+import { readdirSync as readdirSync4 } from "node:fs";
+import { dirname as dirname5, extname as extname2, join as join10, relative as relative2 } from "node:path";
 function toCandidate(dir, files, sourceRoot, repoRoot) {
   const rel = relative2(sourceRoot, dir);
   const slug = rel ? toKebab(rel) : toKebab(relative2(repoRoot, dir));
@@ -868,14 +922,14 @@ function collectFilesViaFsWalk(sourceRoot) {
   function walk(dir, acc) {
     let entries;
     try {
-      entries = readdirSync3(dir, { withFileTypes: true });
+      entries = readdirSync4(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name))
         continue;
-      const full = join9(dir, entry.name);
+      const full = join10(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full, acc);
       } else if (SOURCE_EXTS.has(extname2(entry.name).toLowerCase())) {
@@ -889,7 +943,7 @@ function toKebab(relPath) {
 }
 var SOURCE_EXTS;
 var init_enumerate = __esm(() => {
-  init_indexer();
+  init_indexing();
   SOURCE_EXTS = new Set([
     ".ts",
     ".tsx",
@@ -913,8 +967,8 @@ var init_enumerate = __esm(() => {
 });
 
 // src/vault/mapper/discover/sourceRoot.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "node:fs";
-import { join as join10, resolve } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync6, readdirSync as readdirSync5 } from "node:fs";
+import { join as join11, resolve } from "node:path";
 function resolveSourceRoot(repoRoot, indexResult) {
   const abs = resolve(repoRoot);
   if (indexResult.structure.isMonorepo && indexResult.structure.workspaces?.length) {
@@ -927,18 +981,18 @@ function resolveSingleRoot(repoRoot) {
   const fromTsconfig = readTsconfigRoot(repoRoot);
   if (fromTsconfig) {
     const candidate = resolve(repoRoot, fromTsconfig);
-    if (existsSync8(candidate))
+    if (existsSync9(candidate))
       return candidate;
   }
-  if (existsSync8(join10(repoRoot, "src")))
-    return join10(repoRoot, "src");
-  if (existsSync8(join10(repoRoot, "lib")))
-    return join10(repoRoot, "lib");
+  if (existsSync9(join11(repoRoot, "src")))
+    return join11(repoRoot, "src");
+  if (existsSync9(join11(repoRoot, "lib")))
+    return join11(repoRoot, "lib");
   return repoRoot;
 }
 function readTsconfigRoot(repoRoot) {
-  const tsconfigPath = join10(repoRoot, "tsconfig.json");
-  if (!existsSync8(tsconfigPath))
+  const tsconfigPath = join11(repoRoot, "tsconfig.json");
+  if (!existsSync9(tsconfigPath))
     return null;
   try {
     const raw = readFileSync6(tsconfigPath, "utf-8");
@@ -962,21 +1016,21 @@ function resolveMonorepoRoots(repoRoot, workspaceGlobs) {
   for (const glob of workspaceGlobs) {
     if (glob.endsWith("/*") || glob.endsWith("/**/")) {
       const base = glob.replace(/\/?\*\*?\/?$/, "");
-      const baseDir = join10(repoRoot, base);
-      if (!existsSync8(baseDir))
+      const baseDir = join11(repoRoot, base);
+      if (!existsSync9(baseDir))
         continue;
       try {
-        const entries = readdirSync4(baseDir, { withFileTypes: true });
+        const entries = readdirSync5(baseDir, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.isDirectory() || entry.name.startsWith("."))
             continue;
-          const wsRoot = join10(baseDir, entry.name);
+          const wsRoot = join11(baseDir, entry.name);
           roots.push(resolveSingleRoot(wsRoot));
         }
       } catch {}
     } else {
-      const wsRoot = join10(repoRoot, glob);
-      if (existsSync8(wsRoot)) {
+      const wsRoot = join11(repoRoot, glob);
+      if (existsSync9(wsRoot)) {
         roots.push(resolveSingleRoot(wsRoot));
       }
     }
@@ -8436,23 +8490,15 @@ var init_dist = __esm(() => {
 });
 
 // src/vault/internal/utils.ts
-import {
-  appendFileSync as appendFileSync2,
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync7,
-  readdirSync as readdirSync5,
-  statSync,
-  writeFileSync as writeFileSync3
-} from "node:fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname7, join as join11, resolve as resolve2 } from "node:path";
+import { dirname as dirname7, join as join12, resolve as resolve2 } from "node:path";
 function errorMessage(e) {
   return e instanceof Error ? e.message : String(e);
 }
 function vaultDebugLogPath() {
-  const home = process.env.ANCHORKIT_TEST_HOME ?? join11(homedir5(), ".anchorkit");
-  return join11(home, "logs", "debug.log");
+  const home = process.env.ANCHORKIT_TEST_HOME ?? join12(homedir5(), ".anchorkit");
+  return join12(home, "logs", "debug.log");
 }
 function ensureDebugLogReady() {
   if (!process.env.ANCHORKIT_DEBUG)
@@ -8480,6 +8526,67 @@ function logForDebugging(message, opts = {}) {
 function parseYaml(input) {
   return $parse(input);
 }
+async function runWithLimit(tasks, limit) {
+  const results = new Array(tasks.length);
+  let next = 0;
+  async function worker() {
+    while (next < tasks.length) {
+      const idx = next++;
+      try {
+        const value = await tasks[idx]?.();
+        results[idx] = { status: "fulfilled", value };
+      } catch (reason) {
+        results[idx] = { status: "rejected", reason };
+      }
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+function findGitRoot(startDir = process.cwd()) {
+  let dir = resolve2(startDir);
+  while (true) {
+    if (existsSync10(join12(dir, ".git")))
+      return dir;
+    const parent = dirname7(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function ensureIgnored(repoRoot, pattern) {
+  const gitignorePath = join12(repoRoot, ".gitignore");
+  const norm = (p) => p.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+  const normalizedTarget = norm(pattern);
+  if (!existsSync10(gitignorePath)) {
+    mkdirSync4(dirname7(gitignorePath), { recursive: true });
+    writeFileSync3(gitignorePath, `${pattern}
+`, "utf-8");
+    return { added: true };
+  }
+  const content = readFileSync7(gitignorePath, "utf-8");
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    if (norm(line) === normalizedTarget)
+      return { added: false };
+  }
+  const needsLeadingEol = content.length > 0 && !content.endsWith(`
+`);
+  const eol = content.includes(`\r
+`) ? `\r
+` : `
+`;
+  const prefix = needsLeadingEol ? eol : "";
+  writeFileSync3(gitignorePath, content + prefix + pattern + eol, "utf-8");
+  return { added: true };
+}
+var debugLogReady = null;
+var init_utils = __esm(() => {
+  init_dist();
+});
+
+// src/core/vault/conventions/frontmatter.ts
 function quoteProblematicValues(frontmatterText) {
   const lines = frontmatterText.split(`
 `);
@@ -8516,14 +8623,14 @@ function parseFrontmatter(markdown, sourcePath) {
   const content = markdown.slice(match[0].length);
   let frontmatter = {};
   try {
-    const parsed = parseYaml(frontmatterText);
+    const parsed = $parse(frontmatterText);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       frontmatter = parsed;
     }
   } catch {
     try {
       const quoted = quoteProblematicValues(frontmatterText);
-      const parsed = parseYaml(quoted);
+      const parsed = $parse(quoted);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         frontmatter = parsed;
       }
@@ -8556,93 +8663,10 @@ function serializeFrontmatter(fm) {
 ${body}---
 `;
 }
-async function runWithLimit(tasks, limit) {
-  const results = new Array(tasks.length);
-  let next = 0;
-  async function worker() {
-    while (next < tasks.length) {
-      const idx = next++;
-      try {
-        const value = await tasks[idx]?.();
-        results[idx] = { status: "fulfilled", value };
-      } catch (reason) {
-        results[idx] = { status: "rejected", reason };
-      }
-    }
-  }
-  const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => worker());
-  await Promise.all(workers);
-  return results;
-}
-function findGitRoot(startDir = process.cwd()) {
-  let dir = resolve2(startDir);
-  while (true) {
-    if (existsSync9(join11(dir, ".git")))
-      return dir;
-    const parent = dirname7(dir);
-    if (parent === dir)
-      return null;
-    dir = parent;
-  }
-}
-function ensureIgnored(repoRoot, pattern) {
-  const gitignorePath = join11(repoRoot, ".gitignore");
-  const norm = (p) => p.trim().replace(/^\/+/, "").replace(/\/+$/, "");
-  const normalizedTarget = norm(pattern);
-  if (!existsSync9(gitignorePath)) {
-    mkdirSync4(dirname7(gitignorePath), { recursive: true });
-    writeFileSync3(gitignorePath, `${pattern}
-`, "utf-8");
-    return { added: true };
-  }
-  const content = readFileSync7(gitignorePath, "utf-8");
-  const lines = content.split(/\r?\n/);
-  for (const line of lines) {
-    if (norm(line) === normalizedTarget)
-      return { added: false };
-  }
-  const needsLeadingEol = content.length > 0 && !content.endsWith(`
-`);
-  const eol = content.includes(`\r
-`) ? `\r
-` : `
-`;
-  const prefix = needsLeadingEol ? eol : "";
-  writeFileSync3(gitignorePath, content + prefix + pattern + eol, "utf-8");
-  return { added: true };
-}
-function* walkVaultNoteFiles(vaultPath) {
-  if (!existsSync9(vaultPath))
-    return;
-  for (const folder of NOTE_FOLDERS) {
-    const dir = join11(vaultPath, folder);
-    if (!existsSync9(dir))
-      continue;
-    let entries;
-    try {
-      entries = readdirSync5(dir);
-    } catch {
-      continue;
-    }
-    for (const name of entries) {
-      if (!name.endsWith(".md"))
-        continue;
-      if (name.startsWith("_"))
-        continue;
-      const abs = join11(dir, name);
-      try {
-        if (!statSync(abs).isFile())
-          continue;
-      } catch {
-        continue;
-      }
-      yield { folder, abs };
-    }
-  }
-}
-var debugLogReady = null, FRONTMATTER_REGEX, YAML_SPECIAL_CHARS, FRONTMATTER_FIELD_ORDER, NOTE_FOLDERS;
-var init_utils = __esm(() => {
+var FRONTMATTER_REGEX, YAML_SPECIAL_CHARS, FRONTMATTER_FIELD_ORDER;
+var init_frontmatter = __esm(() => {
   init_dist();
+  init_utils();
   FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)---\s*\n?/;
   YAML_SPECIAL_CHARS = /[{}[\]*&#!|>%@`]|: /;
   FRONTMATTER_FIELD_ORDER = [
@@ -8678,14 +8702,6 @@ var init_utils = __esm(() => {
     "affected_modules",
     "source"
   ];
-  NOTE_FOLDERS = [
-    "knowledge",
-    "maps",
-    "decisions",
-    "flows",
-    "incidents",
-    "archive"
-  ];
 });
 
 // src/core/vault/conventions/parser.ts
@@ -9081,15 +9097,16 @@ var init_validator = __esm(() => {
 // src/core/vault/conventions/index.ts
 var init_conventions = __esm(() => {
   init_defaults();
+  init_frontmatter();
   init_parser();
   init_validator();
 });
 
 // src/core/vault/storage/writer.ts
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname8, join as join12 } from "node:path";
+import { dirname as dirname8, join as join13 } from "node:path";
 function writeVaultDoc(vaultPath, doc) {
-  const filePath = join12(vaultPath, doc.filename);
+  const filePath = join13(vaultPath, doc.filename);
   mkdirSync5(dirname8(filePath), { recursive: true });
   const fullContent = `# ${doc.title}
 
@@ -9116,22 +9133,22 @@ function writeVaultDocs(vaultPath, projectName, docs) {
     ""
   ].join(`
 `);
-  const indexPath = join12(vaultPath, "index.md");
+  const indexPath = join13(vaultPath, "index.md");
   mkdirSync5(vaultPath, { recursive: true });
   writeFileSync4(indexPath, indexContent, "utf-8");
   writtenFiles.push("index.md");
   return writtenFiles;
 }
 function writeVaultFile(vaultPath, filename, content) {
-  const filePath = join12(vaultPath, filename);
+  const filePath = join13(vaultPath, filename);
   mkdirSync5(dirname8(filePath), { recursive: true });
   writeFileSync4(filePath, content, "utf-8");
 }
 var init_writer = () => {};
 
 // src/vault/escapeHatch/log.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join14 } from "node:path";
 function targetVaultPath(cfg, needs) {
   if (needs.affectedVault === "global" && cfg.global) {
     return cfg.global.path;
@@ -9141,8 +9158,8 @@ function targetVaultPath(cfg, needs) {
 function appendLine(vaultPath, line) {
   try {
     mkdirSync6(vaultPath, { recursive: true });
-    const logPath = join13(vaultPath, "_log.md");
-    if (!existsSync10(logPath)) {
+    const logPath = join14(vaultPath, "_log.md");
+    if (!existsSync11(logPath)) {
       writeFileSync5(logPath, `# Vault log
 
 ${line}
@@ -9230,15 +9247,15 @@ var init_wikiLinkParser = __esm(() => {
 });
 
 // src/core/vault/storage/writeNote-helpers.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, readdirSync as readdirSync6, statSync as statSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync9, readdirSync as readdirSync6, statSync as statSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join15 } from "node:path";
 function appendLogEntry(vaultPath, kind, target = "") {
   const ts = new Date().toISOString();
   const middle = target ? `  ${target}` : "";
   const line = `- ${ts}  ${kind}${middle}  source: code-analysis
 `;
-  const logPath = join14(vaultPath, "_log.md");
-  if (!existsSync11(logPath)) {
+  const logPath = join15(vaultPath, "_log.md");
+  if (!existsSync12(logPath)) {
     writeFileSync6(logPath, `# Vault log
 
 ${line}`, "utf-8");
@@ -9252,7 +9269,7 @@ ${line}`, "utf-8");
 }
 function collectNoteBasenames(dir) {
   const names = new Set;
-  if (!existsSync11(dir))
+  if (!existsSync12(dir))
     return names;
   const walk = (d) => {
     let entries;
@@ -9262,7 +9279,7 @@ function collectNoteBasenames(dir) {
       return;
     }
     for (const entry of entries) {
-      const p = join14(d, entry);
+      const p = join15(d, entry);
       let s;
       try {
         s = statSync2(p);
@@ -9282,7 +9299,7 @@ function collectNoteBasenames(dir) {
 function collectAllNoteBasenames(vaultPath) {
   const names = new Set;
   for (const folder of NOTE_FOLDERS) {
-    const folderPath = join14(vaultPath, folder);
+    const folderPath = join15(vaultPath, folder);
     for (const n of collectNoteBasenames(folderPath)) {
       if (!n.startsWith("_"))
         names.add(n);
@@ -9348,7 +9365,7 @@ function countIncomingLinks(vaultPath, selfFilename) {
       return;
     }
     for (const entry of entries) {
-      const p = join14(d, entry);
+      const p = join15(d, entry);
       let s;
       try {
         s = statSync2(p);
@@ -9367,7 +9384,7 @@ function countIncomingLinks(vaultPath, selfFilename) {
     }
   };
   for (const folder of NOTE_FOLDERS) {
-    walk(join14(vaultPath, folder));
+    walk(join15(vaultPath, folder));
   }
   return count;
 }
@@ -9454,18 +9471,19 @@ function checkOrphan(vaultPath, filename, relPath) {
 var WIKILINK_RE;
 var init_writeNote_helpers = __esm(() => {
   init_resolver();
-  init_utils();
+  init_conventions();
+  init_indexing();
   init_wikiLinkParser();
   WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
 });
 
 // src/core/vault/storage/writeNote.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join16 } from "node:path";
 function loadConventions(vaultPath) {
   mkdirSync8(vaultPath, { recursive: true });
-  const conventionsPath = join15(vaultPath, "_conventions.md");
-  if (!existsSync12(conventionsPath)) {
+  const conventionsPath = join16(vaultPath, "_conventions.md");
+  if (!existsSync13(conventionsPath)) {
     writeFileSync7(conventionsPath, CONVENTIONS_MD_DEFAULT, "utf-8");
     appendLogEntry(vaultPath, "conventions-regenerated");
   }
@@ -9527,12 +9545,12 @@ var init_writeNote = __esm(() => {
 });
 
 // src/core/vault/storage/scaffold.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync11, readdirSync as readdirSync7, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync11, readdirSync as readdirSync7, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join17 } from "node:path";
 function writeIfAbsent(absPath, content) {
-  if (existsSync13(absPath))
+  if (existsSync14(absPath))
     return false;
-  mkdirSync9(join16(absPath, ".."), { recursive: true });
+  mkdirSync9(join17(absPath, ".."), { recursive: true });
   writeFileSync8(absPath, content, "utf-8");
   return true;
 }
@@ -9579,20 +9597,20 @@ async function bootstrapVault(cfg, opts) {
     if (wrote)
       filesCreated.push(relPath);
   };
-  track("_index.md", writeIfAbsent(join16(vp, "_index.md"), masterIndex()));
-  track("_conventions.md", writeIfAbsent(join16(vp, "_conventions.md"), CONVENTIONS_MD_DEFAULT));
-  track("_log.md", writeIfAbsent(join16(vp, "_log.md"), initialLog()));
+  track("_index.md", writeIfAbsent(join17(vp, "_index.md"), masterIndex()));
+  track("_conventions.md", writeIfAbsent(join17(vp, "_conventions.md"), CONVENTIONS_MD_DEFAULT));
+  track("_log.md", writeIfAbsent(join17(vp, "_log.md"), initialLog()));
   for (const f of SUBFOLDERS) {
-    track(`${f}/_index.md`, writeIfAbsent(join16(vp, f, "_index.md"), subfolderIndex(f)));
+    track(`${f}/_index.md`, writeIfAbsent(join17(vp, f, "_index.md"), subfolderIndex(f)));
   }
   for (const type of NOTE_TYPES) {
-    track(`meta/templates/${type}.md`, writeIfAbsent(join16(vp, "meta", "templates", `${type}.md`), TEMPLATES[type]));
+    track(`meta/templates/${type}.md`, writeIfAbsent(join17(vp, "meta", "templates", `${type}.md`), TEMPLATES[type]));
   }
-  const specsRoot = join16(vp, "..", "specs");
+  const specsRoot = join17(vp, "..", "specs");
   for (const sf of SPECS_SUBFOLDERS) {
-    const dir = join16(specsRoot, sf);
+    const dir = join17(specsRoot, sf);
     mkdirSync9(dir, { recursive: true });
-    track(`../specs/${sf}/.gitkeep`, writeIfAbsent(join16(dir, ".gitkeep"), ""));
+    track(`../specs/${sf}/.gitkeep`, writeIfAbsent(join17(dir, ".gitkeep"), ""));
   }
   let gitignoreUpdated = false;
   if (opts.gitignore) {
@@ -9602,7 +9620,7 @@ async function bootstrapVault(cfg, opts) {
   return { vaultPath: vp, filesCreated, gitignoreUpdated };
 }
 function detectVaultShape(vaultPath) {
-  if (!existsSync13(vaultPath))
+  if (!existsSync14(vaultPath))
     return "none";
   let entries;
   try {
@@ -13296,21 +13314,21 @@ var init_noteAccess = __esm(() => {
 var init_artifacts = () => {};
 
 // src/vault/globalConfig.ts
-import { chmodSync as chmodSync2, existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname9, join as join17 } from "node:path";
+import { dirname as dirname9, join as join18 } from "node:path";
 function resolveMachineConfigPath() {
   if (process.env.ANCHORKIT_TEST_MACHINE_CONFIG_PATH) {
     return process.env.ANCHORKIT_TEST_MACHINE_CONFIG_PATH;
   }
   if (process.platform === "win32" && process.env.APPDATA) {
-    return join17(process.env.APPDATA, "anchorkit", "config.json");
+    return join18(process.env.APPDATA, "anchorkit", "config.json");
   }
-  return join17(homedir6(), ".anchorkit", "config.json");
+  return join18(homedir6(), ".anchorkit", "config.json");
 }
 function loadMachineConfig() {
   const path2 = resolveMachineConfigPath();
-  if (!existsSync14(path2))
+  if (!existsSync15(path2))
     return {};
   try {
     const raw = readFileSync12(path2, "utf-8");
@@ -13327,9 +13345,9 @@ function defaultGlobalVaultPath() {
     return process.env.ANCHORKIT_TEST_DEFAULT_GLOBAL_VAULT_PATH;
   }
   if (process.platform === "win32" && process.env.APPDATA) {
-    return join17(process.env.APPDATA, "anchorkit", "global-vault");
+    return join18(process.env.APPDATA, "anchorkit", "global-vault");
   }
-  return join17(homedir6(), ".anchorkit", "global-vault");
+  return join18(homedir6(), ".anchorkit", "global-vault");
 }
 function resolveGlobalVault() {
   const cfg = loadMachineConfig();
@@ -13353,11 +13371,11 @@ __export(exports_config, {
   isRepoOnboarded: () => isRepoOnboarded,
   adaptLegacyConfig: () => adaptLegacyConfig
 });
-import { existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "node:fs";
-import { basename as basename2, join as join18 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "node:fs";
+import { basename as basename2, join as join19 } from "node:path";
 function resolveVaultPath(projectRoot) {
-  const configPath = join18(projectRoot, ".anchorkit", "config.json");
-  if (existsSync15(configPath)) {
+  const configPath = join19(projectRoot, ".anchorkit", "config.json");
+  if (existsSync16(configPath)) {
     try {
       const raw = readFileSync13(configPath, "utf-8");
       const config = JSON.parse(raw);
@@ -13366,7 +13384,7 @@ function resolveVaultPath(projectRoot) {
       }
     } catch {}
   }
-  return join18(projectRoot, ".anchorkit", "vault");
+  return join19(projectRoot, ".anchorkit", "vault");
 }
 function resolveVaultConfig(projectRoot, provider = "generic") {
   const vaultPath = resolveVaultPath(projectRoot);
@@ -13386,8 +13404,8 @@ function resolveGlobal() {
   return null;
 }
 function loadVaultManifest(vaultPath) {
-  const manifestPath = join18(vaultPath, "manifest.json");
-  if (!existsSync15(manifestPath)) {
+  const manifestPath = join19(vaultPath, "manifest.json");
+  if (!existsSync16(manifestPath)) {
     return null;
   }
   try {
@@ -13399,12 +13417,12 @@ function loadVaultManifest(vaultPath) {
 }
 function saveVaultManifest(vaultPath, manifest) {
   mkdirSync11(vaultPath, { recursive: true });
-  const manifestPath = join18(vaultPath, "manifest.json");
+  const manifestPath = join19(vaultPath, "manifest.json");
   writeFileSync10(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
 }
 function isRepoOnboarded(projectRoot) {
   const vaultPath = resolveVaultPath(projectRoot);
-  return existsSync15(join18(vaultPath, "manifest.json"));
+  return existsSync16(join19(vaultPath, "manifest.json"));
 }
 function adaptLegacyConfig(cfg) {
   if ("local" in cfg)
@@ -14033,11 +14051,11 @@ var init_emitNotes = __esm(() => {
 });
 
 // src/vault/mapper/emit/orphanGate.ts
-import { existsSync as existsSync16, readFileSync as readFileSync15, readdirSync as readdirSync8, statSync as statSync3 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync15, readdirSync as readdirSync8, statSync as statSync3 } from "node:fs";
+import { join as join20 } from "node:path";
 function runOrphanGate(vaultPath) {
-  const mapsDir = join19(vaultPath, "maps");
-  const knowledgeDir = join19(vaultPath, "knowledge");
+  const mapsDir = join20(vaultPath, "maps");
+  const knowledgeDir = join20(vaultPath, "knowledge");
   const linkedFromMaps = new Set;
   walkMdFiles(mapsDir, (content) => {
     for (const match of content.matchAll(WIKILINK_RE2)) {
@@ -14060,7 +14078,7 @@ function runOrphanGate(vaultPath) {
   return { orphans, ok: orphans.length === 0 };
 }
 function walkMdFiles(dir, callback) {
-  if (!existsSync16(dir))
+  if (!existsSync17(dir))
     return;
   const walk = (d) => {
     let entries;
@@ -14070,7 +14088,7 @@ function walkMdFiles(dir, callback) {
       return;
     }
     for (const entry of entries) {
-      const p = join19(d, entry);
+      const p = join20(d, entry);
       let s;
       try {
         s = statSync3(p);
@@ -14109,7 +14127,7 @@ var init_runOrphanGate = __esm(() => {
 });
 
 // src/vault/mapper/analyze/tsParser.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync16 } from "node:fs";
 import path2 from "node:path";
 import { Project, ts } from "ts-morph";
 function detectScriptKind(absPath) {
@@ -14150,7 +14168,7 @@ function createTsParser(repoRoot, options2 = {}) {
     if (project)
       return project;
     const candidate = options2.tsConfigFilePath ?? path2.join(absRepoRoot, "tsconfig.json");
-    const tsConfigPath = existsSync17(candidate) ? candidate : null;
+    const tsConfigPath = existsSync18(candidate) ? candidate : null;
     project = new Project(buildProjectOptions(tsConfigPath));
     return project;
   }
@@ -15041,7 +15059,11 @@ var init_inferSemantic = __esm(() => {
   TOOLS.inferSemantic = { fn: inferSemantic, descriptor: descriptor8 };
 });
 
-// src/vault/query/embeddings.ts
+// src/core/vault/query/embeddings.ts
+function setEmbedder(embedder) {
+  cachedEmbedder = embedder;
+  cachedEmbedderPromise = null;
+}
 async function loadEmbedder() {
   if (cachedEmbedder)
     return cachedEmbedder;
@@ -15104,19 +15126,10 @@ var init_embeddings = __esm(() => {
   init_utils();
 });
 
-// src/vault/query/index.ts
-var exports_query = {};
-__export(exports_query, {
-  updateEntry: () => updateEntry,
-  safeMtimeMs: () => safeMtimeMs,
-  removeEntry: () => removeEntry,
-  persistIndex: () => persistIndex,
-  loadIndex: () => loadIndex,
-  buildIndex: () => buildIndex
-});
+// src/core/vault/query/noteIndex.ts
 import { createHash as createHash4 } from "node:crypto";
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync19,
   readdirSync as readdirSync9,
@@ -15125,12 +15138,12 @@ import {
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename as basename6, extname as extname4, join as join20 } from "node:path";
+import { basename as basename6, extname as extname4, join as join21 } from "node:path";
 function cacheDir(vaultPath) {
-  return join20(vaultPath, ".cache");
+  return join21(vaultPath, ".cache");
 }
 function indexPath(vaultPath) {
-  return join20(cacheDir(vaultPath), INDEX_FILENAME);
+  return join21(cacheDir(vaultPath), INDEX_FILENAME);
 }
 function emptyIndex() {
   return {
@@ -15147,7 +15160,7 @@ function isValidIndex(value) {
 }
 function loadIndex(vaultPath) {
   const path4 = indexPath(vaultPath);
-  if (!existsSync18(path4))
+  if (!existsSync19(path4))
     return null;
   try {
     const raw = JSON.parse(readFileSync19(path4, "utf-8"));
@@ -15172,8 +15185,8 @@ function loadIndex(vaultPath) {
 function ensureCacheDir(vaultPath) {
   const dir = cacheDir(vaultPath);
   mkdirSync12(dir, { recursive: true });
-  const gi = join20(dir, ".gitignore");
-  if (!existsSync18(gi)) {
+  const gi = join21(dir, ".gitignore");
+  if (!existsSync19(gi)) {
     try {
       writeFileSync11(gi, `*
 !.gitignore
@@ -15183,7 +15196,7 @@ function ensureCacheDir(vaultPath) {
 }
 function persistIndex(vaultPath, idx) {
   ensureCacheDir(vaultPath);
-  const tmp = join20(tmpdir(), `bridgeai-index-${process.pid}-${Date.now()}.json`);
+  const tmp = join21(tmpdir(), `bridgeai-index-${process.pid}-${Date.now()}.json`);
   try {
     writeFileSync11(tmp, JSON.stringify(idx), "utf-8");
     renameSync(tmp, indexPath(vaultPath));
@@ -15196,8 +15209,8 @@ function persistIndex(vaultPath, idx) {
 function readNotesFromVault(vaultPath, scope) {
   const out = [];
   for (const folder of NOTE_FOLDERS) {
-    const dir = join20(vaultPath, folder);
-    if (!existsSync18(dir))
+    const dir = join21(vaultPath, folder);
+    if (!existsSync19(dir))
       continue;
     let entries;
     try {
@@ -15210,7 +15223,7 @@ function readNotesFromVault(vaultPath, scope) {
         continue;
       if (entry.startsWith("_"))
         continue;
-      const full = join20(dir, entry);
+      const full = join21(dir, entry);
       let raw;
       try {
         raw = readFileSync19(full, "utf-8");
@@ -15350,23 +15363,490 @@ function safeMtimeMs(path4) {
   }
 }
 var SCHEMA_VERSION2 = "1", INDEX_FILENAME = "embeddings.json";
-var init_query = __esm(() => {
+var init_noteIndex = __esm(() => {
+  init_utils();
+  init_conventions();
+  init_indexing();
+  init_embeddings();
+});
+
+// src/core/vault/query/cacheAside.ts
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync20, renameSync as renameSync2, writeFileSync as writeFileSync12 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join22 } from "node:path";
+function cachePath2(vaultPath) {
+  return join22(vaultPath, ".cache", CACHE_FILENAME);
+}
+function emptyCache() {
+  return { schemaVersion: SCHEMA_VERSION3, entries: [] };
+}
+function isValidCache(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const v = value;
+  return v.schemaVersion === SCHEMA_VERSION3 && Array.isArray(v.entries);
+}
+function loadCacheFile(vaultPath) {
+  const path4 = cachePath2(vaultPath);
+  if (!existsSync20(path4))
+    return emptyCache();
+  try {
+    const raw = JSON.parse(readFileSync20(path4, "utf-8"));
+    if (!isValidCache(raw))
+      return emptyCache();
+    return raw;
+  } catch (err) {
+    logForDebugging(`[query/cache] load failed (resetting): ${errorMessage(err)}`, {
+      level: "warn"
+    });
+    return emptyCache();
+  }
+}
+function persistCacheFile(vaultPath, file) {
+  const dir = join22(vaultPath, ".cache");
+  mkdirSync13(dir, { recursive: true });
+  const gi = join22(dir, ".gitignore");
+  if (!existsSync20(gi)) {
+    try {
+      writeFileSync12(gi, `*
+!.gitignore
+`, "utf-8");
+    } catch {}
+  }
+  const tmp = join22(tmpdir2(), `bridgeai-qcache-${process.pid}-${Date.now()}.json`);
+  try {
+    writeFileSync12(tmp, JSON.stringify(file), "utf-8");
+    renameSync2(tmp, cachePath2(vaultPath));
+  } catch (err) {
+    logForDebugging(`[query/cache] persist failed: ${errorMessage(err)}`, { level: "warn" });
+  }
+}
+function hashQuery(query) {
+  return createHash5("sha256").update(query.trim().toLowerCase()).digest("hex");
+}
+function lookup(vaultPath, _query, vec) {
+  if (isZeroVector(vec))
+    return null;
+  const file = loadCacheFile(vaultPath);
+  if (file.entries.length === 0)
+    return null;
+  let best = null;
+  for (const entry of file.entries) {
+    const score = cosine(vec, entry.vector);
+    if (score < CACHE_HIT_THRESHOLD)
+      continue;
+    if (best === null || score > best.score)
+      best = { entry, score };
+  }
+  if (!best)
+    return null;
+  const verifiedMs = Date.parse(best.entry.lastVerified);
+  if (!Number.isFinite(verifiedMs))
+    return null;
+  for (const note of best.entry.topK) {
+    if (safeMtimeMs(note.path) > verifiedMs)
+      return null;
+  }
+  return best.entry;
+}
+function fill(vaultPath, query, vec, topK) {
+  if (isZeroVector(vec))
+    return;
+  const file = loadCacheFile(vaultPath);
+  const nowMs = Date.now();
+  const nowStr = new Date(nowMs).toISOString();
+  const maxMtimeMs = topK.reduce((m, n) => Math.max(m, safeMtimeMs(n.path)), 0);
+  const lastVerifiedMs = maxMtimeMs > 0 ? Math.max(nowMs, maxMtimeMs + 1) : nowMs;
+  const lastVerifiedStr = new Date(lastVerifiedMs).toISOString();
+  const queryHash = hashQuery(query);
+  const existingIdx = file.entries.findIndex((e) => e.queryHash === queryHash);
+  const entry = {
+    queryHash,
+    query,
+    vector: vec,
+    topK,
+    lastVerified: lastVerifiedStr,
+    lastQueried: nowStr
+  };
+  if (existingIdx >= 0) {
+    file.entries[existingIdx] = entry;
+  } else {
+    file.entries.push(entry);
+  }
+  if (file.entries.length > MAX_ENTRIES) {
+    file.entries.sort((a, b) => a.lastQueried.localeCompare(b.lastQueried));
+    file.entries = file.entries.slice(file.entries.length - MAX_ENTRIES);
+  }
+  persistCacheFile(vaultPath, file);
+}
+function touch(vaultPath, queryHash) {
+  const file = loadCacheFile(vaultPath);
+  const idx = file.entries.findIndex((e) => e.queryHash === queryHash);
+  if (idx < 0)
+    return;
+  file.entries[idx].lastQueried = new Date().toISOString();
+  persistCacheFile(vaultPath, file);
+}
+function coalesceCall(key, factory) {
+  const existing = inFlight.get(key);
+  if (existing)
+    return existing;
+  const fresh = factory().finally(() => {
+    inFlight.delete(key);
+  });
+  inFlight.set(key, fresh);
+  return fresh;
+}
+function clearCoalescer() {
+  inFlight.clear();
+}
+var CACHE_FILENAME = "query-cache.json", SCHEMA_VERSION3 = "1", MAX_ENTRIES = 100, inFlight;
+var init_cacheAside = __esm(() => {
   init_utils();
   init_utils();
+  init_embeddings();
+  init_noteIndex();
+  inFlight = new Map;
+});
+
+// src/core/vault/query/expansion.ts
+import { existsSync as existsSync21, readFileSync as readFileSync21 } from "node:fs";
+import { join as join23 } from "node:path";
+function findGlobalSlugsInBody(text) {
+  const out = [];
+  let match;
+  while ((match = WIKILINK_REGEX.exec(text)) !== null) {
+    const raw = match[1];
+    if (!raw)
+      continue;
+    const target = parseWikiLinkTarget(raw);
+    if (target.vault === "global")
+      out.push(target.slug);
+  }
+  return out;
+}
+function findGlobalSlugsInRelated(related) {
+  if (!Array.isArray(related))
+    return [];
+  const out = [];
+  for (const r of related) {
+    if (typeof r !== "string")
+      continue;
+    const stripped = r.replace(/^\[\[|\]\]$/g, "");
+    const target = parseWikiLinkTarget(stripped);
+    if (target.vault === "global")
+      out.push(target.slug);
+  }
+  return out;
+}
+function readGlobalNoteBody(globalPath, slug) {
+  for (const folder of NOTE_FOLDERS) {
+    const p = join23(globalPath, folder, `${slug}.md`);
+    if (!existsSync21(p))
+      continue;
+    try {
+      const raw = readFileSync21(p, "utf-8");
+      const parsed = parseFrontmatter(raw);
+      return parsed.content ?? "";
+    } catch (err) {
+      logForDebugging(`[query/expansion] read failed ${p}: ${errorMessage(err)}`, {
+        level: "warn"
+      });
+      return null;
+    }
+  }
+  return null;
+}
+async function readGlobalNoteBodyVia(globalPath, slug, noteAccess2) {
+  for (const folder of NOTE_FOLDERS) {
+    const p = join23(globalPath, folder, `${slug}.md`);
+    if (!existsSync21(p))
+      continue;
+    try {
+      const raw = await noteAccess2.readUserNote(p);
+      if (!raw)
+        return "";
+      const parsed = parseFrontmatter(raw);
+      return parsed.content ?? "";
+    } catch (err) {
+      logForDebugging(`[query/expansion] read failed ${p}: ${errorMessage(err)}`, {
+        level: "warn"
+      });
+      return null;
+    }
+  }
+  return null;
+}
+function collectGlobalSlugs(note) {
+  const fmRelated = note.related;
+  return new Set([
+    ...findGlobalSlugsInBody(note.summary),
+    ...findGlobalSlugsInRelated(fmRelated)
+  ]);
+}
+function appendExpansion(expansions, slug, body, charsUsed) {
+  const remaining = EXPANSION_BUDGET_CHARS - charsUsed;
+  if (body.length <= remaining) {
+    expansions.push({ slug, scope: "global", body, truncated: false });
+    return { charsUsed: charsUsed + body.length, truncated: false };
+  }
+  expansions.push({ slug, scope: "global", body: body.slice(0, remaining), truncated: true });
+  return { charsUsed: EXPANSION_BUDGET_CHARS, truncated: true };
+}
+function pushBudgetExceeded(expansions, slug) {
+  expansions.push({ slug, scope: "global", body: "", truncated: true });
+}
+function expandLinks(cfg, results) {
+  if (!cfg.global)
+    return { results };
+  const globalPath = cfg.global.path;
+  let charsUsed = 0;
+  let truncatedFlag = false;
+  const out = [];
+  for (const note of results) {
+    const expansions = [];
+    for (const slug of collectGlobalSlugs(note)) {
+      if (charsUsed >= EXPANSION_BUDGET_CHARS) {
+        pushBudgetExceeded(expansions, slug);
+        truncatedFlag = true;
+        continue;
+      }
+      const body = readGlobalNoteBody(globalPath, slug);
+      if (body === null)
+        continue;
+      const r = appendExpansion(expansions, slug, body, charsUsed);
+      charsUsed = r.charsUsed;
+      if (r.truncated)
+        truncatedFlag = true;
+    }
+    out.push(expansions.length > 0 ? { ...note, expanded_links: expansions } : note);
+  }
+  return truncatedFlag ? { results: out, warning: TRUNCATION_WARNING } : { results: out };
+}
+async function expandLinksAsync(cfg, results, noteAccess2) {
+  if (!cfg.global)
+    return { results };
+  const globalPath = cfg.global.path;
+  let charsUsed = 0;
+  let truncatedFlag = false;
+  const out = [];
+  for (const note of results) {
+    const expansions = [];
+    for (const slug of collectGlobalSlugs(note)) {
+      if (charsUsed >= EXPANSION_BUDGET_CHARS) {
+        pushBudgetExceeded(expansions, slug);
+        truncatedFlag = true;
+        continue;
+      }
+      const body = await readGlobalNoteBodyVia(globalPath, slug, noteAccess2);
+      if (body === null)
+        continue;
+      const r = appendExpansion(expansions, slug, body, charsUsed);
+      charsUsed = r.charsUsed;
+      if (r.truncated)
+        truncatedFlag = true;
+    }
+    out.push(expansions.length > 0 ? { ...note, expanded_links: expansions } : note);
+  }
+  return truncatedFlag ? { results: out, warning: TRUNCATION_WARNING } : { results: out };
+}
+var WIKILINK_REGEX, TRUNCATION_WARNING;
+var init_expansion = __esm(() => {
   init_utils();
+  init_conventions();
+  init_indexing();
+  init_storage();
+  init_embeddings();
+  WIKILINK_REGEX = /\[\[([^\]]+)\]\]/g;
+  TRUNCATION_WARNING = `Expansion budget (${EXPANSION_BUDGET_CHARS} chars) reached; some [[global:...]] references returned truncated or empty.`;
+});
+
+// src/core/vault/query/query.ts
+import { existsSync as existsSync22, readFileSync as readFileSync22, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join24 } from "node:path";
+function sanitize(opts) {
+  const limit = Math.min(Math.max(1, Math.floor(opts.limit ?? DEFAULT_LIMIT2)), MAX_LIMIT);
+  return {
+    query: opts.query.trim(),
+    limit,
+    scope: opts.scope ?? "both",
+    expand: opts.expand ?? true
+  };
+}
+function indexEntryToResult(filename, entry, vaultLocalPath, vaultGlobalPath, score) {
+  const root = entry.scope === "global" ? vaultGlobalPath ?? vaultLocalPath : vaultLocalPath;
+  return {
+    filename,
+    folder: entry.folder,
+    path: join24(root, entry.folder, `${filename}.md`),
+    scope: entry.scope,
+    score,
+    summary: entry.summary
+  };
+}
+function topK(index, queryVec, limit, scope, cfg) {
+  const localPath = cfg.local.path;
+  const globalPath = cfg.global ? cfg.global.path : null;
+  const scored = [];
+  for (const [filename, entry] of Object.entries(index.entries)) {
+    if (scope !== "both" && entry.scope !== scope)
+      continue;
+    if (entry.vector.length !== queryVec.length)
+      continue;
+    const score = cosine(queryVec, entry.vector);
+    if (!Number.isFinite(score))
+      continue;
+    scored.push({ filename, score, entry });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit).map((s) => indexEntryToResult(s.filename, s.entry, localPath, globalPath, s.score));
+}
+function appendLog2(vaultPath, kind, detail = "") {
+  const ts4 = new Date().toISOString();
+  const line = `- ${ts4}  ${kind}${detail ? `  ${detail}` : ""}  source: code-analysis
+`;
+  const logPath = join24(vaultPath, "_log.md");
+  try {
+    if (!existsSync22(logPath)) {
+      writeFileSync13(logPath, `# Vault log
+
+${line}`, "utf-8");
+      return;
+    }
+    const content = readFileSync22(logPath, "utf-8");
+    const needsNl = content.length > 0 && !content.endsWith(`
+`);
+    writeFileSync13(logPath, content + (needsNl ? `
+` : "") + line, "utf-8");
+  } catch (err) {
+    logForDebugging(`[query] log append failed: ${errorMessage(err)}`, {
+      level: "warn"
+    });
+  }
+}
+async function ensureIndex(cfg) {
+  const existing = loadIndex(cfg.local.path);
+  if (existing && Object.keys(existing.entries).length > 0)
+    return existing;
+  const fresh = await buildIndex(cfg);
+  appendLog2(cfg.local.path, "embeddings-built", `${Object.keys(fresh.entries).length} notes`);
+  return fresh;
+}
+function emptyEnvelope(error) {
+  return {
+    ok: error === undefined,
+    results: [],
+    cacheHit: false,
+    servedAt: new Date().toISOString(),
+    ...error ? { error } : {}
+  };
+}
+async function vaultQuery(cfg, opts, extras = {}) {
+  try {
+    if (!opts.query || !opts.query.trim()) {
+      return emptyEnvelope("empty query");
+    }
+    const sanitized = sanitize(opts);
+    const vaultPath = cfg.vaultPath ?? cfg.local.path;
+    const cacheKey = hashQuery(sanitized.query);
+    return await coalesceCall(cacheKey, async () => {
+      const index = await ensureIndex(cfg);
+      if (Object.keys(index.entries).length === 0) {
+        return {
+          ...emptyEnvelope(),
+          warnings: ["vault has no notes yet"]
+        };
+      }
+      const vec = await embedText(sanitized.query);
+      if (isZeroVector(vec))
+        return emptyEnvelope("embedding failed");
+      const cached = lookup(vaultPath, sanitized.query, vec);
+      if (cached) {
+        touch(vaultPath, cached.queryHash);
+        const filtered = sanitized.scope === "both" ? cached.topK : cached.topK.filter((n) => n.scope === sanitized.scope);
+        return {
+          ok: true,
+          results: filtered.slice(0, sanitized.limit),
+          cacheHit: true,
+          servedAt: new Date().toISOString()
+        };
+      }
+      const k = topK(index, vec, sanitized.limit, sanitized.scope, cfg);
+      let results = k;
+      const warnings = [];
+      if (sanitized.expand) {
+        const expanded = extras.noteAccess ? await expandLinksAsync(cfg, k, extras.noteAccess) : expandLinks(cfg, k);
+        results = expanded.results;
+        if (expanded.warning)
+          warnings.push(expanded.warning);
+      }
+      fill(vaultPath, sanitized.query, vec, results);
+      return {
+        ok: true,
+        results,
+        cacheHit: false,
+        servedAt: new Date().toISOString(),
+        ...warnings.length > 0 ? { warnings } : {}
+      };
+    });
+  } catch (err) {
+    logForDebugging(`[query] unexpected: ${errorMessage(err)}`, { level: "warn" });
+    return emptyEnvelope(errorMessage(err));
+  }
+}
+var DEFAULT_LIMIT2 = 5, MAX_LIMIT = 20;
+var init_query = __esm(() => {
+  init_utils();
+  init_cacheAside();
+  init_embeddings();
+  init_expansion();
+  init_noteIndex();
+});
+
+// src/core/vault/query/index.ts
+var exports_query = {};
+__export(exports_query, {
+  vaultQuery: () => vaultQuery,
+  updateEntry: () => updateEntry,
+  setEmbedder: () => setEmbedder,
+  safeMtimeMs: () => safeMtimeMs,
+  removeEntry: () => removeEntry,
+  lookup: () => lookup,
+  loadIndex: () => loadIndex,
+  isZeroVector: () => isZeroVector,
+  hashQuery: () => hashQuery,
+  fill: () => fill,
+  expandLinksAsync: () => expandLinksAsync,
+  expandLinks: () => expandLinks,
+  embedText: () => embedText,
+  cosine: () => cosine,
+  coalesceCall: () => coalesceCall,
+  clearCoalescer: () => clearCoalescer,
+  buildIndex: () => buildIndex,
+  EXPANSION_BUDGET_CHARS: () => EXPANSION_BUDGET_CHARS,
+  EMBEDDING_MODEL: () => EMBEDDING_MODEL,
+  EMBEDDING_DIM: () => EMBEDDING_DIM,
+  CACHE_HIT_THRESHOLD: () => CACHE_HIT_THRESHOLD
+});
+var init_query2 = __esm(() => {
+  init_query();
   init_embeddings();
+  init_noteIndex();
+  init_cacheAside();
+  init_expansion();
 });
 
 // src/vault/mapper/pipeline-phases.ts
 import {
-  existsSync as existsSync19,
-  mkdirSync as mkdirSync13,
-  readFileSync as readFileSync20,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync14,
+  readFileSync as readFileSync23,
   readdirSync as readdirSync10,
-  renameSync as renameSync2,
-  writeFileSync as writeFileSync12
+  renameSync as renameSync3,
+  writeFileSync as writeFileSync14
 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join25 } from "node:path";
 async function analyzeModules(candidates, parser2, opts, report, progress) {
   const exportsByModule = new Map;
   const importsByModule = new Map;
@@ -15485,9 +15965,9 @@ async function embedOnEmit(cfg, opts, report) {
   if (!embedOptIn || report.modules.emitted === 0)
     return;
   try {
-    const { buildIndex: buildIndex2 } = await Promise.resolve().then(() => (init_query(), exports_query));
+    const { buildIndex: buildIndex2 } = await Promise.resolve().then(() => (init_query2(), exports_query));
     const idx = await buildIndex2(cfg);
-    appendLog2(cfg.vaultPath, "embeddings-updated", `${Object.keys(idx.entries).length} notes`, "code-analysis");
+    appendLog3(cfg.vaultPath, "embeddings-updated", `${Object.keys(idx.entries).length} notes`, "code-analysis");
   } catch (err) {
     report.errors.push(`embed-on-emit: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -15495,11 +15975,11 @@ async function embedOnEmit(cfg, opts, report) {
 function executeArchiveOps(vaultPath, archiveOps, report) {
   for (const op of archiveOps) {
     try {
-      const fromPath = join21(vaultPath, op.from);
-      const toPath = join21(vaultPath, op.to);
-      if (existsSync19(fromPath)) {
-        mkdirSync13(join21(vaultPath, "archive"), { recursive: true });
-        renameSync2(fromPath, toPath);
+      const fromPath = join25(vaultPath, op.from);
+      const toPath = join25(vaultPath, op.to);
+      if (existsSync23(fromPath)) {
+        mkdirSync14(join25(vaultPath, "archive"), { recursive: true });
+        renameSync3(fromPath, toPath);
         report.modules.archived++;
       }
     } catch (err) {
@@ -15511,11 +15991,11 @@ function finalizeLog(vaultPath, descriptors, report) {
   const logEntry = buildLogEntry(report);
   const llmContentPersisted = descriptors.some((d) => !d.staticOnly && !d.fallback);
   const logSource = llmContentPersisted ? "llm-inference" : "code-analysis";
-  appendLog2(vaultPath, report.errors.some((e) => e.startsWith("write-error:")) ? "map-aborted" : "map-complete", logEntry, logSource);
+  appendLog3(vaultPath, report.errors.some((e) => e.startsWith("write-error:")) ? "map-aborted" : "map-complete", logEntry, logSource);
 }
 function readExistingModules(vaultPath) {
-  const knowledgeDir = join21(vaultPath, "knowledge");
-  if (!existsSync19(knowledgeDir))
+  const knowledgeDir = join25(vaultPath, "knowledge");
+  if (!existsSync23(knowledgeDir))
     return [];
   const results = [];
   try {
@@ -15524,7 +16004,7 @@ function readExistingModules(vaultPath) {
       if (!file.startsWith("module-") || !file.endsWith(".md"))
         continue;
       try {
-        const content = readFileSync20(join21(knowledgeDir, file), "utf-8");
+        const content = readFileSync23(join25(knowledgeDir, file), "utf-8");
         const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
         if (!fmMatch)
           continue;
@@ -15557,22 +16037,22 @@ function extractFmArray(fm, key) {
   }
   return [];
 }
-function appendLog2(vaultPath, kind, detail, source = "code-analysis") {
+function appendLog3(vaultPath, kind, detail, source = "code-analysis") {
   const ts4 = new Date().toISOString();
   const line = `- ${ts4}  ${kind}  ${detail}  source: ${source}
 `;
-  const logPath = join21(vaultPath, "_log.md");
-  mkdirSync13(vaultPath, { recursive: true });
-  if (!existsSync19(logPath)) {
-    writeFileSync12(logPath, `# Vault log
+  const logPath = join25(vaultPath, "_log.md");
+  mkdirSync14(vaultPath, { recursive: true });
+  if (!existsSync23(logPath)) {
+    writeFileSync14(logPath, `# Vault log
 
 ${line}`, "utf-8");
     return;
   }
-  const content = readFileSync20(logPath, "utf-8");
+  const content = readFileSync23(logPath, "utf-8");
   const needsNl = content.length > 0 && !content.endsWith(`
 `);
-  writeFileSync12(logPath, content + (needsNl ? `
+  writeFileSync14(logPath, content + (needsNl ? `
 ` : "") + line, "utf-8");
 }
 function buildLogEntry(report) {
@@ -15617,7 +16097,7 @@ async function runMapping(cfg, indexResult, opts) {
     const candidates = discoverModules({ projectRoot: cfg.projectRoot, indexResult });
     report.modules.discovered = candidates.length;
     if (candidates.length === 0) {
-      appendLog2(cfg.vaultPath, "map-complete", "0 modules discovered — nothing to map");
+      appendLog3(cfg.vaultPath, "map-complete", "0 modules discovered — nothing to map");
       return report;
     }
     progress({ phase: "analyze", current: 0, total: candidates.length });
@@ -15660,7 +16140,7 @@ async function runMapping(cfg, indexResult, opts) {
     finalizeLog(cfg.vaultPath, descriptors, report);
   } catch (err) {
     report.errors.push(`pipeline-error: ${err instanceof Error ? err.message : String(err)}`);
-    appendLog2(cfg.vaultPath, "map-aborted", `pipeline-error: ${err instanceof Error ? err.message : String(err)}`);
+    appendLog3(cfg.vaultPath, "map-aborted", `pipeline-error: ${err instanceof Error ? err.message : String(err)}`);
   }
   return report;
 }
@@ -15683,18 +16163,18 @@ var init_mapper = __esm(() => {
 });
 
 // src/config/settings.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync15, readFileSync as readFileSync25, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync16, readFileSync as readFileSync28, writeFileSync as writeFileSync17 } from "node:fs";
 import { dirname as dirname10 } from "node:path";
 function defaultSettings() {
   return { version: SETTINGS_VERSION };
 }
 function loadSettings() {
   const path4 = settingsPath();
-  if (!existsSync24(path4))
+  if (!existsSync28(path4))
     return defaultSettings();
   let raw;
   try {
-    raw = readFileSync25(path4, "utf8");
+    raw = readFileSync28(path4, "utf8");
   } catch {
     return defaultSettings();
   }
@@ -15734,13 +16214,13 @@ function loadSettings() {
 function saveSettings(settings) {
   const path4 = settingsPath();
   const dir = dirname10(path4);
-  if (!existsSync24(dir)) {
-    mkdirSync15(dir, { recursive: true, mode: 448 });
+  if (!existsSync28(dir)) {
+    mkdirSync16(dir, { recursive: true, mode: 448 });
   }
   const toWrite = { ...settings, version: SETTINGS_VERSION };
   const body = `${JSON.stringify(toWrite, null, 2)}
 `;
-  writeFileSync15(path4, body, { mode: 384 });
+  writeFileSync17(path4, body, { mode: 384 });
 }
 var SETTINGS_VERSION = 1;
 var init_settings = __esm(() => {
@@ -19714,15 +20194,15 @@ var init_zod = __esm(() => {
 });
 
 // src/vault/lint.ts
-import { existsSync as existsSync34, readFileSync as readFileSync29, readdirSync as readdirSync14, statSync as statSync10, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join38, relative as relative6 } from "node:path";
+import { existsSync as existsSync38, readFileSync as readFileSync32, readdirSync as readdirSync14, statSync as statSync10, writeFileSync as writeFileSync21 } from "node:fs";
+import { join as join42, relative as relative6 } from "node:path";
 function toPosix(p) {
   return p.split("\\").join("/");
 }
 function walkFolder(vaultPath, folder) {
   const out = [];
-  const folderAbs = join38(vaultPath, folder);
-  if (!existsSync34(folderAbs))
+  const folderAbs = join42(vaultPath, folder);
+  if (!existsSync38(folderAbs))
     return out;
   const walk = (dir) => {
     let entries;
@@ -19732,7 +20212,7 @@ function walkFolder(vaultPath, folder) {
       return;
     }
     for (const entry of entries) {
-      const abs = join38(dir, entry);
+      const abs = join42(dir, entry);
       let s;
       try {
         s = statSync10(abs);
@@ -19751,7 +20231,7 @@ function walkFolder(vaultPath, folder) {
         continue;
       let raw = "";
       try {
-        raw = readFileSync29(abs, "utf-8");
+        raw = readFileSync32(abs, "utf-8");
       } catch {
         continue;
       }
@@ -19843,8 +20323,8 @@ async function lintVault(cfg, opts = {}) {
   for (const n of notes)
     basenameSet.add(n.basename);
   for (const folder of NOTE_FOLDERS) {
-    const idx = join38(vaultPath, folder, "_index.md");
-    if (!existsSync34(idx)) {
+    const idx = join42(vaultPath, folder, "_index.md");
+    if (!existsSync38(idx)) {
       issues.push({
         kind: "missing-index",
         file: `${folder}/_index.md`,
@@ -19935,8 +20415,8 @@ async function lintVault(cfg, opts = {}) {
     const srcPath = note.frontmatter.source_path;
     const lastVerified = note.frontmatter.last_verified;
     if (typeof srcPath === "string" && srcPath.trim() !== "" && lastVerified != null) {
-      const srcAbs = join38(cfg.projectRoot, srcPath);
-      if (existsSync34(srcAbs)) {
+      const srcAbs = join42(cfg.projectRoot, srcPath);
+      if (existsSync38(srcAbs)) {
         let srcMtime = null;
         try {
           srcMtime = statSync10(srcAbs).mtime;
@@ -19962,9 +20442,9 @@ async function lintVault(cfg, opts = {}) {
         return;
       if (issue.kind === "missing-index") {
         const [folder] = issue.file.split("/");
-        const dest = join38(vaultPath, folder, "_index.md");
+        const dest = join42(vaultPath, folder, "_index.md");
         try {
-          writeFileSync19(dest, subfolderIndexContent(folder), "utf-8");
+          writeFileSync21(dest, subfolderIndexContent(folder), "utf-8");
           if (!fixed.includes(issue.file))
             fixed.push(issue.file);
           resolvedIssueIds.add(idx);
@@ -19972,13 +20452,13 @@ async function lintVault(cfg, opts = {}) {
         return;
       }
       if (issue.kind === "frontmatter") {
-        const abs = join38(vaultPath, issue.file);
+        const abs = join42(vaultPath, issue.file);
         try {
-          const raw = readFileSync29(abs, "utf-8");
+          const raw = readFileSync32(abs, "utf-8");
           const parsed = parseFrontmatter(raw);
           const rewritten = `${serializeFrontmatter(parsed.frontmatter)}${parsed.content}`;
           if (rewritten !== raw) {
-            writeFileSync19(abs, rewritten, "utf-8");
+            writeFileSync21(abs, rewritten, "utf-8");
             if (!fixed.includes(issue.file))
               fixed.push(issue.file);
             resolvedIssueIds.add(idx);
@@ -20003,7 +20483,8 @@ async function lintVault(cfg, opts = {}) {
 var META_FILENAMES, WIKILINK_RE3, LINK_FRONTMATTER_FIELDS;
 var init_lint = __esm(() => {
   init_conventions();
-  init_utils();
+  init_conventions();
+  init_indexing();
   init_storage();
   init_storage();
   META_FILENAMES = new Set(["_index.md", "_log.md", "_conventions.md"]);
@@ -20024,446 +20505,16 @@ function detectProvider(explicitProvider) {
   return "claude";
 }
 
-// src/vault/query/cacheAside.ts
-import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync35, mkdirSync as mkdirSync19, readFileSync as readFileSync30, renameSync as renameSync4, writeFileSync as writeFileSync20 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join39 } from "node:path";
-function cachePath2(vaultPath) {
-  return join39(vaultPath, ".cache", CACHE_FILENAME);
-}
-function emptyCache() {
-  return { schemaVersion: SCHEMA_VERSION4, entries: [] };
-}
-function isValidCache(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const v = value;
-  return v.schemaVersion === SCHEMA_VERSION4 && Array.isArray(v.entries);
-}
-function loadCacheFile(vaultPath) {
-  const path4 = cachePath2(vaultPath);
-  if (!existsSync35(path4))
-    return emptyCache();
-  try {
-    const raw = JSON.parse(readFileSync30(path4, "utf-8"));
-    if (!isValidCache(raw))
-      return emptyCache();
-    return raw;
-  } catch (err) {
-    logForDebugging(`[query/cache] load failed (resetting): ${errorMessage(err)}`, {
-      level: "warn"
-    });
-    return emptyCache();
-  }
-}
-function persistCacheFile(vaultPath, file) {
-  const dir = join39(vaultPath, ".cache");
-  mkdirSync19(dir, { recursive: true });
-  const gi = join39(dir, ".gitignore");
-  if (!existsSync35(gi)) {
-    try {
-      writeFileSync20(gi, `*
-!.gitignore
-`, "utf-8");
-    } catch {}
-  }
-  const tmp = join39(tmpdir2(), `bridgeai-qcache-${process.pid}-${Date.now()}.json`);
-  try {
-    writeFileSync20(tmp, JSON.stringify(file), "utf-8");
-    renameSync4(tmp, cachePath2(vaultPath));
-  } catch (err) {
-    logForDebugging(`[query/cache] persist failed: ${errorMessage(err)}`, { level: "warn" });
-  }
-}
-function hashQuery(query) {
-  return createHash5("sha256").update(query.trim().toLowerCase()).digest("hex");
-}
-function lookup(vaultPath, _query, vec) {
-  if (isZeroVector(vec))
-    return null;
-  const file = loadCacheFile(vaultPath);
-  if (file.entries.length === 0)
-    return null;
-  let best = null;
-  for (const entry of file.entries) {
-    const score = cosine(vec, entry.vector);
-    if (score < CACHE_HIT_THRESHOLD)
-      continue;
-    if (best === null || score > best.score)
-      best = { entry, score };
-  }
-  if (!best)
-    return null;
-  const verifiedMs = Date.parse(best.entry.lastVerified);
-  if (!Number.isFinite(verifiedMs))
-    return null;
-  for (const note of best.entry.topK) {
-    if (safeMtimeMs(note.path) > verifiedMs)
-      return null;
-  }
-  return best.entry;
-}
-function fill(vaultPath, query, vec, topK) {
-  if (isZeroVector(vec))
-    return;
-  const file = loadCacheFile(vaultPath);
-  const nowMs = Date.now();
-  const nowStr = new Date(nowMs).toISOString();
-  const maxMtimeMs = topK.reduce((m, n) => Math.max(m, safeMtimeMs(n.path)), 0);
-  const lastVerifiedMs = maxMtimeMs > 0 ? Math.max(nowMs, maxMtimeMs + 1) : nowMs;
-  const lastVerifiedStr = new Date(lastVerifiedMs).toISOString();
-  const queryHash = hashQuery(query);
-  const existingIdx = file.entries.findIndex((e) => e.queryHash === queryHash);
-  const entry = {
-    queryHash,
-    query,
-    vector: vec,
-    topK,
-    lastVerified: lastVerifiedStr,
-    lastQueried: nowStr
-  };
-  if (existingIdx >= 0) {
-    file.entries[existingIdx] = entry;
-  } else {
-    file.entries.push(entry);
-  }
-  if (file.entries.length > MAX_ENTRIES) {
-    file.entries.sort((a, b) => a.lastQueried.localeCompare(b.lastQueried));
-    file.entries = file.entries.slice(file.entries.length - MAX_ENTRIES);
-  }
-  persistCacheFile(vaultPath, file);
-}
-function touch(vaultPath, queryHash) {
-  const file = loadCacheFile(vaultPath);
-  const idx = file.entries.findIndex((e) => e.queryHash === queryHash);
-  if (idx < 0)
-    return;
-  file.entries[idx].lastQueried = new Date().toISOString();
-  persistCacheFile(vaultPath, file);
-}
-function coalesceCall(key, factory) {
-  const existing = inFlight.get(key);
-  if (existing)
-    return existing;
-  const fresh = factory().finally(() => {
-    inFlight.delete(key);
-  });
-  inFlight.set(key, fresh);
-  return fresh;
-}
-var CACHE_FILENAME = "query-cache.json", SCHEMA_VERSION4 = "1", MAX_ENTRIES = 100, inFlight;
-var init_cacheAside = __esm(() => {
-  init_utils();
-  init_utils();
-  init_embeddings();
-  init_query();
-  inFlight = new Map;
-});
-
-// src/vault/query/expansion.ts
-import { existsSync as existsSync36, readFileSync as readFileSync31 } from "node:fs";
-import { join as join40 } from "node:path";
-function findGlobalSlugsInBody(text) {
-  const out = [];
-  let match;
-  while ((match = WIKILINK_REGEX.exec(text)) !== null) {
-    const raw = match[1];
-    if (!raw)
-      continue;
-    const target = parseWikiLinkTarget(raw);
-    if (target.vault === "global")
-      out.push(target.slug);
-  }
-  return out;
-}
-function findGlobalSlugsInRelated(related) {
-  if (!Array.isArray(related))
-    return [];
-  const out = [];
-  for (const r of related) {
-    if (typeof r !== "string")
-      continue;
-    const stripped = r.replace(/^\[\[|\]\]$/g, "");
-    const target = parseWikiLinkTarget(stripped);
-    if (target.vault === "global")
-      out.push(target.slug);
-  }
-  return out;
-}
-function readGlobalNoteBody(globalPath, slug) {
-  for (const folder of NOTE_FOLDERS) {
-    const p = join40(globalPath, folder, `${slug}.md`);
-    if (!existsSync36(p))
-      continue;
-    try {
-      const raw = readFileSync31(p, "utf-8");
-      const parsed = parseFrontmatter(raw);
-      return parsed.content ?? "";
-    } catch (err) {
-      logForDebugging(`[query/expansion] read failed ${p}: ${errorMessage(err)}`, {
-        level: "warn"
-      });
-      return null;
-    }
-  }
-  return null;
-}
-async function readGlobalNoteBodyVia(globalPath, slug, noteAccess2) {
-  for (const folder of NOTE_FOLDERS) {
-    const p = join40(globalPath, folder, `${slug}.md`);
-    if (!existsSync36(p))
-      continue;
-    try {
-      const raw = await noteAccess2.readUserNote(p);
-      if (!raw)
-        return "";
-      const parsed = parseFrontmatter(raw);
-      return parsed.content ?? "";
-    } catch (err) {
-      logForDebugging(`[query/expansion] read failed ${p}: ${errorMessage(err)}`, {
-        level: "warn"
-      });
-      return null;
-    }
-  }
-  return null;
-}
-function collectGlobalSlugs(note) {
-  const fmRelated = note.related;
-  return new Set([
-    ...findGlobalSlugsInBody(note.summary),
-    ...findGlobalSlugsInRelated(fmRelated)
-  ]);
-}
-function appendExpansion(expansions, slug, body, charsUsed) {
-  const remaining = EXPANSION_BUDGET_CHARS - charsUsed;
-  if (body.length <= remaining) {
-    expansions.push({ slug, scope: "global", body, truncated: false });
-    return { charsUsed: charsUsed + body.length, truncated: false };
-  }
-  expansions.push({ slug, scope: "global", body: body.slice(0, remaining), truncated: true });
-  return { charsUsed: EXPANSION_BUDGET_CHARS, truncated: true };
-}
-function pushBudgetExceeded(expansions, slug) {
-  expansions.push({ slug, scope: "global", body: "", truncated: true });
-}
-function expandLinks(cfg, results) {
-  if (!cfg.global)
-    return { results };
-  const globalPath = cfg.global.path;
-  let charsUsed = 0;
-  let truncatedFlag = false;
-  const out = [];
-  for (const note of results) {
-    const expansions = [];
-    for (const slug of collectGlobalSlugs(note)) {
-      if (charsUsed >= EXPANSION_BUDGET_CHARS) {
-        pushBudgetExceeded(expansions, slug);
-        truncatedFlag = true;
-        continue;
-      }
-      const body = readGlobalNoteBody(globalPath, slug);
-      if (body === null)
-        continue;
-      const r = appendExpansion(expansions, slug, body, charsUsed);
-      charsUsed = r.charsUsed;
-      if (r.truncated)
-        truncatedFlag = true;
-    }
-    out.push(expansions.length > 0 ? { ...note, expanded_links: expansions } : note);
-  }
-  return truncatedFlag ? { results: out, warning: TRUNCATION_WARNING } : { results: out };
-}
-async function expandLinksAsync(cfg, results, noteAccess2) {
-  if (!cfg.global)
-    return { results };
-  const globalPath = cfg.global.path;
-  let charsUsed = 0;
-  let truncatedFlag = false;
-  const out = [];
-  for (const note of results) {
-    const expansions = [];
-    for (const slug of collectGlobalSlugs(note)) {
-      if (charsUsed >= EXPANSION_BUDGET_CHARS) {
-        pushBudgetExceeded(expansions, slug);
-        truncatedFlag = true;
-        continue;
-      }
-      const body = await readGlobalNoteBodyVia(globalPath, slug, noteAccess2);
-      if (body === null)
-        continue;
-      const r = appendExpansion(expansions, slug, body, charsUsed);
-      charsUsed = r.charsUsed;
-      if (r.truncated)
-        truncatedFlag = true;
-    }
-    out.push(expansions.length > 0 ? { ...note, expanded_links: expansions } : note);
-  }
-  return truncatedFlag ? { results: out, warning: TRUNCATION_WARNING } : { results: out };
-}
-var WIKILINK_REGEX, TRUNCATION_WARNING;
-var init_expansion = __esm(() => {
-  init_utils();
-  init_storage();
-  init_embeddings();
-  WIKILINK_REGEX = /\[\[([^\]]+)\]\]/g;
-  TRUNCATION_WARNING = `Expansion budget (${EXPANSION_BUDGET_CHARS} chars) reached; some [[global:...]] references returned truncated or empty.`;
-});
-
-// src/vault/query/query.ts
-import { existsSync as existsSync37, readFileSync as readFileSync32, writeFileSync as writeFileSync21 } from "node:fs";
-import { join as join41 } from "node:path";
-function sanitize(opts) {
-  const limit = Math.min(Math.max(1, Math.floor(opts.limit ?? DEFAULT_LIMIT4)), MAX_LIMIT2);
-  return {
-    query: opts.query.trim(),
-    limit,
-    scope: opts.scope ?? "both",
-    expand: opts.expand ?? true
-  };
-}
-function indexEntryToResult(filename, entry, vaultLocalPath, vaultGlobalPath, score) {
-  const root = entry.scope === "global" ? vaultGlobalPath ?? vaultLocalPath : vaultLocalPath;
-  return {
-    filename,
-    folder: entry.folder,
-    path: join41(root, entry.folder, `${filename}.md`),
-    scope: entry.scope,
-    score,
-    summary: entry.summary
-  };
-}
-function topK(index, queryVec, limit, scope, cfg) {
-  const localPath = cfg.local.path;
-  const globalPath = cfg.global ? cfg.global.path : null;
-  const scored = [];
-  for (const [filename, entry] of Object.entries(index.entries)) {
-    if (scope !== "both" && entry.scope !== scope)
-      continue;
-    if (entry.vector.length !== queryVec.length)
-      continue;
-    const score = cosine(queryVec, entry.vector);
-    if (!Number.isFinite(score))
-      continue;
-    scored.push({ filename, score, entry });
-  }
-  scored.sort((a, b) => b.score - a.score);
-  return scored.slice(0, limit).map((s) => indexEntryToResult(s.filename, s.entry, localPath, globalPath, s.score));
-}
-function appendLog3(vaultPath, kind, detail = "") {
-  const ts4 = new Date().toISOString();
-  const line = `- ${ts4}  ${kind}${detail ? `  ${detail}` : ""}  source: code-analysis
-`;
-  const logPath = join41(vaultPath, "_log.md");
-  try {
-    if (!existsSync37(logPath)) {
-      writeFileSync21(logPath, `# Vault log
-
-${line}`, "utf-8");
-      return;
-    }
-    const content = readFileSync32(logPath, "utf-8");
-    const needsNl = content.length > 0 && !content.endsWith(`
-`);
-    writeFileSync21(logPath, content + (needsNl ? `
-` : "") + line, "utf-8");
-  } catch (err) {
-    logForDebugging(`[query] log append failed: ${errorMessage(err)}`, {
-      level: "warn"
-    });
-  }
-}
-async function ensureIndex(cfg) {
-  const existing = loadIndex(cfg.local.path);
-  if (existing && Object.keys(existing.entries).length > 0)
-    return existing;
-  const fresh = await buildIndex(cfg);
-  appendLog3(cfg.local.path, "embeddings-built", `${Object.keys(fresh.entries).length} notes`);
-  return fresh;
-}
-function emptyEnvelope(error) {
-  return {
-    ok: error === undefined,
-    results: [],
-    cacheHit: false,
-    servedAt: new Date().toISOString(),
-    ...error ? { error } : {}
-  };
-}
-async function vaultQuery(cfg, opts, extras = {}) {
-  try {
-    if (!opts.query || !opts.query.trim()) {
-      return emptyEnvelope("empty query");
-    }
-    const sanitized = sanitize(opts);
-    const vaultPath = cfg.vaultPath ?? cfg.local.path;
-    const cacheKey = hashQuery(sanitized.query);
-    return await coalesceCall(cacheKey, async () => {
-      const index = await ensureIndex(cfg);
-      if (Object.keys(index.entries).length === 0) {
-        return {
-          ...emptyEnvelope(),
-          warnings: ["vault has no notes yet"]
-        };
-      }
-      const vec = await embedText(sanitized.query);
-      if (isZeroVector(vec))
-        return emptyEnvelope("embedding failed");
-      const cached = lookup(vaultPath, sanitized.query, vec);
-      if (cached) {
-        touch(vaultPath, cached.queryHash);
-        const filtered = sanitized.scope === "both" ? cached.topK : cached.topK.filter((n) => n.scope === sanitized.scope);
-        return {
-          ok: true,
-          results: filtered.slice(0, sanitized.limit),
-          cacheHit: true,
-          servedAt: new Date().toISOString()
-        };
-      }
-      const k = topK(index, vec, sanitized.limit, sanitized.scope, cfg);
-      let results = k;
-      const warnings = [];
-      if (sanitized.expand) {
-        const expanded = extras.noteAccess ? await expandLinksAsync(cfg, k, extras.noteAccess) : expandLinks(cfg, k);
-        results = expanded.results;
-        if (expanded.warning)
-          warnings.push(expanded.warning);
-      }
-      fill(vaultPath, sanitized.query, vec, results);
-      return {
-        ok: true,
-        results,
-        cacheHit: false,
-        servedAt: new Date().toISOString(),
-        ...warnings.length > 0 ? { warnings } : {}
-      };
-    });
-  } catch (err) {
-    logForDebugging(`[query] unexpected: ${errorMessage(err)}`, { level: "warn" });
-    return emptyEnvelope(errorMessage(err));
-  }
-}
-var DEFAULT_LIMIT4 = 5, MAX_LIMIT2 = 20;
-var init_query2 = __esm(() => {
-  init_utils();
-  init_utils();
-  init_cacheAside();
-  init_embeddings();
-  init_expansion();
-  init_query();
-});
-
 // src/vault/index.ts
 import { readFileSync as readFileSync33 } from "node:fs";
-import { basename as basename11, join as join42 } from "node:path";
+import { basename as basename11, join as join43 } from "node:path";
 function slugify(input) {
   const s = input.toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
   return s || "untitled";
 }
 function toInternal(config) {
   const provider = detectProvider();
-  const vaultPath = join42(config.root, ".anchorkit", "vault");
+  const vaultPath = join43(config.root, ".anchorkit", "vault");
   return {
     local: { path: vaultPath },
     global: config.globalRoot ? { path: config.globalRoot } : null,
@@ -20541,7 +20592,7 @@ function createVault(config) {
       if (!result.ok) {
         throw new Error(`vault.write failed: ${result.violations.map((v) => `${v.field}: expected ${String(v.expected)}, got ${String(v.got)} (${v.rule})`).join("; ")}`);
       }
-      const absPath = join42(internal.local.path, result.path);
+      const absPath = join43(internal.local.path, result.path);
       const written = readNoteFile(absPath);
       if (!written) {
         throw new Error(`vault.write succeeded but cannot re-read ${absPath}`);
@@ -20597,7 +20648,8 @@ function createVault(config) {
   };
 }
 var init_vault = __esm(() => {
-  init_utils();
+  init_conventions();
+  init_indexing();
   init_lint();
   init_query2();
   init_storage();
@@ -22492,7 +22544,7 @@ var require_core2 = __commonJS((exports, module) => {
     return match && match.index === 0;
   }
   var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-  function join43(regexps, separator = "|") {
+  function join44(regexps, separator = "|") {
     let numCaptures = 0;
     return regexps.map((regex) => {
       numCaptures += 1;
@@ -22775,7 +22827,7 @@ var require_core2 = __commonJS((exports, module) => {
           this.exec = () => null;
         }
         const terminators = this.regexes.map((el) => el[1]);
-        this.matcherRe = langRe(join43(terminators), true);
+        this.matcherRe = langRe(join44(terminators), true);
         this.lastIndex = 0;
       }
       exec(s) {
@@ -76984,11 +77036,11 @@ Implement when the case demands — do not invent these:
 `;
 
 // src/vault/provider/formatters.ts
-import { existsSync as existsSync38, readFileSync as readFileSync34 } from "node:fs";
+import { existsSync as existsSync39, readFileSync as readFileSync34 } from "node:fs";
 import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync22 } from "node:fs";
-import { join as join43 } from "node:path";
+import { join as join44 } from "node:path";
 function isBridgeAiGenerated(filePath) {
-  if (!existsSync38(filePath))
+  if (!existsSync39(filePath))
     return false;
   try {
     const content = readFileSync34(filePath, "utf-8");
@@ -77015,8 +77067,8 @@ function buildProviderContent(vaultPath, _projectRoot) {
     "commands.md"
   ];
   for (const docFile of docFiles) {
-    const docPath = join43(vaultPath, docFile);
-    if (existsSync38(docPath)) {
+    const docPath = join44(vaultPath, docFile);
+    if (existsSync39(docPath)) {
       try {
         const content = readFileSync34(docPath, "utf-8");
         sections.push(content);
@@ -77029,15 +77081,15 @@ function buildProviderContent(vaultPath, _projectRoot) {
 `);
 }
 function formatForClaude(vaultPath, projectRoot) {
-  const filePath = join43(vaultPath, "CLAUDE.md");
+  const filePath = join44(vaultPath, "CLAUDE.md");
   const content = buildProviderContent(vaultPath, projectRoot);
   mkdirSync20(vaultPath, { recursive: true });
   writeFileSync22(filePath, content, "utf-8");
   return { filePath, skipped: false };
 }
 function formatForCursor(vaultPath, projectRoot) {
-  const filePath = join43(projectRoot, ".cursorrules");
-  if (existsSync38(filePath) && !isBridgeAiGenerated(filePath)) {
+  const filePath = join44(projectRoot, ".cursorrules");
+  if (existsSync39(filePath) && !isBridgeAiGenerated(filePath)) {
     return {
       filePath,
       skipped: true,
@@ -77049,9 +77101,9 @@ function formatForCursor(vaultPath, projectRoot) {
   return { filePath, skipped: false };
 }
 function formatForGemini(vaultPath, projectRoot) {
-  const geminiDir = join43(projectRoot, ".gemini");
-  const filePath = join43(geminiDir, "rules.md");
-  if (existsSync38(filePath) && !isBridgeAiGenerated(filePath)) {
+  const geminiDir = join44(projectRoot, ".gemini");
+  const filePath = join44(geminiDir, "rules.md");
+  if (existsSync39(filePath) && !isBridgeAiGenerated(filePath)) {
     return {
       filePath,
       skipped: true,
@@ -77079,10 +77131,10 @@ var BRIDGE_AI_MARKER = "<!-- bridge-ai generated -->";
 var init_formatters = () => {};
 
 // src/vault/state.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync21, readFileSync as readFileSync35, writeFileSync as writeFileSync23 } from "node:fs";
-import { join as join44 } from "node:path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync21, readFileSync as readFileSync35, writeFileSync as writeFileSync23 } from "node:fs";
+import { join as join45 } from "node:path";
 function statePath(vaultPath) {
-  return join44(vaultPath, STATE_FILE);
+  return join45(vaultPath, STATE_FILE);
 }
 function now() {
   return new Date().toISOString();
@@ -77202,7 +77254,7 @@ async function runMappingForOnboarding(projectRoot, options2) {
 var init_onboard = __esm(() => {
   init_config();
   init_storage();
-  init_indexer();
+  init_indexing();
   init_utils();
   init_formatters();
   init_storage();
@@ -79026,8 +79078,8 @@ var init_plan_mode = __esm(() => {
 
 // src/tools/request-permission.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync as existsSync50, mkdirSync as mkdirSync29, readFileSync as readFileSync46, unlinkSync as unlinkSync3, writeFileSync as writeFileSync32 } from "node:fs";
-import { join as join58 } from "node:path";
+import { existsSync as existsSync51, mkdirSync as mkdirSync29, readFileSync as readFileSync46, unlinkSync as unlinkSync3, writeFileSync as writeFileSync32 } from "node:fs";
+import { join as join59 } from "node:path";
 function createRequestPermissionTool(opts) {
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
   const pollIntervalMs = opts.pollIntervalMs ?? POLL_INTERVAL_MS2;
@@ -79036,11 +79088,11 @@ function createRequestPermissionTool(opts) {
     description: "Internal permission prompt — asks the AnchorKit user whether Claude may execute a tool. Used via claude --permission-prompt-tool.",
     inputSchema: requestPermissionInputSchema,
     async handler(input) {
-      const dir = join58(opts.cwd, ".anchorkit", "permissions");
-      if (!existsSync50(dir))
+      const dir = join59(opts.cwd, ".anchorkit", "permissions");
+      if (!existsSync51(dir))
         mkdirSync29(dir, { recursive: true });
       const id = randomUUID2();
-      const file = join58(dir, `${id}.json`);
+      const file = join59(dir, `${id}.json`);
       const payload = {
         id,
         status: "pending",
@@ -79171,9 +79223,9 @@ var init_todo_write = __esm(() => {
 });
 
 // src/tools/vault-map.ts
-import { basename as basename14, join as join59 } from "node:path";
+import { basename as basename14, join as join60 } from "node:path";
 function toInternal2(config) {
-  const vaultPath = join59(config.root, ".anchorkit", "vault");
+  const vaultPath = join60(config.root, ".anchorkit", "vault");
   return {
     local: { path: vaultPath },
     global: config.globalRoot ? { path: config.globalRoot } : null,
@@ -79211,7 +79263,7 @@ function createVaultMapTool(config) {
 var vaultMapInputSchema, vaultMapJsonSchema;
 var init_vault_map = __esm(() => {
   init_zod();
-  init_indexer();
+  init_indexing();
   init_mapper();
   vaultMapInputSchema = exports_external.object({
     scope: exports_external.enum(["project", "global"]).optional(),
@@ -81013,9 +81065,9 @@ async function handler3(_args, ctx) {
 }
 
 // src/commands/vault-map.ts
-init_indexer();
+init_indexing();
 init_mapper();
-import { basename as basename7, join as join22 } from "node:path";
+import { basename as basename7, join as join26 } from "node:path";
 var LEGACY_GATE_MODULE_LIMIT = 100;
 function parseVaultMapFlags(args) {
   const flags = {
@@ -81093,7 +81145,7 @@ async function handler4(args, ctx) {
   }
 }
 function buildInternalCfg(root) {
-  const vaultPath = join22(root, ".anchorkit", "vault");
+  const vaultPath = join26(root, ".anchorkit", "vault");
   return {
     local: { path: vaultPath },
     global: null,
@@ -81162,14 +81214,14 @@ async function handler5(args, ctx) {
 }
 
 // src/commands/vault-search.ts
-import { existsSync as existsSync20, readFileSync as readFileSync21 } from "node:fs";
-import { join as join23, relative as relative4 } from "node:path";
-init_utils();
-var DEFAULT_LIMIT2 = 20;
-var MAX_LIMIT = 500;
+import { existsSync as existsSync24, readFileSync as readFileSync24 } from "node:fs";
+import { join as join27, relative as relative4 } from "node:path";
+init_indexing();
+var DEFAULT_LIMIT3 = 20;
+var MAX_LIMIT2 = 500;
 function parseSearchArgs(args) {
   let global = false;
-  let limit = DEFAULT_LIMIT2;
+  let limit = DEFAULT_LIMIT3;
   const positionals = [];
   for (let i = 0;i < args.length; i++) {
     const a = args[i];
@@ -81178,13 +81230,13 @@ function parseSearchArgs(args) {
     } else if (a === "-n" || a === "--limit") {
       const n = Number.parseInt(args[i + 1] ?? "", 10);
       if (Number.isFinite(n) && n > 0)
-        limit = Math.min(n, MAX_LIMIT);
+        limit = Math.min(n, MAX_LIMIT2);
       i++;
     } else if (a.startsWith("-n=") || a.startsWith("--limit=")) {
       const rhs = a.split("=")[1] ?? "";
       const n = Number.parseInt(rhs, 10);
       if (Number.isFinite(n) && n > 0)
-        limit = Math.min(n, MAX_LIMIT);
+        limit = Math.min(n, MAX_LIMIT2);
     } else if (!a.startsWith("-")) {
       positionals.push(a);
     }
@@ -81211,8 +81263,8 @@ async function handler6(args, ctx) {
   try {
     const vault = await ctx.vault();
     const root = vault.config.root;
-    const vaultPath = global ? vault.config.globalRoot ?? join23(root, ".anchorkit", "global-vault") : join23(root, ".anchorkit", "vault");
-    if (!existsSync20(vaultPath)) {
+    const vaultPath = global ? vault.config.globalRoot ?? join27(root, ".anchorkit", "global-vault") : join27(root, ".anchorkit", "vault");
+    if (!existsSync24(vaultPath)) {
       ctx.appendOutput(source_default.dim(global ? "no global vault configured — nothing to search." : "no vault at this path — nothing to search."));
       return { ok: true };
     }
@@ -81223,7 +81275,7 @@ async function handler6(args, ctx) {
       for (const abs of walkNotes(vaultPath)) {
         let raw;
         try {
-          raw = readFileSync21(abs, "utf-8");
+          raw = readFileSync24(abs, "utf-8");
         } catch {
           continue;
         }
@@ -81262,8 +81314,8 @@ async function handler6(args, ctx) {
 }
 
 // src/commands/vault-stats.ts
-import { existsSync as existsSync21, readFileSync as readFileSync22, readdirSync as readdirSync11, statSync as statSync7 } from "node:fs";
-import { basename as basename8, extname as extname5, join as join24, relative as relative5 } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync25, readdirSync as readdirSync11, statSync as statSync7 } from "node:fs";
+import { basename as basename8, extname as extname5, join as join28, relative as relative5 } from "node:path";
 var NOTE_FOLDERS2 = ["knowledge", "maps", "decisions", "flows", "incidents", "archive"];
 var NOTE_TYPES2 = [
   "module",
@@ -81306,8 +81358,8 @@ function countByFolder(vaultPath) {
   for (const folder of NOTE_FOLDERS2)
     counts[folder] = 0;
   for (const folder of NOTE_FOLDERS2) {
-    const dir = join24(vaultPath, folder);
-    if (!existsSync21(dir))
+    const dir = join28(vaultPath, folder);
+    if (!existsSync25(dir))
       continue;
     let entries;
     try {
@@ -81321,7 +81373,7 @@ function countByFolder(vaultPath) {
       if (basename8(name).startsWith("_"))
         continue;
       try {
-        const s = statSync7(join24(dir, name));
+        const s = statSync7(join28(dir, name));
         if (s.isFile())
           counts[folder] = (counts[folder] ?? 0) + 1;
       } catch {}
@@ -81330,13 +81382,13 @@ function countByFolder(vaultPath) {
   return counts;
 }
 function countCaptures(vaultPath) {
-  const logPath = join24(vaultPath, "_log.md");
+  const logPath = join28(vaultPath, "_log.md");
   const summary = { live: 0, undone: 0, bySource: {} };
-  if (!existsSync21(logPath))
+  if (!existsSync25(logPath))
     return summary;
   let content;
   try {
-    content = readFileSync22(logPath, "utf-8");
+    content = readFileSync25(logPath, "utf-8");
   } catch {
     return summary;
   }
@@ -81390,8 +81442,8 @@ function computeAge(notes) {
 function countOrphans(vaultPath) {
   const all = [];
   for (const folder of NOTE_FOLDERS2) {
-    const dir = join24(vaultPath, folder);
-    if (!existsSync21(dir))
+    const dir = join28(vaultPath, folder);
+    if (!existsSync25(dir))
       continue;
     let entries;
     try {
@@ -81404,7 +81456,7 @@ function countOrphans(vaultPath) {
         continue;
       if (basename8(name).startsWith("_"))
         continue;
-      all.push(join24(dir, name));
+      all.push(join28(dir, name));
     }
   }
   if (all.length === 0)
@@ -81417,7 +81469,7 @@ function countOrphans(vaultPath) {
   for (const abs of all) {
     let raw;
     try {
-      raw = readFileSync22(abs, "utf-8");
+      raw = readFileSync25(abs, "utf-8");
     } catch {
       continue;
     }
@@ -81444,9 +81496,9 @@ async function handler7(args, ctx) {
   try {
     const vault = await ctx.vault();
     const root = vault.config.root;
-    const vaultPath = global ? vault.config.globalRoot ?? join24(root, ".anchorkit", "global-vault") : join24(root, ".anchorkit", "vault");
+    const vaultPath = global ? vault.config.globalRoot ?? join28(root, ".anchorkit", "global-vault") : join28(root, ".anchorkit", "vault");
     const label = global ? "Global vault" : "Local vault";
-    if (global && !existsSync21(vaultPath)) {
+    if (global && !existsSync25(vaultPath)) {
       const msg = "no global vault configured. Run `/vault-init-global` (or set ANCHORKIT_GLOBAL_VAULT) to create one.";
       ctx.appendOutput(msg);
       return { ok: false, message: msg };
@@ -81496,8 +81548,8 @@ async function handler7(args, ctx) {
 }
 
 // src/commands/vault-undo.ts
-import { existsSync as existsSync22, readFileSync as readFileSync23, rmSync, writeFileSync as writeFileSync13 } from "node:fs";
-import { basename as basename9, isAbsolute, join as join25, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync26, rmSync, writeFileSync as writeFileSync15 } from "node:fs";
+import { basename as basename9, isAbsolute, join as join29, resolve as resolve3 } from "node:path";
 function parseUndoCount(args, fallback = 1) {
   for (const a of args) {
     const n = Number.parseInt(a, 10);
@@ -81511,15 +81563,15 @@ async function handler8(args, ctx) {
   try {
     const vault = await ctx.vault();
     const root = vault.config.root;
-    const statePath = join25(root, ".anchorkit", "state.json");
-    const vaultRoot = join25(root, ".anchorkit", "vault");
-    if (!existsSync22(statePath)) {
+    const statePath = join29(root, ".anchorkit", "state.json");
+    const vaultRoot = join29(root, ".anchorkit", "vault");
+    if (!existsSync26(statePath)) {
       ctx.appendOutput("nothing to undo (no state file yet).");
       return { ok: true };
     }
     let raw;
     try {
-      raw = readFileSync23(statePath, "utf-8");
+      raw = readFileSync26(statePath, "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       ctx.appendOutput(`could not read state.json: ${msg}`);
@@ -81552,7 +81604,7 @@ async function handler8(args, ctx) {
         continue;
       }
       try {
-        if (existsSync22(abs))
+        if (existsSync26(abs))
           rmSync(abs, { force: true });
         removed++;
         ctx.appendOutput(`undid: ${basename9(cap.filename)}`);
@@ -81562,7 +81614,7 @@ async function handler8(args, ctx) {
     }
     const next = { ...parsed, captures: remaining };
     try {
-      writeFileSync13(statePath, JSON.stringify(next, null, 2), "utf-8");
+      writeFileSync15(statePath, JSON.stringify(next, null, 2), "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       ctx.appendOutput(`could not rewrite state.json: ${msg}`);
@@ -81578,23 +81630,24 @@ async function handler8(args, ctx) {
 }
 
 // src/commands/vault-upgrade.ts
-import { basename as basename10, join as join27 } from "node:path";
+import { basename as basename10, join as join31 } from "node:path";
 
 // src/vault/upgrade.ts
 init_config();
-init_utils();
+init_conventions();
+init_indexing();
 init_storage();
 init_storage();
 import {
-  existsSync as existsSync23,
-  mkdirSync as mkdirSync14,
-  readFileSync as readFileSync24,
+  existsSync as existsSync27,
+  mkdirSync as mkdirSync15,
+  readFileSync as readFileSync27,
   readdirSync as readdirSync12,
   statSync as statSync8,
   unlinkSync,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync16
 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join26, resolve as resolve4 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join30, resolve as resolve4 } from "node:path";
 function inferNoteType(_docPath, doc, projectRoot) {
   const raw = doc?.source_path;
   if (typeof raw !== "string" || raw.trim().length === 0) {
@@ -81605,7 +81658,7 @@ function inferNoteType(_docPath, doc, projectRoot) {
   if (!abs.startsWith(rootResolved))
     return "concept";
   try {
-    if (existsSync23(abs) && statSync8(abs).isFile())
+    if (existsSync27(abs) && statSync8(abs).isFile())
       return "module";
   } catch {}
   return "concept";
@@ -81633,18 +81686,18 @@ function firstNonEmptyLine(body, max = 120) {
   return "";
 }
 function appendLogEntry2(vaultPath, line) {
-  const logPath = join26(vaultPath, "_log.md");
-  if (!existsSync23(logPath)) {
-    writeFileSync14(logPath, `# Vault log
+  const logPath = join30(vaultPath, "_log.md");
+  if (!existsSync27(logPath)) {
+    writeFileSync16(logPath, `# Vault log
 
 ${line}
 `, "utf-8");
     return;
   }
-  const content = readFileSync24(logPath, "utf-8");
+  const content = readFileSync27(logPath, "utf-8");
   const needsNl = content.length > 0 && !content.endsWith(`
 `);
-  writeFileSync14(logPath, `${content + (needsNl ? `
+  writeFileSync16(logPath, `${content + (needsNl ? `
 ` : "") + line}
 `, "utf-8");
 }
@@ -81683,10 +81736,10 @@ async function upgradeVault(cfg) {
     const docRelPath = typeof docEntry === "string" ? docEntry : "";
     if (!docRelPath)
       continue;
-    const srcPath = join26(cfg.vaultPath, docRelPath);
-    if (!existsSync23(srcPath))
+    const srcPath = join30(cfg.vaultPath, docRelPath);
+    if (!existsSync27(srcPath))
       continue;
-    const raw = readFileSync24(srcPath, "utf-8");
+    const raw = readFileSync27(srcPath, "utf-8");
     const { frontmatter: existingFm, content: existingBody } = parseFrontmatter(raw);
     const hadFrontmatter = Object.keys(existingFm).length > 0;
     const body = hadFrontmatter ? existingBody : raw;
@@ -81762,8 +81815,8 @@ function addScopeToVault(cfg) {
   };
   const skippedDetails = [];
   for (const folder of NOTE_FOLDERS) {
-    const folderPath = join26(vaultPath, folder);
-    if (!existsSync23(folderPath))
+    const folderPath = join30(vaultPath, folder);
+    if (!existsSync27(folderPath))
       continue;
     walkAndAddScope(folderPath, folder, result, skippedDetails);
   }
@@ -81783,7 +81836,7 @@ function walkAndAddScope(dir, folderRel, result, skippedDetails) {
     return;
   }
   for (const entry of entries) {
-    const full = join26(dir, entry);
+    const full = join30(dir, entry);
     let s;
     try {
       s = statSync8(full);
@@ -81800,7 +81853,7 @@ function walkAndAddScope(dir, folderRel, result, skippedDetails) {
   }
 }
 function processOneNote(absPath, relPath, result, skippedDetails) {
-  const raw = readFileSync24(absPath, "utf-8");
+  const raw = readFileSync27(absPath, "utf-8");
   const fenceMatch = raw.match(/^---\n([\s\S]*?)\n---\n?/);
   if (!fenceMatch) {
     result.notesSkipped++;
@@ -81833,7 +81886,7 @@ ${newFrontmatter}
 ---
 ${rest.startsWith(`
 `) ? rest.slice(1) : rest}`;
-  writeFileSync14(absPath, newRaw, "utf-8");
+  writeFileSync16(absPath, newRaw, "utf-8");
   result.notesAdded++;
 }
 function regenerateIndex(vaultPath, movedSlugs) {
@@ -81857,8 +81910,8 @@ function regenerateIndex(vaultPath, movedSlugs) {
   lines.push("- [[_conventions]] — vault constitution");
   lines.push("- [[_log]] — append-only mutation log");
   lines.push("");
-  mkdirSync14(vaultPath, { recursive: true });
-  writeFileSync14(join26(vaultPath, "_index.md"), lines.join(`
+  mkdirSync15(vaultPath, { recursive: true });
+  writeFileSync16(join30(vaultPath, "_index.md"), lines.join(`
 `), "utf-8");
 }
 
@@ -81916,7 +81969,7 @@ async function handler9(args, ctx) {
   }
 }
 function buildInternalCfg2(root) {
-  const vaultPath = join27(root, ".anchorkit", "vault");
+  const vaultPath = join31(root, ".anchorkit", "vault");
   return {
     local: { path: vaultPath },
     global: null,
@@ -82558,13 +82611,13 @@ async function handler12(_args, ctx) {
 
 // src/session/store.ts
 import { promises as fsp } from "node:fs";
-import { existsSync as existsSync25 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync29 } from "node:fs";
+import { join as join32 } from "node:path";
 function sessionsDir(cwd) {
-  return join28(cwd, ".anchorkit", "sessions");
+  return join32(cwd, ".anchorkit", "sessions");
 }
 function sessionPath(cwd, sessionId) {
-  return join28(sessionsDir(cwd), `${sessionId}.json`);
+  return join32(sessionsDir(cwd), `${sessionId}.json`);
 }
 function newSessionId() {
   const iso = new Date().toISOString().replace(/[:.]/g, "-");
@@ -82594,7 +82647,7 @@ async function saveSession(cwd, session) {
 }
 async function loadSession(cwd, sessionId) {
   const p = sessionPath(cwd, sessionId);
-  if (!existsSync25(p))
+  if (!existsSync29(p))
     return null;
   let raw;
   try {
@@ -82615,7 +82668,7 @@ async function loadSession(cwd, sessionId) {
 }
 async function listSessions(cwd) {
   const dir = sessionsDir(cwd);
-  if (!existsSync25(dir))
+  if (!existsSync29(dir))
     return [];
   let entries;
   try {
@@ -82628,7 +82681,7 @@ async function listSessions(cwd) {
   for (const file of files) {
     const sessionId = file.replace(/\.json$/, "");
     try {
-      const raw = await fsp.readFile(join28(dir, file), "utf-8");
+      const raw = await fsp.readFile(join32(dir, file), "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object")
         continue;
@@ -82661,7 +82714,7 @@ async function rotateSessions(cwd, opts = {}) {
   const ttlDaysRaw = normalized.ttlDays ?? envNumber("ANCHORKIT_SESSIONS_TTL_DAYS") ?? DEFAULT_TTL_DAYS;
   const ttlMs = ttlDaysRaw > 0 ? ttlDaysRaw * 24 * 60 * 60 * 1000 : Number.POSITIVE_INFINITY;
   const dir = sessionsDir(cwd);
-  if (!existsSync25(dir))
+  if (!existsSync29(dir))
     return;
   const summaries = await listSessions(cwd);
   const victims = new Set;
@@ -83221,8 +83274,8 @@ ${truncated}`;
 
 // src/commands/pr.ts
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync26 } from "node:fs";
-import { join as join29 } from "node:path";
+import { existsSync as existsSync30 } from "node:fs";
+import { join as join33 } from "node:path";
 var TITLE_MAX_LEN = 70;
 function parsePrArgs(args) {
   const out = { draft: false };
@@ -83296,10 +83349,10 @@ function defaultRun(cmd, args, opts) {
 }
 function createPrCommandHandler(deps = {}) {
   const run = deps.run ?? defaultRun;
-  const exists = deps.existsSync ?? existsSync26;
+  const exists = deps.existsSync ?? existsSync30;
   return async function handler18(args, ctx) {
     const { base: baseArg, draft } = parsePrArgs(args);
-    if (!exists(join29(ctx.cwd, ".git"))) {
+    if (!exists(join33(ctx.cwd, ".git"))) {
       const msg = "not a git repository";
       ctx.appendOutput(msg);
       return { ok: false, message: msg };
@@ -83394,17 +83447,17 @@ var handler18 = createPrCommandHandler();
 
 // src/skills/loader.ts
 init_paths();
-import { existsSync as existsSync27, readFileSync as readFileSync26, readdirSync as readdirSync13, statSync as statSync9 } from "node:fs";
-import { join as join30 } from "node:path";
+import { existsSync as existsSync31, readFileSync as readFileSync29, readdirSync as readdirSync13, statSync as statSync9 } from "node:fs";
+import { join as join34 } from "node:path";
 var SKILL_FILENAME = "SKILL.md";
 function skillsDir() {
-  return join30(anchorkitHomeDir(), "skills");
+  return join34(anchorkitHomeDir(), "skills");
 }
 function skillDir(name) {
-  return join30(skillsDir(), name);
+  return join34(skillsDir(), name);
 }
 function skillFilePath(name) {
-  return join30(skillDir(name), SKILL_FILENAME);
+  return join34(skillDir(name), SKILL_FILENAME);
 }
 function parseSkillMd(raw) {
   if (!raw.startsWith(`---
@@ -83457,7 +83510,7 @@ function firstNonEmptyLine2(body) {
 }
 async function listSkills() {
   const root = skillsDir();
-  if (!existsSync27(root))
+  if (!existsSync31(root))
     return [];
   let entries;
   try {
@@ -83467,19 +83520,19 @@ async function listSkills() {
   }
   const out = [];
   for (const entry of entries) {
-    const dir = join30(root, entry);
+    const dir = join34(root, entry);
     try {
       if (!statSync9(dir).isDirectory())
         continue;
     } catch {
       continue;
     }
-    const file = join30(dir, SKILL_FILENAME);
-    if (!existsSync27(file))
+    const file = join34(dir, SKILL_FILENAME);
+    if (!existsSync31(file))
       continue;
     let raw;
     try {
-      raw = readFileSync26(file, "utf-8");
+      raw = readFileSync29(file, "utf-8");
     } catch {
       continue;
     }
@@ -83494,11 +83547,11 @@ async function listSkills() {
 async function loadSkill(name) {
   const dir = skillDir(name);
   const file = skillFilePath(name);
-  if (!existsSync27(file))
+  if (!existsSync31(file))
     return null;
   let raw;
   try {
-    raw = readFileSync26(file, "utf-8");
+    raw = readFileSync29(file, "utf-8");
   } catch {
     return null;
   }
@@ -83552,30 +83605,30 @@ async function handler19(args, ctx) {
 // src/mcp/config.ts
 init_paths();
 import { promises as fsp2 } from "node:fs";
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname11, join as join31 } from "node:path";
+import { dirname as dirname11, join as join35 } from "node:path";
 var NAME_RE = /^[a-z0-9_-]+$/;
 function isValidServerName(name) {
   return NAME_RE.test(name);
 }
 function projectConfigPath(cwd) {
-  return join31(cwd, ".anchorkit", "mcp-servers.json");
+  return join35(cwd, ".anchorkit", "mcp-servers.json");
 }
 function globalConfigPath(homeDir) {
   if (homeDir !== undefined) {
-    return join31(homeDir, ".anchorkit", "mcp-servers.json");
+    return join35(homeDir, ".anchorkit", "mcp-servers.json");
   }
   if (process.env.ANCHORKIT_TEST_HOME) {
-    return join31(anchorkitHomeDir(), "mcp-servers.json");
+    return join35(anchorkitHomeDir(), "mcp-servers.json");
   }
-  return join31(homedir7(), ".anchorkit", "mcp-servers.json");
+  return join35(homedir7(), ".anchorkit", "mcp-servers.json");
 }
 function configPathForScope(scope, cwd, homeDir) {
   return scope === "project" ? projectConfigPath(cwd) : globalConfigPath(homeDir);
 }
 async function readConfigFile(path4) {
-  if (!existsSync28(path4))
+  if (!existsSync32(path4))
     return {};
   let raw;
   try {
@@ -83786,8 +83839,8 @@ async function handler20(args, ctx) {
 }
 
 // src/hooks/config.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync16, readFileSync as readFileSync27, renameSync as renameSync3, writeFileSync as writeFileSync16 } from "node:fs";
-import { dirname as dirname12, join as join32 } from "node:path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync17, readFileSync as readFileSync30, renameSync as renameSync4, writeFileSync as writeFileSync18 } from "node:fs";
+import { dirname as dirname12, join as join36 } from "node:path";
 var KNOWN_HOOKS = [
   "inject-context",
   "principles-injection",
@@ -83799,15 +83852,15 @@ var KNOWN_HOOKS = [
   "gsd-pipeline"
 ];
 function hooksConfigPath(cwd) {
-  return join32(cwd, ".anchorkit", "hooks-config.json");
+  return join36(cwd, ".anchorkit", "hooks-config.json");
 }
 var EMPTY = { disabled: [] };
 async function loadHooksConfig(cwd) {
   const p = hooksConfigPath(cwd);
-  if (!existsSync29(p))
+  if (!existsSync33(p))
     return { disabled: [] };
   try {
-    const raw = readFileSync27(p, "utf-8");
+    const raw = readFileSync30(p, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && Array.isArray(parsed.disabled)) {
       const disabled = parsed.disabled.filter((x) => typeof x === "string");
@@ -83822,12 +83875,12 @@ async function loadHooksConfig(cwd) {
 }
 function writeConfigAtomic(p, cfg) {
   const dir = dirname12(p);
-  if (!existsSync29(dir))
-    mkdirSync16(dir, { recursive: true });
+  if (!existsSync33(dir))
+    mkdirSync17(dir, { recursive: true });
   const tmp = `${p}.tmp.${process.pid}.${Date.now()}`;
-  writeFileSync16(tmp, `${JSON.stringify(cfg, null, 2)}
+  writeFileSync18(tmp, `${JSON.stringify(cfg, null, 2)}
 `, "utf-8");
-  renameSync3(tmp, p);
+  renameSync4(tmp, p);
 }
 async function setHookEnabled(cwd, name, enabled) {
   const cfg = await loadHooksConfig(cwd);
@@ -84097,7 +84150,7 @@ var ErrorResponseSchema = exports_external.object({
 init_zod();
 import { promises as fs2, constants as fsConstants } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join33 } from "node:path";
+import { join as join37 } from "node:path";
 var CREDENTIALS_SCHEMA = exports_external.object({
   apiUrl: exports_external.string().url(),
   userId: exports_external.string().uuid(),
@@ -84109,8 +84162,8 @@ var CREDENTIALS_SCHEMA = exports_external.object({
 });
 function defaultCredentialsPaths() {
   const home = process.env.HOME ?? process.env.USERPROFILE ?? homedir8();
-  const dir = join33(home, ".anchorkit");
-  return { file: join33(dir, "credentials.json"), dir };
+  const dir = join37(home, ".anchorkit");
+  return { file: join37(dir, "credentials.json"), dir };
 }
 async function loadCredentials(paths = defaultCredentialsPaths()) {
   let raw;
@@ -84136,7 +84189,7 @@ async function saveCredentials(creds, paths = defaultCredentialsPaths()) {
   const validated = CREDENTIALS_SCHEMA.parse(creds);
   await fs2.mkdir(paths.dir, { recursive: true, mode: 448 });
   const tmpName = `credentials.json.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`;
-  const tmpPath = join33(paths.dir, tmpName);
+  const tmpPath = join37(paths.dir, tmpName);
   const data = `${JSON.stringify(validated, null, 2)}
 `;
   await fs2.writeFile(tmpPath, data, { encoding: "utf8", mode: 384 });
@@ -84384,7 +84437,7 @@ function safeJsonParse(raw) {
 init_debugLog();
 
 // src/sync/supervisor.ts
-import { existsSync as existsSync30 } from "node:fs";
+import { existsSync as existsSync34 } from "node:fs";
 import { dirname as dirname14, resolve as resolvePath } from "node:path";
 import { Readable, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
@@ -84500,10 +84553,10 @@ function defaultNodeSpawner() {
 function defaultWorkerScript() {
   const here = dirname14(fileURLToPath(import.meta.url));
   const sibling = resolvePath(here, "worker.ts");
-  if (existsSync30(sibling))
+  if (existsSync34(sibling))
     return sibling;
   const bundled = resolvePath(here, "sync", "worker.mjs");
-  if (existsSync30(bundled))
+  if (existsSync34(bundled))
     return bundled;
   return sibling;
 }
@@ -84975,9 +85028,9 @@ function failure(err, ctx, what) {
 
 // src/cli/doctorChecks.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync17, rmSync as rmSync2, writeFileSync as writeFileSync17 } from "node:fs";
+import { mkdirSync as mkdirSync18, rmSync as rmSync2, writeFileSync as writeFileSync19 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { join as join34 } from "node:path";
+import { join as join38 } from "node:path";
 var DEFAULT_TIMEOUT_MS2 = 2000;
 function defaultSpawn(cmd, args, opts = {}) {
   try {
@@ -85101,9 +85154,9 @@ function checkGit(spawn2) {
 }
 function checkWritable(name, dir) {
   try {
-    mkdirSync17(dir, { recursive: true });
-    const probe = join34(dir, `.anchorkit-doctor-${process.pid}-${Date.now()}`);
-    writeFileSync17(probe, "ok", "utf-8");
+    mkdirSync18(dir, { recursive: true });
+    const probe = join38(dir, `.anchorkit-doctor-${process.pid}-${Date.now()}`);
+    writeFileSync19(probe, "ok", "utf-8");
     try {
       rmSync2(probe, { force: true });
     } catch {}
@@ -85141,8 +85194,8 @@ async function checkVault(loader) {
 async function runAllChecks(opts) {
   const spawn2 = opts.spawnFn ?? defaultSpawn;
   const home = opts.homeDir ?? homedir9();
-  const anchorHome = join34(home, ".anchorkit");
-  const anchorProject = join34(opts.cwd, ".anchorkit");
+  const anchorHome = join38(home, ".anchorkit");
+  const anchorProject = join38(opts.cwd, ".anchorkit");
   const jobs = [
     Promise.resolve().then(() => checkBun()),
     Promise.resolve().then(() => checkClaude(spawn2)),
@@ -85225,7 +85278,7 @@ var handler22 = createDoctorCommandHandler();
 init_zod();
 import { randomUUID } from "node:crypto";
 import { promises as fs3 } from "node:fs";
-import { dirname as dirname15, join as join35 } from "node:path";
+import { dirname as dirname15, join as join39 } from "node:path";
 var SyncConflictEntrySchema = exports_external.object({
   path: exports_external.string(),
   noteId: exports_external.string().uuid(),
@@ -85240,7 +85293,7 @@ var SyncStateSchema = exports_external.object({
   conflicts: exports_external.array(SyncConflictEntrySchema).default([])
 });
 function syncStatePath(cwd) {
-  return join35(cwd, ".anchorkit", "sync-state.json");
+  return join39(cwd, ".anchorkit", "sync-state.json");
 }
 async function loadSyncState(cwd) {
   const path4 = syncStatePath(cwd);
@@ -85394,8 +85447,8 @@ async function syncHandler(args, ctx) {
 }
 
 // src/commands/resolve.ts
-import { existsSync as existsSync32 } from "node:fs";
-import { join as join36 } from "node:path";
+import { existsSync as existsSync36 } from "node:fs";
+import { join as join40 } from "node:path";
 
 // src/manifest/db.ts
 import Database from "better-sqlite3";
@@ -85799,16 +85852,16 @@ class LocalResolver {
 }
 
 // src/commands/resolve.ts
-var DEFAULT_LIMIT3 = 10;
+var DEFAULT_LIMIT4 = 10;
 async function resolveHandler(args, ctx) {
-  const limit = parseLimit(args) ?? DEFAULT_LIMIT3;
+  const limit = parseLimit(args) ?? DEFAULT_LIMIT4;
   const query = stripFlags(args).join(" ").trim();
   if (!query) {
     ctx.appendOutput('usage: /resolve "<query>" [-n=N]');
     return { ok: false, message: "missing query" };
   }
   const dbPath = resolveManifestPath(ctx.cwd);
-  if (!existsSync32(dbPath)) {
+  if (!existsSync36(dbPath)) {
     ctx.appendOutput(`no manifest.db at ${dbPath} — sync has not indexed any notes yet`);
     return { ok: false, message: "no manifest" };
   }
@@ -85883,7 +85936,7 @@ function parseLimit(args) {
   return null;
 }
 function resolveManifestPath(cwd) {
-  return join36(cwd, ".anchorkit", "manifest.db");
+  return join40(cwd, ".anchorkit", "manifest.db");
 }
 
 // src/commands/cursor-agent.ts
@@ -86641,17 +86694,17 @@ async function dispatchSlashCommand(input, ctx) {
 
 // src/config/trust.ts
 init_paths();
-import { chmodSync as chmodSync3, existsSync as existsSync33, mkdirSync as mkdirSync18, readFileSync as readFileSync28, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname16, join as join37 } from "node:path";
+import { chmodSync as chmodSync3, existsSync as existsSync37, mkdirSync as mkdirSync19, readFileSync as readFileSync31, writeFileSync as writeFileSync20 } from "node:fs";
+import { dirname as dirname16, join as join41 } from "node:path";
 function trustedFoldersPath() {
-  return join37(anchorkitHomeDir(), "trusted-folders.json");
+  return join41(anchorkitHomeDir(), "trusted-folders.json");
 }
 function loadTrustedFolders() {
   const path4 = trustedFoldersPath();
-  if (!existsSync33(path4))
+  if (!existsSync37(path4))
     return {};
   try {
-    const raw = readFileSync28(path4, "utf-8");
+    const raw = readFileSync31(path4, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
       return {};
@@ -86668,8 +86721,8 @@ function trustFolder(cwd) {
   const map = loadTrustedFolders();
   map[cwd] = { acceptedAt: new Date().toISOString() };
   const path4 = trustedFoldersPath();
-  mkdirSync18(dirname16(path4), { recursive: true, mode: 448 });
-  writeFileSync18(path4, JSON.stringify(map, null, 2), "utf-8");
+  mkdirSync19(dirname16(path4), { recursive: true, mode: 448 });
+  writeFileSync20(path4, JSON.stringify(map, null, 2), "utf-8");
   try {
     chmodSync3(path4, 384);
   } catch {}
@@ -92189,9 +92242,9 @@ function TrustDialog({ cwd, onDecision }) {
 // src/repl/allowedTools.ts
 import { mkdirSync as mkdirSync22, readFileSync as readFileSync36, renameSync as renameSync5, writeFileSync as writeFileSync24 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
-import { dirname as dirname18, join as join45 } from "node:path";
+import { dirname as dirname18, join as join46 } from "node:path";
 function configPath(opts = {}) {
-  return join45(opts.homeDir ?? homedir10(), ".anchorkit", "allowed-tools.json");
+  return join46(opts.homeDir ?? homedir10(), ".anchorkit", "allowed-tools.json");
 }
 function loadAllowedTools(opts = {}) {
   const path4 = configPath(opts);
@@ -92226,7 +92279,7 @@ function writeAtomic(path4, payload) {
 
 // src/repl/permissionsWatcher.ts
 import {
-  existsSync as existsSync40,
+  existsSync as existsSync41,
   mkdirSync as mkdirSync23,
   readFileSync as readFileSync37,
   readdirSync as readdirSync15,
@@ -92235,18 +92288,18 @@ import {
   watch,
   writeFileSync as writeFileSync25
 } from "node:fs";
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 var STALE_FILE_MS = 60 * 60 * 1000;
 function createPermissionsWatcher(cwd) {
-  const dir = join46(cwd, ".anchorkit", "permissions");
-  if (!existsSync40(dir))
+  const dir = join47(cwd, ".anchorkit", "permissions");
+  if (!existsSync41(dir))
     mkdirSync23(dir, { recursive: true });
   try {
     const now2 = Date.now();
     for (const filename of readdirSync15(dir)) {
       if (!filename.endsWith(".json"))
         continue;
-      const path4 = join46(dir, filename);
+      const path4 = join47(dir, filename);
       try {
         const age = now2 - statSync11(path4).mtimeMs;
         if (age > STALE_FILE_MS)
@@ -92271,7 +92324,7 @@ function createPermissionsWatcher(cwd) {
         continue;
       let parsed;
       try {
-        const raw = readFileSync37(join46(dir, filename), "utf-8");
+        const raw = readFileSync37(join47(dir, filename), "utf-8");
         parsed = JSON.parse(raw);
       } catch {
         continue;
@@ -92314,7 +92367,7 @@ function createPermissionsWatcher(cwd) {
       return () => listeners.delete(cb);
     },
     respond(id, decision, message) {
-      const file = join46(dir, `${id}.json`);
+      const file = join47(dir, `${id}.json`);
       try {
         const raw = readFileSync37(file, "utf-8");
         const parsed = JSON.parse(raw);
@@ -92353,7 +92406,7 @@ function usePlanMode() {
 
 // src/repl/useSession.ts
 init_detect();
-import { join as join57 } from "node:path";
+import { join as join58 } from "node:path";
 import { useCallback, useEffect as useEffect7, useRef as useRef2, useState as useState10 } from "react";
 
 // src/agent/runner.ts
@@ -92385,25 +92438,25 @@ async function* runTurn(prompt, opts) {
 }
 
 // src/claude-memory/watcher.ts
-import { existsSync as existsSync42, watch as watch2 } from "node:fs";
-import { join as join49 } from "node:path";
+import { existsSync as existsSync43, watch as watch2 } from "node:fs";
+import { join as join50 } from "node:path";
 
 // src/claude-memory/paths.ts
 import { homedir as homedir11 } from "node:os";
-import { join as join47 } from "node:path";
+import { join as join48 } from "node:path";
 function claudeProjectSlug(cwd) {
   return cwd.replace(/\\/g, "/").replace(/\//g, "-");
 }
 function claudeMemoryDir(cwd) {
-  return join47(homedir11(), ".claude", "projects", claudeProjectSlug(cwd), "memory");
+  return join48(homedir11(), ".claude", "projects", claudeProjectSlug(cwd), "memory");
 }
 function claudeProjectDir(cwd) {
-  return join47(homedir11(), ".claude", "projects", claudeProjectSlug(cwd));
+  return join48(homedir11(), ".claude", "projects", claudeProjectSlug(cwd));
 }
 
 // src/claude-memory/sync.ts
-import { existsSync as existsSync41, mkdirSync as mkdirSync24, readFileSync as readFileSync38, readdirSync as readdirSync16, statSync as statSync12, writeFileSync as writeFileSync26 } from "node:fs";
-import { basename as basename12, join as join48 } from "node:path";
+import { existsSync as existsSync42, mkdirSync as mkdirSync24, readFileSync as readFileSync38, readdirSync as readdirSync16, statSync as statSync12, writeFileSync as writeFileSync26 } from "node:fs";
+import { basename as basename12, join as join49 } from "node:path";
 function parseClaudeMemoryFile(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
   if (!match) {
@@ -92426,7 +92479,7 @@ function parseClaudeMemoryFile(content) {
 }
 function readExistingCreated(destPath) {
   try {
-    if (!existsSync41(destPath))
+    if (!existsSync42(destPath))
       return null;
     const content = readFileSync38(destPath, "utf-8");
     const m2 = content.match(/^created:\s*(.+)$/m);
@@ -92486,9 +92539,9 @@ function syncMemoryFileToVault(memoryFilePath, vaultPath) {
   const { frontmatter: claudeFm, body } = parseClaudeMemoryFile(content);
   const rawTitle = claudeFm.name ?? filename.replace(/\.md$/, "");
   const title = titleCase(rawTitle);
-  const destDir = join48(vaultPath, "knowledge");
+  const destDir = join49(vaultPath, "knowledge");
   const destFilename = toVaultFilename(filename);
-  const destPath = join48(destDir, destFilename);
+  const destPath = join49(destDir, destFilename);
   const created = readExistingCreated(destPath) ?? fileMtime;
   const updated = fileMtime;
   const fm = buildVaultFrontmatter({
@@ -92521,7 +92574,7 @@ function bulkSyncMemoryDir(memoryDir, vaultPath) {
     return;
   }
   for (const f of files) {
-    syncMemoryFileToVault(join48(memoryDir, f), vaultPath);
+    syncMemoryFileToVault(join49(memoryDir, f), vaultPath);
   }
 }
 
@@ -92537,11 +92590,11 @@ function createClaudeMemoryWatcher(cwd, vaultPath) {
     if (!filename || !filename.endsWith(".md") || filename === "MEMORY.md")
       return;
     setImmediate(() => {
-      syncMemoryFileToVault(join49(memDir, filename), vaultPath);
+      syncMemoryFileToVault(join50(memDir, filename), vaultPath);
     });
   }
   function startMemWatcher() {
-    if (memWatcher || stopped || !existsSync42(memDir))
+    if (memWatcher || stopped || !existsSync43(memDir))
       return;
     bulkSyncMemoryDir(memDir, vaultPath);
     try {
@@ -92557,11 +92610,11 @@ function createClaudeMemoryWatcher(cwd, vaultPath) {
     }
   }
   function startProjectWatcher() {
-    if (projectWatcher || stopped || !existsSync42(projectDir))
+    if (projectWatcher || stopped || !existsSync43(projectDir))
       return;
     try {
       projectWatcher = watch2(projectDir, (_eventType, name) => {
-        if (name === "memory" && existsSync42(memDir)) {
+        if (name === "memory" && existsSync43(memDir)) {
           projectWatcher?.close();
           projectWatcher = null;
           startMemWatcher();
@@ -92580,9 +92633,9 @@ function createClaudeMemoryWatcher(cwd, vaultPath) {
       if (started || stopped)
         return;
       started = true;
-      if (existsSync42(memDir)) {
+      if (existsSync43(memDir)) {
         startMemWatcher();
-      } else if (existsSync42(projectDir)) {
+      } else if (existsSync43(projectDir)) {
         startProjectWatcher();
       }
     },
@@ -92600,11 +92653,11 @@ function createClaudeMemoryWatcher(cwd, vaultPath) {
 init_settings();
 
 // src/hooks/anchorkit-context-injection.ts
-import { existsSync as existsSync43, readFileSync as readFileSync39 } from "node:fs";
-import { join as join50 } from "node:path";
+import { existsSync as existsSync44, readFileSync as readFileSync39 } from "node:fs";
+import { join as join51 } from "node:path";
 function tryRead(path4, maxChars = 8000) {
   try {
-    if (!existsSync43(path4))
+    if (!existsSync44(path4))
       return null;
     const content = readFileSync39(path4, "utf-8");
     return content.length > maxChars ? `${content.slice(0, maxChars)}
@@ -92615,10 +92668,10 @@ function tryRead(path4, maxChars = 8000) {
   }
 }
 function computeAnchorKitContext(cwd) {
-  const vaultPath = join50(cwd, ".anchorkit", "vault");
-  const claudeMdPath = join50(vaultPath, "CLAUDE.md");
-  const projectMdPath = join50(cwd, "PROJECT.md");
-  const stateMdPath = join50(vaultPath, "STATE.md");
+  const vaultPath = join51(cwd, ".anchorkit", "vault");
+  const claudeMdPath = join51(vaultPath, "CLAUDE.md");
+  const projectMdPath = join51(cwd, "PROJECT.md");
+  const stateMdPath = join51(vaultPath, "STATE.md");
   const claudeMd = tryRead(claudeMdPath);
   const projectMd = tryRead(projectMdPath);
   const stateMd = tryRead(stateMdPath, 4000);
@@ -93011,8 +93064,8 @@ function createAutoCaptureAgent(ctx) {
   };
 }
 // src/vault/agents/session-lifecycle-agent.ts
-import { existsSync as existsSync44, mkdirSync as mkdirSync25, readFileSync as readFileSync40, writeFileSync as writeFileSync27 } from "node:fs";
-import { join as join51 } from "node:path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync25, readFileSync as readFileSync40, writeFileSync as writeFileSync27 } from "node:fs";
+import { join as join52 } from "node:path";
 var CYCLE_CLASSIFIER_PROMPT = (conversation, currentState) => `You are a session-lifecycle classifier for a software engineering AI assistant. Your job is to detect when a meaningful work cycle has completed in a conversation.
 
 You MUST work in ANY language — classify based on MEANING, not keywords.
@@ -93076,13 +93129,13 @@ function nowIso() {
   return new Date().toISOString();
 }
 function writeSessionNote(vaultPath, title, cycleType, summary, stateUpdate) {
-  const sessionsDir2 = join51(vaultPath, "_sessions");
+  const sessionsDir2 = join52(vaultPath, "_sessions");
   mkdirSync25(sessionsDir2, { recursive: true });
   const today = todayIso2();
   const slug = slugify3(title);
   const filename = `${today}-${slug}.md`;
-  const filepath = join51(sessionsDir2, filename);
-  if (existsSync44(filepath))
+  const filepath = join52(sessionsDir2, filename);
+  if (existsSync45(filepath))
     return filepath;
   const content = `---
 title: "${title.replace(/"/g, "\\\"")}"
@@ -93106,11 +93159,11 @@ ${stateUpdate}
   return filepath;
 }
 function updateStateMd(vaultPath, cycleType, title, summary) {
-  const statePath2 = join51(vaultPath, "STATE.md");
+  const statePath2 = join52(vaultPath, "STATE.md");
   const today = todayIso2();
   const entry = `- **${today}** [${cycleType}] ${title}: ${summary.split(`
 `)[0]}`;
-  if (!existsSync44(statePath2)) {
+  if (!existsSync45(statePath2)) {
     const content = `# Project State
 
 > Persistent state across AnchorKit sessions. Updated automatically when work cycles complete.
@@ -93166,13 +93219,13 @@ ${entry}
   }
 }
 function createSessionLifecycleAgent(ctx) {
-  const vaultPath = join51(ctx.repoRoot, ".anchorkit", "vault");
+  const vaultPath = join52(ctx.repoRoot, ".anchorkit", "vault");
   return {
     async run(conversation) {
-      const stateMdPath = join51(vaultPath, "STATE.md");
+      const stateMdPath = join52(vaultPath, "STATE.md");
       let currentState = null;
       try {
-        if (existsSync44(stateMdPath)) {
+        if (existsSync45(stateMdPath)) {
           currentState = readFileSync40(stateMdPath, "utf-8");
         }
       } catch {
@@ -93200,8 +93253,8 @@ function createSessionLifecycleAgent(ctx) {
   };
 }
 // src/hooks/state.ts
-import { existsSync as existsSync45, mkdirSync as mkdirSync26, readFileSync as readFileSync41, writeFileSync as writeFileSync28 } from "node:fs";
-import { dirname as dirname19, join as join52 } from "node:path";
+import { existsSync as existsSync46, mkdirSync as mkdirSync26, readFileSync as readFileSync41, writeFileSync as writeFileSync28 } from "node:fs";
+import { dirname as dirname19, join as join53 } from "node:path";
 var EMPTY_STATE = Object.freeze({
   captures: [],
   conversationMapEmits: [],
@@ -93210,11 +93263,11 @@ var EMPTY_STATE = Object.freeze({
   sessionCycles: []
 });
 function statePath2(repoRoot) {
-  return join52(repoRoot, ".anchorkit", "state.json");
+  return join53(repoRoot, ".anchorkit", "state.json");
 }
 function readState(repoRoot) {
   const p = statePath2(repoRoot);
-  if (!existsSync45(p))
+  if (!existsSync46(p))
     return cloneEmpty();
   try {
     const raw = readFileSync41(p, "utf-8");
@@ -93339,8 +93392,8 @@ Assistant: ${assistantText}`;
 };
 
 // src/hooks/conversation-mapping.ts
-import { existsSync as existsSync46, readFileSync as readFileSync42, writeFileSync as writeFileSync29 } from "node:fs";
-import { dirname as dirname20, isAbsolute as isAbsolute3, join as join53, relative as relative7, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync47, readFileSync as readFileSync42, writeFileSync as writeFileSync29 } from "node:fs";
+import { dirname as dirname20, isAbsolute as isAbsolute3, join as join54, relative as relative7, resolve as resolve5 } from "node:path";
 var MAX_PER_TURN = 5;
 var MAX_PER_SESSION2 = 10;
 var MAX_PER_HOUR2 = 30;
@@ -93375,7 +93428,7 @@ function slugForDir(repoRelDir) {
 }
 var INSIGHTS_HEADING = "## Conversation Insights";
 function appendConversationInsight(notePath, entry, now2 = new Date) {
-  if (!existsSync46(notePath))
+  if (!existsSync47(notePath))
     return false;
   let raw;
   try {
@@ -93421,7 +93474,7 @@ ${newEntry}
 async function emitFirstTouchModule(repoRoot) {
   try {
     const { resolveVaultConfig: resolveVaultConfig2 } = await Promise.resolve().then(() => (init_config(), exports_config));
-    const { indexCodebase: indexCodebase2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+    const { indexCodebase: indexCodebase2 } = await Promise.resolve().then(() => (init_indexing(), exports_indexing));
     const { runMapping: runMapping2 } = await Promise.resolve().then(() => (init_mapper(), exports_mapper));
     const cfg = resolveVaultConfig2(repoRoot);
     const index = await indexCodebase2(repoRoot);
@@ -93499,8 +93552,8 @@ var conversationMappingHook = {
         return;
       const assistantText = assistantTextFromEvents2(events);
       const substantive = assistantText.trim().length > SUBSTANTIVE_TEXT_CHARS;
-      const vaultPath = join53(ctx.repoRoot, ".anchorkit", "vault");
-      const knowledgeDir = join53(vaultPath, "knowledge");
+      const vaultPath = join54(ctx.repoRoot, ".anchorkit", "vault");
+      const knowledgeDir = join54(vaultPath, "knowledge");
       const emittedFiles = [];
       const turnId = turnIdFromEvents(events);
       let emittedThisTurn = 0;
@@ -93513,8 +93566,8 @@ var conversationMappingHook = {
         const slug = slugForDir(relDir);
         if (!slug)
           continue;
-        const notePath = join53(knowledgeDir, `module-${slug}.md`);
-        if (!existsSync46(notePath)) {
+        const notePath = join54(knowledgeDir, `module-${slug}.md`);
+        if (!existsSync47(notePath)) {
           if (!triggeredFirstTouch) {
             triggeredFirstTouch = true;
             const result = await emitFirstTouchModule(ctx.repoRoot);
@@ -93524,7 +93577,7 @@ var conversationMappingHook = {
               continue;
             }
           }
-          if (!existsSync46(notePath))
+          if (!existsSync47(notePath))
             continue;
           emittedFiles.push(notePath);
           emittedThisTurn += 1;
@@ -94155,8 +94208,8 @@ var injectContextHook = {
 };
 
 // src/services/specManager/index.ts
-import { existsSync as existsSync47, mkdirSync as mkdirSync27, readFileSync as readFileSync43, writeFileSync as writeFileSync30 } from "node:fs";
-import { join as join54 } from "node:path";
+import { existsSync as existsSync48, mkdirSync as mkdirSync27, readFileSync as readFileSync43, writeFileSync as writeFileSync30 } from "node:fs";
+import { join as join55 } from "node:path";
 function slugify5(input) {
   return input.toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "untitled";
 }
@@ -94164,10 +94217,10 @@ function nowIso2() {
   return new Date().toISOString();
 }
 function specsRoot(repoRoot) {
-  return join54(repoRoot, ".anchorkit", "specs");
+  return join55(repoRoot, ".anchorkit", "specs");
 }
 function manifestPath(repoRoot) {
-  return join54(specsRoot(repoRoot), "manifest.json");
+  return join55(specsRoot(repoRoot), "manifest.json");
 }
 function emptyManifest() {
   return {
@@ -94180,7 +94233,7 @@ function emptyManifest() {
 }
 function readManifest(repoRoot) {
   const mp = manifestPath(repoRoot);
-  if (!existsSync47(mp))
+  if (!existsSync48(mp))
     return emptyManifest();
   try {
     const raw = readFileSync43(mp, "utf-8");
@@ -94200,7 +94253,7 @@ function writeManifest(repoRoot, manifest) {
 function createFeatureSpec(repoRoot, title, opts = {}) {
   const manifest = readManifest(repoRoot);
   const slug = slugify5(title);
-  const dirPath = join54(specsRoot(repoRoot), "features", slug);
+  const dirPath = join55(specsRoot(repoRoot), "features", slug);
   mkdirSync27(dirPath, { recursive: true });
   const now2 = nowIso2();
   const spec = {
@@ -94234,7 +94287,7 @@ ${opts.summary ?? "_To be specified._"}
 
 - _None identified yet_
 `;
-  writeFileSync30(join54(dirPath, "spec.md"), specMd, "utf-8");
+  writeFileSync30(join55(dirPath, "spec.md"), specMd, "utf-8");
   manifest.features[slug] = spec;
   manifest.activeFeature = slug;
   writeManifest(repoRoot, manifest);
@@ -94266,7 +94319,7 @@ function createQuickTask(repoRoot, title) {
   const id = manifest.nextQuickId;
   const slug = slugify5(title);
   const dirName = `${String(id).padStart(3, "0")}-${slug}`;
-  const dirPath = join54(specsRoot(repoRoot), "quick", dirName);
+  const dirPath = join55(specsRoot(repoRoot), "quick", dirName);
   mkdirSync27(dirPath, { recursive: true });
   const now2 = nowIso2();
   const task = {
@@ -94290,15 +94343,15 @@ _${title}_
 
 - [ ] _Define completion criteria_
 `;
-  writeFileSync30(join54(dirPath, "TASK.md"), taskMd, "utf-8");
+  writeFileSync30(join55(dirPath, "TASK.md"), taskMd, "utf-8");
   manifest.quickTasks[dirName] = task;
   manifest.nextQuickId = id + 1;
   writeManifest(repoRoot, manifest);
   return task;
 }
 function readSpecFile(repoRoot, featureSlug, filename) {
-  const filePath = join54(specsRoot(repoRoot), "features", featureSlug, filename);
-  if (!existsSync47(filePath))
+  const filePath = join55(specsRoot(repoRoot), "features", featureSlug, filename);
+  if (!existsSync48(filePath))
     return null;
   try {
     return readFileSync43(filePath, "utf-8");
@@ -95371,16 +95424,16 @@ function createHookPipeline(opts = {}) {
 init_globalConfig();
 
 // src/vault/principles/loader.ts
-import { existsSync as existsSync48, readFileSync as readFileSync44 } from "node:fs";
-import { join as join55 } from "node:path";
+import { existsSync as existsSync49, readFileSync as readFileSync44 } from "node:fs";
+import { join as join56 } from "node:path";
 var PRINCIPLES_FILENAME = "_principles.md";
 function resolvePrinciplesPath(ref) {
-  return join55(ref.path, PRINCIPLES_FILENAME);
+  return join56(ref.path, PRINCIPLES_FILENAME);
 }
 function readPrinciples(ref) {
   const path4 = resolvePrinciplesPath(ref);
   try {
-    if (!existsSync48(path4))
+    if (!existsSync49(path4))
       return null;
     return readFileSync44(path4, "utf-8");
   } catch {
@@ -95470,16 +95523,16 @@ function runPrinciplesInjection() {
   return { systemPrompt: section2 };
 }
 // src/mcp-config/write.ts
-import { existsSync as existsSync49, mkdirSync as mkdirSync28, readFileSync as readFileSync45, writeFileSync as writeFileSync31 } from "node:fs";
-import { dirname as dirname21, join as join56, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync50, mkdirSync as mkdirSync28, readFileSync as readFileSync45, writeFileSync as writeFileSync31 } from "node:fs";
+import { dirname as dirname21, join as join57, resolve as resolve6 } from "node:path";
 var ANCHORKIT_SERVER_ENTRY = Object.freeze({
   command: "anchorkit",
   args: ["internal-mcp-server"]
 });
 function ensureMcpConfig(repoRoot) {
-  const claudeDir = join56(repoRoot, ".claude");
-  const configPath2 = join56(claudeDir, "mcp.json");
-  if (!existsSync49(configPath2)) {
+  const claudeDir = join57(repoRoot, ".claude");
+  const configPath2 = join57(claudeDir, "mcp.json");
+  if (!existsSync50(configPath2)) {
     mkdirSync28(dirname21(configPath2), { recursive: true });
     writeFileSync31(configPath2, renderFreshConfig(), "utf-8");
     return resolve6(configPath2);
@@ -95707,7 +95760,7 @@ function useSession(opts = {}) {
       memWatcherRef.current = null;
       return;
     }
-    const vaultPath = join57(cwd, ".anchorkit", "vault");
+    const vaultPath = join58(cwd, ".anchorkit", "vault");
     const w2 = createClaudeMemoryWatcher(cwd, vaultPath);
     w2.start();
     memWatcherRef.current = w2;
@@ -96317,7 +96370,7 @@ async function resolveTier() {
     return "free";
   }
 }
-var VERSION = "1.2.5-beta.3.1";
+var VERSION = "1.2.6-beta.3.1";
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
   console.log(`anchorkit v${VERSION}`);
@@ -96377,4 +96430,4 @@ if (args[0] === "internal-mcp-server") {
   });
 }
 
-//# debugId=005B574EAF1433C864756E2164756E21
+//# debugId=A11665494EE3CF2C64756E2164756E21