ultra11y 5.40.2 → 5.41.0

package/scripts/ultra11y.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { realpathSync as realpathSync6, writeFileSync as writeFileSync21, mkdirSync as mkdirSync18, existsSync as existsSync38, readFileSync as readFileSync34, appendFileSync, copyFileSync as copyFileSync4 } from "fs";
-import { join as join53, relative as relative6, resolve as resolve16, sep as sep7, dirname as dirname16 } from "path";
+import { realpathSync as realpathSync7, writeFileSync as writeFileSync21, mkdirSync as mkdirSync18, existsSync as existsSync38, readFileSync as readFileSync34, appendFileSync, copyFileSync as copyFileSync4 } from "fs";
+import { join as join53, relative as relative6, resolve as resolve16, sep as sep7, dirname as dirname17 } from "path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL3 } from "url";
 
 // src/types.ts
-var VERSION = "5.40.2";
+var VERSION = "5.41.0";
 var SCHEMA_VERSION = 2;
 var INAPPLICABLE_STATUS = "C";
 
@@ -19922,7 +19922,7 @@ function opaqueLibrarySpecifiers(ast, elements) {
 }
 
 // src/glob.ts
-import { existsSync as existsSync11, statSync as statSync6 } from "fs";
+import { existsSync as existsSync11, statSync as statSync10 } from "fs";
 import { join as join24, sep as sep3 } from "path";
 
 // src/util.ts
@@ -19958,13 +19958,18 @@ import { spawnSync } from "child_process";
 import { readdirSync, statSync, lstatSync, readFileSync as readFileSync2, realpathSync } from "fs";
 import { join, sep, extname as extname2 } from "path";
 import { createHash } from "crypto";
-import { readFileSync as readFileSync22, existsSync } from "fs";
+import { readFileSync as readFileSync22, existsSync, statSync as statSync2 } from "fs";
 import { homedir } from "os";
 import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 import { basename } from "path";
 import { readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
+import { existsSync as existsSync2, statSync as statSync3 } from "fs";
+import * as os from "os";
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+import { Worker } from "worker_threads";
 import { posix } from "path";
 import { join as join7 } from "path";
 import { posix as posix2 } from "path";
@@ -19972,11 +19977,11 @@ import { join as join8 } from "path";
 import { join as join9 } from "path";
 import { join as join10 } from "path";
 import { join as join11 } from "path";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
-import { join as join12 } from "path";
-import { mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4, join as join13 } from "path";
-import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { chmodSync, mkdtempSync as mkdtempSync2, readFileSync as readFileSync6, realpathSync as realpathSync2, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename3, dirname as dirname4, join as join12 } from "path";
+import { mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync3, statSync as statSync5, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname5, join as join13 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync6 } from "fs";
 import { join as join14 } from "path";
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync6, readFileSync as readFileSync8 } from "fs";
@@ -19991,16 +19996,11 @@ import { spawn } from "child_process";
 import { existsSync as existsSync9 } from "fs";
 import { join as join20 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
-import { statSync as statSync5 } from "fs";
+import { statSync as statSync7 } from "fs";
 import { join as join21 } from "path";
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync12, statSync as statSync8, watch as watchFs } from "fs";
 import { isAbsolute, join as join22 } from "path";
 import { createInterface } from "readline";
-import { existsSync as existsSync2, statSync as statSync2 } from "fs";
-import { availableParallelism } from "os";
-import { dirname as dirname2, join as join4 } from "path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
-import { Worker } from "worker_threads";
 import { basename as basename2 } from "path";
 import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
 import { join as join5 } from "path";
@@ -20009,12 +20009,17 @@ import { existsSync as existsSync4, mkdirSync, mkdtempSync, readFileSync as read
 import { dirname as dirname3, join as join6, resolve, sep as sep2 } from "path";
 import { gunzipSync } from "zlib";
 import { join as join15 } from "path";
-import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync13, statSync as statSync9, writeFileSync as writeFileSync4 } from "fs";
 import { join as join23, resolve as resolve4 } from "path";
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err2) => function __init() {
+  if (err2) throw err2[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err2 = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name2 in all)
@@ -20026,9 +20031,9 @@ var EXTRACTOR_VERSION;
 var init_types = __esm({
   "src/types.ts"() {
     "use strict";
-    ENGINE_VERSION = "2.28.0";
+    ENGINE_VERSION = "2.28.1";
     SCHEMA_VERSION2 = 5;
-    EXTRACTOR_VERSION = 13;
+    EXTRACTOR_VERSION = 14;
   }
 });
 function sh(cmd, args2, opts = {}) {
@@ -20354,6 +20359,9 @@ var init_ignore = __esm({
     init_util();
   }
 });
+function isIgnoredDirectory(name2, ignoreDirs) {
+  return ignoreDirs.has(name2) || name2.startsWith(".codeindex-edit-");
+}
 function walk(root, opts = {}) {
   const maxFileBytes = opts.maxFileBytes ?? 1024 * 1024;
   const maxFiles = opts.maxFiles ?? Infinity;
@@ -20402,7 +20410,7 @@ function walk(root, opts = {}) {
       const abs = join(frame.dir, name2);
       const rel2 = frame.rel ? `${frame.rel}/${name2}` : name2;
       const isLink = entry.isSymbolicLink();
-      if (entry.isDirectory() && ignoreDirs.has(name2)) continue;
+      if (entry.isDirectory() && isIgnoredDirectory(name2, ignoreDirs)) continue;
       let st;
       try {
         st = isLink ? statSync(abs) : lstatSync(abs);
@@ -20410,7 +20418,7 @@ function walk(root, opts = {}) {
         continue;
       }
       if (st.isDirectory()) {
-        if (ignoreDirs.has(name2)) continue;
+        if (isIgnoredDirectory(name2, ignoreDirs)) continue;
         if (isLink) continue;
         if (useGitignore && rules.length && isIgnored(rules, rel2, true)) continue;
         stack.push({ dir: abs, rel: rel2, rules });
@@ -25823,16 +25831,26 @@ async function ensureGrammars(keys) {
     parser = new Parser3();
   }
   for (const key2 of new Set(keys)) {
-    if (loaded.has(key2) || failed.has(key2)) continue;
+    if (loaded.has(key2)) continue;
     const wasm = firstIn(`${key2}.wasm`);
+    const fingerprint = wasm ? (() => {
+      try {
+        const st = statSync2(wasm);
+        return `${wasm}:${st.size}:${st.mtimeMs}`;
+      } catch {
+        return `${wasm}:unreadable`;
+      }
+    })() : `missing:${dirs.join("|")}`;
+    if (failed.get(key2) === fingerprint) continue;
     if (!wasm) {
-      failed.add(key2);
+      failed.set(key2, fingerprint);
       continue;
     }
     try {
       loaded.set(key2, await Language.load(new Uint8Array(readFileSync22(wasm))));
+      failed.delete(key2);
     } catch {
-      failed.add(key2);
+      failed.set(key2, fingerprint);
     }
   }
 }
@@ -25935,7 +25953,7 @@ var init_loader = __esm({
     runtimeReady = false;
     parser = null;
     loaded = /* @__PURE__ */ new Map();
-    failed = /* @__PURE__ */ new Set();
+    failed = /* @__PURE__ */ new Map();
   }
 });
 function findFirst(node, pred) {
@@ -28176,6 +28194,7 @@ function buildCodeRecord(rel2, ext2, size, content, hash, lang, opts = {}) {
     record.truncated = code2.truncated;
     record.relations = code2.relations;
     record.terms = code2.terms;
+    record.literals = code2.literals;
   } else {
     record.title = basename(rel2);
   }
@@ -28254,7 +28273,7 @@ function scanRepo(root, opts = {}) {
       files.push(preUsable.record);
       continue;
     }
-    const record = {
+    const record = kind === "code" ? buildCodeRecord(f.rel, f.ext, f.size, content, hash, lang, opts) : {
       rel: f.rel,
       ext: f.ext,
       size: f.size,
@@ -28266,37 +28285,21 @@ function scanRepo(root, opts = {}) {
       symbols: [],
       refs: []
     };
-    if (content) {
-      if (kind === "doc" && MARKDOWN_EXT.has(f.ext)) {
+    if (kind !== "code") {
+      if (content && kind === "doc" && MARKDOWN_EXT.has(f.ext)) {
         const md = extractMarkdown(content);
         record.title = md.title ?? basename(f.rel);
         record.summary = md.summary;
         record.headings = md.headings;
         record.refs = md.refs;
-      } else if (kind === "doc") {
-        record.title = basename(f.rel);
-      } else if (kind === "code") {
-        const code2 = extractCode(f.rel, f.ext, content, { maxCallsPerFile: opts.maxCallsPerFile });
+      } else if (content && kind === "doc") {
         record.title = basename(f.rel);
-        record.summary = code2.summary;
-        record.symbols = code2.symbols;
-        record.refs = code2.refs;
-        record.pkg = code2.pkg;
-        record.idents = code2.idents;
-        record.calls = code2.calls;
-        record.importedNames = code2.importedNames;
-        record.truncated = code2.truncated;
-        record.relations = code2.relations;
-        record.terms = code2.terms;
-        record.literals = code2.literals;
-      } else if (kind === "config") {
+      } else if (content && kind === "config") {
         record.title = basename(f.rel);
         record.literals = extractConfigLiterals(content);
       } else {
         record.title = basename(f.rel);
       }
-    } else {
-      record.title = basename(f.rel);
     }
     if (kind === "doc" && content) docText.set(f.rel, content);
     files.push(record);
@@ -28339,6 +28342,13 @@ function toCacheMap(scan2) {
   for (const f of scan2.files) m.set(f.rel, { hash: f.hash, record: f, size: f.size, mtimeMs: scan2.mtimes.get(f.rel) });
   return m;
 }
+function needsGrammarWarm(walked, cache, fullHash = false) {
+  const codeFiles = walked.files.filter((file) => classify(file.rel, file.ext) === "code");
+  return fullHash && codeFiles.length > 0 || codeFiles.some((file) => {
+    const cached = cache.get(file.rel);
+    return !cached || cached.size !== file.size || cached.mtimeMs !== file.mtimeMs;
+  });
+}
 function readPersistedIndex(repo, indexDir = INDEX_DIR) {
   let parsed;
   try {
@@ -28390,6 +28400,34 @@ function preloadSession(repo, opts, indexDir = INDEX_DIR) {
   const scan2 = scanRepo(repo, { ...opts, cache: persisted.cacheMap });
   return { scan: scan2, cacheMap: toCacheMap(scan2), arts: preloadArtifacts(repo, scan2, persisted.meta, indexDir) };
 }
+async function preloadSessionLazy(repo, opts, warm, indexDir = INDEX_DIR) {
+  const persisted = readPersistedIndex(repo, indexDir);
+  if (!persisted) return void 0;
+  const walked = opts.precomputedWalk ?? walk(repo, {
+    maxFileBytes: opts.maxBytes,
+    maxFiles: opts.maxFiles,
+    gitignore: opts.gitignore,
+    ignoreDirs: opts.ignoreDirs
+  });
+  const needsWarm = needsGrammarWarm(walked, persisted.cacheMap, opts.fullHash);
+  if (needsWarm) {
+    await warm();
+  }
+  const scan2 = scanRepo(repo, { ...opts, cache: persisted.cacheMap, precomputedWalk: walked });
+  let artifactsTried = false;
+  let artifacts;
+  return {
+    scan: scan2,
+    cacheMap: toCacheMap(scan2),
+    loadArtifacts: () => {
+      if (!artifactsTried) {
+        artifactsTried = true;
+        artifacts = preloadArtifacts(repo, scan2, persisted.meta, indexDir);
+      }
+      return artifacts;
+    }
+  };
+}
 var INDEX_DIR;
 var init_preload = __esm({
   "src/preload.ts"() {
@@ -28397,9 +28435,144 @@ var init_preload = __esm({
     init_types();
     init_scan();
     init_hash();
+    init_walk();
+    init_classify();
     INDEX_DIR = ".codeindex";
   }
 });
+function resolveEngineUrl() {
+  try {
+    const here = fileURLToPath2(import.meta.url);
+    if (here.endsWith("engine.mjs")) return pathToFileURL(here).href;
+    const adjacent = join4(dirname2(here), "engine.mjs");
+    if (existsSync2(adjacent)) return pathToFileURL(adjacent).href;
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function workerCount(requested) {
+  const env = process.env["CODEINDEX_WORKERS"];
+  const raw = requested ?? (env !== void 0 && env !== "" ? Number(env) : void 0);
+  if (raw !== void 0) return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 0;
+  let cores = 1;
+  try {
+    cores = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length;
+  } catch {
+    cores = 1;
+  }
+  return Math.max(0, Math.min(cores - 1, 8));
+}
+async function runExtractWorker(input, post) {
+  await ensureGrammars(input.grammarKeys);
+  const ready = input.grammarKeys.filter((k) => grammarReady(k));
+  const records = [];
+  for (const job of input.jobs) {
+    let size;
+    let mtimeMs;
+    try {
+      const st = statSync3(job.abs);
+      size = st.size;
+      mtimeMs = st.mtimeMs;
+    } catch {
+      continue;
+    }
+    const content = readText2(job.abs);
+    const record = buildCodeRecord(job.rel, job.ext, size, content, sha1(content), extToLang(job.ext), {
+      maxCallsPerFile: input.maxCallsPerFile
+    });
+    records.push({ rel: job.rel, size, mtimeMs, record });
+  }
+  post({ ready, records });
+}
+async function extractInParallel(jobs, grammarKeys, count, opts = {}) {
+  if (count < 2 || jobs.length === 0) return void 0;
+  const engineUrl = resolveEngineUrl();
+  if (!engineUrl) return void 0;
+  const wanted = grammarKeys.filter((k) => grammarReady(k)).sort();
+  const shards = Array.from({ length: Math.min(count, jobs.length) }, () => []);
+  jobs.forEach((j, i2) => shards[i2 % shards.length].push(j));
+  const bootstrap = `import { runExtractWorker } from ${JSON.stringify(engineUrl)};
+import { parentPort, workerData } from "node:worker_threads";
+runExtractWorker(workerData.input, (o) => parentPort.postMessage(o)).catch((e) => parentPort.postMessage({ error: String(e) }));
+`;
+  try {
+    const outputs = await Promise.all(
+      shards.map(
+        (jobsForShard) => new Promise((resolve52, reject) => {
+          const w = new Worker(bootstrap, {
+            eval: true,
+            workerData: { input: { jobs: jobsForShard, grammarKeys: wanted, maxCallsPerFile: opts.maxCallsPerFile } }
+          });
+          const timer = setTimeout(() => {
+            reject(new Error("extraction worker timed out"));
+            void w.terminate();
+          }, WORKER_TIMEOUT_MS);
+          const settle = (fn) => {
+            clearTimeout(timer);
+            fn();
+          };
+          w.once("message", (m) => {
+            settle(() => resolve52(m));
+            void w.terminate();
+          });
+          w.once("error", (e) => settle(() => reject(e)));
+          w.once("exit", (code2) => {
+            if (code2 !== 0) settle(() => reject(new Error(`extraction worker exited with ${code2}`)));
+          });
+        })
+      )
+    );
+    const out2 = /* @__PURE__ */ new Map();
+    for (const o of outputs) {
+      if ("error" in o) return void 0;
+      if (o.ready.slice().sort().join(",") !== wanted.join(",")) return void 0;
+      for (const r of o.records) out2.set(r.rel, { size: r.size, mtimeMs: r.mtimeMs, record: r.record });
+    }
+    return out2;
+  } catch {
+    return void 0;
+  }
+}
+async function scanRepoParallel(root, opts = {}) {
+  const count = workerCount(opts.workers);
+  if (count < 2) return scanRepo(root, opts);
+  const walked = opts.precomputedWalk ?? walk(root, {
+    maxFileBytes: opts.maxBytes,
+    maxFiles: opts.maxFiles,
+    gitignore: opts.gitignore,
+    ignoreDirs: opts.ignoreDirs
+  });
+  const scanOpts = { ...opts, precomputedWalk: walked };
+  const jobs = [];
+  for (const { f } of keptCodeFiles(root, scanOpts)) {
+    const cached = opts.cache?.get(f.rel);
+    if (!opts.fullHash && cached && cached.size !== void 0 && cached.mtimeMs !== void 0 && cached.size === f.size && cached.mtimeMs === f.mtimeMs) {
+      continue;
+    }
+    jobs.push({ abs: f.abs, rel: f.rel, ext: f.ext });
+  }
+  if (jobs.length === 0) return scanRepo(root, scanOpts);
+  const workersForced = opts.workers !== void 0 || (process.env["CODEINDEX_WORKERS"] ?? "") !== "";
+  if (!workersForced && jobs.length < DEFAULT_MIN_PARALLEL_JOBS) return scanRepo(root, scanOpts);
+  const grammarKeys = grammarKeysForExts(walked.files.map((f) => f.ext));
+  const extracted = await extractInParallel(jobs, grammarKeys, count, { maxCallsPerFile: opts.maxCallsPerFile });
+  return scanRepo(root, extracted ? { ...scanOpts, extracted } : scanOpts);
+}
+var WORKER_TIMEOUT_MS;
+var DEFAULT_MIN_PARALLEL_JOBS;
+var init_pool = __esm({
+  "src/pool.ts"() {
+    "use strict";
+    init_hash();
+    init_walk();
+    init_registry();
+    init_loader();
+    init_scan();
+    WORKER_TIMEOUT_MS = 10 * 60 * 1e3;
+    DEFAULT_MIN_PARALLEL_JOBS = 200;
+  }
+});
 function distToSrcCandidates(target) {
   const segs = norm(target).split("/").filter((s) => s !== ".");
   const out2 = [];
@@ -29512,6 +29685,17 @@ function buildCallerIndex(scan2, importPairs, opts = {}) {
       arr.push(s);
     }
   }
+  const defsByFamily = /* @__PURE__ */ new Map();
+  for (const [name2, sites2] of defs) {
+    const families = /* @__PURE__ */ new Map();
+    for (const site of sites2) {
+      const family = familyOf(site.lang);
+      let grouped = families.get(family);
+      if (!grouped) families.set(family, grouped = []);
+      grouped.push(site);
+    }
+    defsByFamily.set(name2, families);
+  }
   const localDefs = /* @__PURE__ */ new Map();
   for (const f of scan2.files) {
     const byName = /* @__PURE__ */ new Map();
@@ -29537,7 +29721,7 @@ function buildCallerIndex(scan2, importPairs, opts = {}) {
           record(local, recall ? { file: f.rel, line: c2.line, confidence: "corroborated" } : { file: f.rel, line: c2.line });
         continue;
       }
-      const cands = (defs.get(c2.name) ?? []).filter((d) => familyOf(d.lang) === family && d.file !== f.rel).map((d) => ({ file: d.file, lang: d.lang }));
+      const cands = (defsByFamily.get(c2.name)?.get(family) ?? []).filter((d) => d.file !== f.rel);
       if (!cands.length) continue;
       const imported = cands.filter((d) => pairs.has(`${f.rel}|${d.file}`));
       const chosen = family === "js" ? imported.length ? pickCandidate(f.rel, imported) : (
@@ -29546,7 +29730,7 @@ function buildCallerIndex(scan2, importPairs, opts = {}) {
         recall && cands.length === 1 ? cands[0] : void 0
       ) : imported.length ? pickCandidate(f.rel, imported) : pickCandidate(f.rel, cands);
       if (!chosen) continue;
-      const def = defs.get(c2.name).find((d) => d.file === chosen.file);
+      const def = chosen;
       record(
         def,
         recall ? { file: f.rel, line: c2.line, confidence: imported.length ? "corroborated" : "unique-name" } : { file: f.rel, line: c2.line }
@@ -30328,6 +30512,25 @@ function cacheFor(scan2) {
   if (!c2) caches.set(scan2, c2 = {});
   return c2;
 }
+function fileByRelFor(scan2) {
+  const c2 = cacheFor(scan2);
+  return c2.fileByRel ??= new Map(scan2.files.map((file) => [file.rel, file]));
+}
+function symbolsByNameFor(scan2) {
+  const c2 = cacheFor(scan2);
+  if (!c2.symbolsByName) {
+    const byName = /* @__PURE__ */ new Map();
+    for (const file of scan2.files) {
+      for (const symbol of file.symbols) {
+        const group = byName.get(symbol.name);
+        if (group) group.push(symbol);
+        else byName.set(symbol.name, [symbol]);
+      }
+    }
+    c2.symbolsByName = byName;
+  }
+  return c2.symbolsByName;
+}
 function resolveContextFor(scan2) {
   const c2 = cacheFor(scan2);
   return c2.resolveCtx ??= buildResolveContext(scan2);
@@ -30630,8 +30833,11 @@ var init_graph = __esm({
     keyOf = (from, to, kind) => `${from}${SEP3}${to}${SEP3}${kind}`;
   }
 });
+function* allSymbols(scan2) {
+  for (const file of scan2.files) yield* file.symbols;
+}
 function symbolsOverview(scan2, rel2) {
-  const f = scan2.files.find((x) => x.rel === rel2);
+  const f = fileByRelFor(scan2).get(rel2);
   if (!f) return [];
   return [...f.symbols].filter((s) => !REFERENCE_KINDS5.has(s.kind)).sort((a, b) => a.line - b.line || byStr(a.name, b.name));
 }
@@ -30642,27 +30848,37 @@ function findSymbol(scan2, namePath, opts = {}) {
   const parents = segments.slice(0, -1);
   const matchName = (name2, wanted) => opts.substring ? name2.toLowerCase().includes(wanted.toLowerCase()) : name2 === wanted;
   const out2 = [];
-  for (const f of scan2.files) {
-    for (const s of f.symbols) {
-      if (REFERENCE_KINDS5.has(s.kind)) continue;
-      if (!matchName(s.name, leaf)) continue;
-      if (parents.length) {
-        const parent = parents[parents.length - 1];
-        if (!s.parent || s.parent !== parent) continue;
-      }
-      out2.push({ ...s });
+  const candidates2 = opts.substring ? allSymbols(scan2) : symbolsByNameFor(scan2).get(leaf) ?? [];
+  for (const s of candidates2) {
+    if (REFERENCE_KINDS5.has(s.kind)) continue;
+    if (!matchName(s.name, leaf)) continue;
+    if (parents.length) {
+      const parent = parents[parents.length - 1];
+      if (!s.parent || s.parent !== parent) continue;
     }
+    out2.push({ ...s });
   }
   out2.sort(
     (a, b) => Number(b.name === leaf) - Number(a.name === leaf) || byStr(a.file, b.file) || a.line - b.line
   );
   const capped = out2.slice(0, opts.maxResults ?? 50);
   if (opts.includeBody) {
+    const linesByFile = /* @__PURE__ */ new Map();
+    const unreadableFiles = /* @__PURE__ */ new Set();
     for (const m of capped) {
       const end = m.endLine ?? m.line;
-      const content = readText2(join11(scan2.root, m.file));
-      if (!content) continue;
-      m.body = content.split("\n").slice(m.line - 1, end).join("\n");
+      if (unreadableFiles.has(m.file)) continue;
+      let lines = linesByFile.get(m.file);
+      if (!lines) {
+        const content = readText2(join11(scan2.root, m.file));
+        if (!content) {
+          unreadableFiles.add(m.file);
+          continue;
+        }
+        lines = content.split("\n");
+        linesByFile.set(m.file, lines);
+      }
+      m.body = lines.slice(m.line - 1, end).join("\n");
     }
   }
   if (opts.concise) {
@@ -30727,6 +30943,34 @@ function resolveUniqueSymbol(scan2, namePath, file) {
 function readLines(abs) {
   return readFileSync6(abs, "utf8").split("\n");
 }
+function atomicWriteText(abs, content, cleanup = rmSync2) {
+  const target = realpathSync2(abs);
+  const mode = statSync4(target).mode;
+  let tempDir;
+  try {
+    tempDir = mkdtempSync2(join12(dirname4(target), ".codeindex-edit-"));
+  } catch {
+    writeFileSync2(target, content);
+    chmodSync(target, mode);
+    return;
+  }
+  const tempFile = join12(tempDir, basename3(target));
+  try {
+    writeFileSync2(tempFile, content);
+    chmodSync(tempFile, mode);
+    try {
+      renameSync2(tempFile, target);
+    } catch {
+      writeFileSync2(target, content);
+      chmodSync(target, mode);
+    }
+  } finally {
+    try {
+      cleanup(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
 function replaceSymbolBody(scan2, namePath, body22, file) {
   const sym = resolveUniqueSymbol(scan2, namePath, file);
   const end = sym.endLine ?? sym.line;
@@ -30734,7 +30978,7 @@ function replaceSymbolBody(scan2, namePath, body22, file) {
   const lines = readLines(abs);
   const newLines = body22.replace(/^\n+|\n+$/g, "").split("\n");
   lines.splice(sym.line - 1, end - sym.line + 1, ...newLines);
-  writeFileSync2(abs, lines.join("\n"));
+  atomicWriteText(abs, lines.join("\n"));
   return { file: sym.file, startLine: sym.line, endLine: sym.line + newLines.length - 1, lines: newLines.length };
 }
 function insertAt(scan2, sym, body22, index, blankBefore, blankAfter) {
@@ -30747,7 +30991,7 @@ function insertAt(scan2, sym, body22, index, blankBefore, blankAfter) {
   block.push(...newLines);
   if (blankAfter && minGap && lines[index]?.trim() !== "") block.push("");
   lines.splice(index, 0, ...block);
-  writeFileSync2(abs, lines.join("\n"));
+  atomicWriteText(abs, lines.join("\n"));
   return { file: sym.file, startLine: index + 1, endLine: index + block.length, lines: block.length };
 }
 function insertAfterSymbol(scan2, namePath, body22, file) {
@@ -30784,7 +31028,7 @@ function memoryPath(repo, name2) {
 }
 function writeMemory(repo, name2, content) {
   const path = memoryPath(repo, name2);
-  mkdirSync2(dirname4(path), { recursive: true });
+  mkdirSync2(dirname5(path), { recursive: true });
   writeFileSync3(path, content.endsWith("\n") ? content : content + "\n");
   return sanitize(name2);
 }
@@ -30798,11 +31042,11 @@ function readMemory(repo, name2) {
 function deleteMemory(repo, name2) {
   const path = memoryPath(repo, name2);
   try {
-    statSync3(path);
+    statSync5(path);
   } catch {
     return false;
   }
-  rmSync2(path);
+  rmSync3(path);
   return true;
 }
 function listMemories(repo) {
@@ -30997,7 +31241,7 @@ function addPackage(root, dir, found, kind, warnings) {
 }
 function isDirAt(root, rel2) {
   try {
-    return statSync4(join14(root, rel2)).isDirectory();
+    return statSync6(join14(root, rel2)).isDirectory();
   } catch {
     return false;
   }
@@ -32155,31 +32399,31 @@ function serializeEmbeddings(index) {
     count: index.records.length,
     records: index.records.map((r) => ({ file: r.file, symbol: r.symbol ?? "", line: r.line ?? 0 }))
   });
-  const headerBuf = Buffer.from(header4, "utf8");
-  const body22 = Buffer.alloc(index.records.length * index.dim);
-  let off = 0;
+  const headerBuf = new TextEncoder().encode(header4);
+  const bodyLength = index.records.length * index.dim;
+  const out2 = new Uint8Array(8 + headerBuf.length + bodyLength);
+  out2.set([67, 73, 69, 49], 0);
+  new DataView(out2.buffer, out2.byteOffset, out2.byteLength).setUint32(4, headerBuf.length, true);
+  out2.set(headerBuf, 8);
+  let off = 8 + headerBuf.length;
   for (const r of index.records) {
-    for (let d = 0; d < index.dim; d++) body22.writeInt8(r.vec[d] ?? 0, off++);
+    for (let d = 0; d < index.dim; d++) out2[off++] = r.vec[d] ?? 0;
   }
-  const out2 = Buffer.alloc(8 + headerBuf.length + body22.length);
-  out2.write(MAGIC, 0, "ascii");
-  out2.writeUInt32LE(headerBuf.length, 4);
-  headerBuf.copy(out2, 8);
-  body22.copy(out2, 8 + headerBuf.length);
   return out2;
 }
 function deserializeEmbeddings(bytes) {
-  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  if (buf.length < 8 || buf.toString("ascii", 0, 4) !== MAGIC) {
+  if (bytes.byteLength < 8 || String.fromCharCode(...bytes.subarray(0, 4)) !== MAGIC) {
     throw new Error("embeddings.bin: bad magic (not a codeindex embeddings artifact)");
   }
-  const headerLen = buf.readUInt32LE(4);
-  const header4 = JSON.parse(buf.toString("utf8", 8, 8 + headerLen));
+  const data2 = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const headerLen = data2.getUint32(4, true);
+  if (8 + headerLen > bytes.byteLength) throw new Error("embeddings.bin: truncated header");
+  const header4 = JSON.parse(new TextDecoder().decode(bytes.subarray(8, 8 + headerLen)));
   const bodyOff = 8 + headerLen;
   const { dim } = header4;
+  if (bodyOff + header4.records.length * dim > bytes.byteLength) throw new Error("embeddings.bin: truncated body");
   const records = header4.records.map((m, i2) => {
-    const vec = new Int8Array(dim);
-    for (let d = 0; d < dim; d++) vec[d] = buf.readInt8(bodyOff + i2 * dim + d);
+    const vec = new Int8Array(bytes.buffer.slice(bytes.byteOffset + bodyOff + i2 * dim, bytes.byteOffset + bodyOff + (i2 + 1) * dim));
     const rec = { file: m.file, vec };
     if (m.symbol) rec.symbol = m.symbol;
     if (m.line) rec.line = m.line;
@@ -32546,18 +32790,33 @@ function createFramer() {
   };
 }
 function fileUri(root, rel2) {
-  const abs = `${root.replace(/\/+$/, "")}/${rel2.replace(/^\/+/, "")}`;
+  const rootPath = root.replace(/\\/g, "/").replace(/\/+$/, "");
+  const relPath = rel2.replace(/\\/g, "/").replace(/^\/+/, "");
+  const abs = `${rootPath}/${relPath}`;
+  if (abs.startsWith("//")) {
+    const [host = "", ...segments] = abs.slice(2).split("/");
+    return `file://${encodeURIComponent(host)}/${segments.map(encodeURIComponent).join("/")}`;
+  }
   const drive = /^([A-Za-z]):/.exec(abs);
   const path = drive ? `/${abs}` : abs;
-  return "file://" + path.split("/").map((segment, i2) => i2 === 0 ? segment : encodeURIComponent(segment)).join("/");
+  return "file://" + path.split("/").map((segment, i2) => i2 === 0 || i2 === 1 && /^[A-Za-z]:$/.test(segment) ? segment : encodeURIComponent(segment)).join("/");
 }
 function relFromUri(root, uri) {
   if (!uri.startsWith("file://")) return void 0;
-  let path = decodeURIComponent(uri.slice("file://".length));
+  let path;
+  try {
+    const encoded = uri.slice("file://".length);
+    path = decodeURIComponent(encoded.startsWith("/") ? encoded : `//${encoded}`).replace(/\\/g, "/");
+  } catch {
+    return void 0;
+  }
   if (/^\/[A-Za-z]:/.test(path)) path = path.slice(1);
-  const base = root.replace(/\/+$/, "");
-  if (path === base) return "";
-  if (!path.startsWith(`${base}/`)) return void 0;
+  const base = root.replace(/\\/g, "/").replace(/\/+$/, "");
+  const windows = /^[A-Za-z]:/.test(base) || base.startsWith("//");
+  const comparablePath = windows ? path.toLowerCase() : path;
+  const comparableBase = windows ? base.toLowerCase() : base;
+  if (comparablePath === comparableBase) return "";
+  if (!comparablePath.startsWith(`${comparableBase}/`)) return void 0;
   return path.slice(base.length + 1);
 }
 function locationsToRefs(root, raw) {
@@ -33350,9 +33609,13 @@ function validateArgs(schema, args2) {
     if (!spec?.type) continue;
     const actual = Array.isArray(value) ? "array" : typeof value;
     if (spec.type === "number") {
-      if (actual === "number") continue;
-      if (actual === "string" && Number.isFinite(Number(value)) && value.trim() !== "") continue;
-      return `\`${key2}\` must be a number, got ${actual === "string" ? JSON.stringify(value) : actual}`;
+      const numeric = actual === "number" ? value : actual === "string" && value.trim() !== "" ? Number(value) : NaN;
+      if (!Number.isFinite(numeric)) {
+        return `\`${key2}\` must be a number, got ${actual === "string" ? JSON.stringify(value) : actual}`;
+      }
+      if (spec.minimum !== void 0 && numeric < spec.minimum) return `\`${key2}\` must be at least ${spec.minimum}`;
+      if (spec.maximum !== void 0 && numeric > spec.maximum) return `\`${key2}\` must be at most ${spec.maximum}`;
+      continue;
     }
     if (spec.type === "array") {
       if (actual !== "array") return `\`${key2}\` must be an array of strings, got ${actual}`;
@@ -33580,7 +33843,7 @@ var init_tools = __esm({
               type: "boolean",
               description: "Return only name/kind/file/line \u2014 drop the signature, line span, visibility and language. Roughly 2.5x smaller; use it when you are resolving a path and nothing more (default false)."
             },
-            maxResults: { type: "number", description: "Cap matches (default 50)" }
+            maxResults: { type: "number", minimum: 1, description: "Cap matches (default 50)" }
           },
           required: ["repo", "namePath"]
         }
@@ -33620,7 +33883,7 @@ var init_tools = __esm({
           type: "object",
           properties: {
             ...repoProp,
-            budgetTokens: { type: "number", description: "Token budget for the key-files section (default 900)" },
+            budgetTokens: { type: "number", minimum: 1, description: "Token budget for the key-files section (default 900)" },
             remember: { type: "boolean", description: "Persist the brief as the `onboarding` memory (default true)" }
           },
           required: ["repo"]
@@ -33631,7 +33894,7 @@ var init_tools = __esm({
         description: "Token-budgeted map of the repository: the highest-PageRank files with their key exported signatures, deterministically rendered to fit `budgetTokens` (default 1024). The densest single read to understand an unfamiliar codebase.",
         inputSchema: {
           type: "object",
-          properties: { ...repoProp, budgetTokens: { type: "number", description: "Approximate token budget (default 1024)" } },
+          properties: { ...repoProp, budgetTokens: { type: "number", minimum: 1, description: "Approximate token budget (default 1024)" } },
           required: ["repo"]
         }
       },
@@ -33725,7 +33988,7 @@ var init_tools = __esm({
           properties: {
             ...repoProp,
             ...scopeProps,
-            limit: { type: "number", description: "Cap entries (default: all)" }
+            limit: { type: "number", minimum: 0, description: "Cap entries (default: all)" }
           },
           required: ["repo"]
         }
@@ -33738,10 +34001,10 @@ var init_tools = __esm({
           properties: {
             ...repoProp,
             ...scopeProps,
-            minFiles: { type: "number", description: "Distinct files a value must span (default 2)" },
-            minCount: { type: "number", description: "Total occurrences required (default 3)" },
+            minFiles: { type: "number", minimum: 1, description: "Distinct files a value must span (default 2)" },
+            minCount: { type: "number", minimum: 1, description: "Total occurrences required (default 3)" },
             includeTests: { type: "boolean", description: "Count test files too (default false)" },
-            limit: { type: "number", description: "Cap duplications (default: all)" }
+            limit: { type: "number", minimum: 0, description: "Cap duplications (default: all)" }
           },
           required: ["repo"]
         }
@@ -33751,7 +34014,13 @@ var init_tools = __esm({
         description: "Cyclomatic-complexity estimates (branch-token counting over AST line spans), most-complex first. Pass `file` for one file's symbols, omit for the repo-wide top. Combine with hotspots: the `risk` field of this tool's sibling ranks complexity \xD7 churn.",
         inputSchema: {
           type: "object",
-          properties: { ...repoProp, file: { type: "string" }, risk: { type: "boolean", description: "Return complexity \xD7 git-churn risk ranking instead" } },
+          properties: {
+            ...repoProp,
+            file: { type: "string" },
+            risk: { type: "boolean", description: "Return complexity \xD7 git-churn risk ranking instead" },
+            since: { type: "string", description: "Only count risk churn after this ref" },
+            top: { type: "number", minimum: 1, description: "Cap ranked symbols" }
+          },
           required: ["repo"]
         }
       },
@@ -33760,7 +34029,11 @@ var init_tools = __esm({
         description: "Mermaid diagram of the module graph (renders inline in Claude/GitHub \u2014 no graph database). Optionally scoped to one module's neighborhood.",
         inputSchema: {
           type: "object",
-          properties: { ...repoProp, module: { type: "string", description: "Module slug to focus on" } },
+          properties: {
+            ...repoProp,
+            module: { type: "string", description: "Module slug to focus on" },
+            maxEdges: { type: "number", minimum: 1, description: "Cap rendered edges" }
+          },
           required: ["repo"]
         }
       },
@@ -33775,7 +34048,7 @@ var init_tools = __esm({
             scope: { type: "string", description: "Restrict to one directory (repo-relative)" },
             globs: { type: "array", items: { type: "string" }, description: "Restrict to matching paths" },
             ignoreCase: { type: "boolean" },
-            maxHits: { type: "number" }
+            maxHits: { type: "number", minimum: 1 }
           },
           required: ["repo", "pattern"]
         }
@@ -33789,7 +34062,7 @@ var init_tools = __esm({
             ...repoProp,
             ...scopeProps,
             query: { type: "string", description: "Natural-language or identifier query" },
-            limit: { type: "number", description: "Max results (default 20)" },
+            limit: { type: "number", minimum: 0, description: "Max results (default 20)" },
             fuzzy: {
               type: "boolean",
               description: 'Fallback for query terms with zero document frequency: a morphological stem match first ("caching" finds "cache"), then trigram similarity for typos (default true)'
@@ -33823,7 +34096,7 @@ var init_tools = __esm({
             ...repoProp,
             ...scopeProps,
             query: { type: "string", description: "Natural-language or identifier query" },
-            limit: { type: "number", description: "Max results (default 20)" },
+            limit: { type: "number", minimum: 0, description: "Max results (default 20)" },
             fuzzy: { type: "boolean", description: "Stem/trigram fallback for zero-document-frequency terms (default true)" },
             exact: { type: "boolean", description: "Drop results carrying no verbatim term match (default false)" }
           },
@@ -33861,7 +34134,7 @@ var init_tools = __esm({
           properties: {
             ...repoProp,
             symbol: { type: "string", description: "Symbol name to centre on" },
-            depth: { type: "number", description: "Hops to follow (default 2, max 5)" },
+            depth: { type: "number", minimum: 1, maximum: 5, description: "Hops to follow (default 2, max 5)" },
             direction: { type: "string", description: "out | in | both (default both)" }
           },
           required: ["repo", "symbol"]
@@ -34125,7 +34398,7 @@ async function memoizedEmbeddingIndex(key2, build) {
 function memoizedEmbedModel(modelDir) {
   let stat;
   try {
-    stat = statSync5(join21(modelDir, "model.json"));
+    stat = statSync7(join21(modelDir, "model.json"));
   } catch {
     return void 0;
   }
@@ -34152,6 +34425,14 @@ function sessionPut(entry) {
 function sessionClear() {
   sessionCaches.length = 0;
 }
+function sessionInvalidate(repo, rel2) {
+  const prefix2 = repo + "\0";
+  for (const entry of sessionCaches) {
+    if (!entry.key.startsWith(prefix2)) continue;
+    if (rel2) entry.cacheMap.delete(rel2);
+    else entry.cacheMap.clear();
+  }
+}
 function sessionKey(repo, opts) {
   return repo + "\0" + JSON.stringify({
     scope: opts.scope,
@@ -34173,7 +34454,11 @@ function getScan(repo, opts = {}, walked) {
     const fresh = scanRepo(repo, { ...opts, cache: hit.cacheMap, precomputedWalk: walked });
     if (fresh.contentUnchanged) {
       if (fresh.cacheDirty) hit.cacheMap = toCacheMap(fresh);
-      if (hit.scan.commit !== fresh.commit) hit.scan.commit = fresh.commit;
+      if (hit.scan.commit !== fresh.commit) {
+        hit.scan.commit = fresh.commit;
+        hit.arts = void 0;
+        hit.loadArtifacts = void 0;
+      }
       return hit.scan;
     }
     sessionPut({ key: key2, scan: fresh, cacheMap: toCacheMap(fresh) });
@@ -34181,31 +34466,77 @@ function getScan(repo, opts = {}, walked) {
   }
   const preloaded = preloadSession(repo, { ...opts, precomputedWalk: walked });
   if (preloaded) {
-    sessionPut({ key: key2, scan: preloaded.scan, cacheMap: preloaded.cacheMap, arts: preloaded.arts });
+    sessionPut({
+      key: key2,
+      scan: preloaded.scan,
+      cacheMap: preloaded.cacheMap,
+      arts: preloaded.arts
+    });
     return preloaded.scan;
   }
   const scan2 = scanRepo(repo, { ...opts, precomputedWalk: walked });
   sessionPut({ key: key2, scan: scan2, cacheMap: toCacheMap(scan2) });
   return scan2;
 }
-function getScanSummary(repo, opts = {}, walked) {
-  if (sessionCaches.some((e) => e.key === sessionKey(repo, opts))) {
-    const scan2 = getScan(repo, opts, walked);
-    return {
-      root: scan2.root,
-      commit: scan2.commit,
-      fileCount: scan2.files.length,
-      languages: scan2.languages,
-      capped: scan2.capped,
-      excluded: scan2.excluded
+async function getScanParallel(repo, opts = {}, walked, warm = async () => {
+}) {
+  const key2 = sessionKey(repo, opts);
+  const existing = sessionCaches.find((entry) => entry.key === key2);
+  if (existing) {
+    const originalCache = existing.cacheMap;
+    const reuseUnchanged = (fresh) => {
+      if (fresh.cacheDirty) existing.cacheMap = toCacheMap(fresh);
+      if (existing.scan.commit !== fresh.commit) {
+        existing.scan.commit = fresh.commit;
+        existing.arts = void 0;
+        existing.loadArtifacts = void 0;
+      }
+      sessionGet(key2);
+      return existing.scan;
     };
+    if (walked && needsGrammarWarm(walked, originalCache, opts.fullHash)) {
+      await warm();
+      const fresh = await scanRepoParallel(repo, { ...opts, cache: originalCache, precomputedWalk: walked });
+      if (fresh.contentUnchanged) return reuseUnchanged(fresh);
+      sessionPut({ key: key2, scan: fresh, cacheMap: toCacheMap(fresh) });
+      return fresh;
+    }
+    const provisional = scanRepo(repo, { ...opts, cache: originalCache, precomputedWalk: walked });
+    if (provisional.contentUnchanged) {
+      return reuseUnchanged(provisional);
+    }
+    if (walked) {
+      sessionPut({ key: key2, scan: provisional, cacheMap: toCacheMap(provisional) });
+      return provisional;
+    }
+    await warm();
+    const scan3 = await scanRepoParallel(repo, { ...opts, cache: originalCache, precomputedWalk: walked });
+    sessionPut({ key: key2, scan: scan3, cacheMap: toCacheMap(scan3) });
+    return scan3;
+  }
+  const preloaded = await preloadSessionLazy(repo, { ...opts, precomputedWalk: walked }, warm);
+  if (preloaded) {
+    sessionPut({
+      key: key2,
+      scan: preloaded.scan,
+      cacheMap: preloaded.cacheMap,
+      arts: preloaded.arts,
+      loadArtifacts: preloaded.loadArtifacts
+    });
+    return preloaded.scan;
   }
+  await warm();
+  const scan2 = await scanRepoParallel(repo, { ...opts, precomputedWalk: walked });
+  sessionPut({ key: key2, scan: scan2, cacheMap: toCacheMap(scan2) });
+  return scan2;
+}
+function getScanSummary(repo, opts = {}, walked) {
   return scanSummary(repo, { ...opts, precomputedWalk: walked });
 }
-function getArtifacts(repo, opts = {}, walked) {
-  const scan2 = getScan(repo, opts, walked);
+function getArtifacts(repo, opts = {}, walked, prepared) {
+  const scan2 = prepared ?? getScan(repo, opts, walked);
   const entry = sessionCaches.find((e) => e.scan === scan2);
-  if (entry) return entry.arts ??= buildArtifactsFromScan(scan2, opts);
+  if (entry) return entry.arts ??= entry.loadArtifacts?.() ?? buildArtifactsFromScan(scan2, opts);
   return buildArtifactsFromScan(scan2, opts);
 }
 async function warmGrammarsForRepo(repo) {
@@ -34223,6 +34554,7 @@ var init_session = __esm({
     "use strict";
     init_pipeline();
     init_scan();
+    init_pool();
     init_preload();
     init_walk();
     init_loader();
@@ -34245,6 +34577,7 @@ __export(mcp_exports, {
   capResponse: () => capResponse,
   getArtifacts: () => getArtifacts,
   getScan: () => getScan,
+  getScanParallel: () => getScanParallel,
   getScanSummary: () => getScanSummary,
   memoizedEmbedModel: () => memoizedEmbedModel,
   memoizedEmbeddingIndex: () => memoizedEmbeddingIndex,
@@ -34261,6 +34594,17 @@ __export(mcp_exports, {
   warmGrammarsForRepo: () => warmGrammarsForRepo,
   warmGrammarsForWalk: () => warmGrammarsForWalk
 });
+function isRpcRequest(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const req = value;
+  if (req.jsonrpc !== "2.0" || typeof req.method !== "string") return false;
+  return req.id === void 0 || req.id === null || typeof req.id === "number" || typeof req.id === "string";
+}
+function isRpcResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const response = value;
+  return response.jsonrpc === "2.0" && typeof response.method !== "string" && ("result" in response || "error" in response);
+}
 function str(v) {
   return typeof v === "string" && v ? v : void 0;
 }
@@ -34269,7 +34613,11 @@ function strArray(v) {
 }
 function num(v) {
   const n = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : NaN;
-  return Number.isFinite(n) && n > 0 ? n : void 0;
+  return Number.isFinite(n) && n >= 0 ? n : void 0;
+}
+function positiveNum(v) {
+  const n = num(v);
+  return n !== void 0 && n > 0 ? n : void 0;
 }
 function errMessage(e) {
   return e instanceof Error ? e.message : String(e);
@@ -34277,14 +34625,27 @@ function errMessage(e) {
 async function callTool(name2, args2, defaultRepo) {
   const repo = str(args2.repo) ?? defaultRepo;
   if (!repo) throw new Error("`repo` is required (absolute path to the repository root)");
+  try {
+    if (!statSync8(repo).isDirectory()) throw new Error("not a directory");
+  } catch {
+    throw new Error(`repository root is not a readable directory: ${repo}`);
+  }
   const scanOpts = { scope: str(args2.scope), include: strArray(args2.include), exclude: strArray(args2.exclude) };
   const rankArg = str(args2.rank);
   const rankOpt = rankArg === "graph" || rankArg === "lexical" ? { rank: rankArg } : {};
   let walked;
+  let preparedScan;
   if (!SCANLESS_TOOLS.has(name2)) {
     walked = walk(repo, {});
-    await warmGrammarsForWalk(walked);
+    preparedScan = await getScanParallel(
+      repo,
+      scanOpts,
+      walked,
+      () => walked ? warmGrammarsForWalk(walked) : Promise.resolve()
+    );
   }
+  const readScan = () => preparedScan ?? getScan(repo, scanOpts, walked);
+  const readArtifacts = () => getArtifacts(repo, scanOpts, walked, preparedScan);
   if (name2 === "scan_summary") {
     const s = getScanSummary(repo, scanOpts, walked);
     return JSON.stringify(
@@ -34294,10 +34655,10 @@ async function callTool(name2, args2, defaultRepo) {
     );
   }
   if (name2 === "graph") {
-    return renderGraphJson(getArtifacts(repo, scanOpts, walked).graph);
+    return renderGraphJson(readArtifacts().graph);
   }
   if (name2 === "symbols") {
-    const { symbols } = getArtifacts(repo, scanOpts, walked);
+    const { symbols } = readArtifacts();
     const lookup2 = str(args2.name);
     if (lookup2) {
       return JSON.stringify({ name: lookup2, defs: symbols.defs[lookup2] ?? [], refs: symbols.refs[lookup2] ?? [] }, null, 2);
@@ -34305,7 +34666,7 @@ async function callTool(name2, args2, defaultRepo) {
     return JSON.stringify(symbols, null, 2);
   }
   if (name2 === "callers") {
-    const scan2 = getScan(repo, scanOpts, walked);
+    const scan2 = readScan();
     const index = args2.recall === true ? buildCallerIndex(scan2, void 0, { recall: true }) : callerIndexFor(scan2);
     const lookup2 = str(args2.name);
     if (lookup2) {
@@ -34329,35 +34690,35 @@ async function callTool(name2, args2, defaultRepo) {
   if (name2 === "symbols_overview") {
     const file = str(args2.file);
     if (!file) throw new Error("`file` is required");
-    return JSON.stringify(symbolsOverview(getScan(repo, scanOpts, walked), file), null, 2);
+    return JSON.stringify(symbolsOverview(readScan(), file), null, 2);
   }
   if (name2 === "find_symbol") {
     const namePath = str(args2.namePath);
     if (!namePath) throw new Error("`namePath` is required");
-    const matches = findSymbol(getScan(repo, scanOpts, walked), namePath, {
+    const matches = findSymbol(readScan(), namePath, {
       substring: args2.substring === true,
       includeBody: args2.includeBody === true,
       concise: args2.concise === true,
-      maxResults: num(args2.maxResults)
+      maxResults: positiveNum(args2.maxResults)
     });
     return JSON.stringify(matches, null, 2);
   }
   if (name2 === "find_references") {
     const symName = str(args2.name);
     if (!symName) throw new Error("`name` is required");
-    const scan2 = getScan(repo, scanOpts, walked);
+    const scan2 = readScan();
     const statik = findReferences(scan2, symName);
     if (args2.lsp === true) return JSON.stringify(await referencesWithLsp(scan2, repo, symName, statik), null, 2);
     return JSON.stringify(statik, null, 2);
   }
   if (name2 === "lsp_status") {
-    return JSON.stringify(await lspStatus(getScan(repo, scanOpts, walked), repo, args2.probe === true), null, 2);
+    return JSON.stringify(await lspStatus(readScan(), repo, args2.probe === true), null, 2);
   }
   if (name2 === "replace_symbol_body" || name2 === "insert_after_symbol" || name2 === "insert_before_symbol") {
     const namePath = str(args2.namePath);
     const body22 = typeof args2.body === "string" ? args2.body : void 0;
     if (!namePath || body22 === void 0) throw new Error("`namePath` and `body` are required");
-    const scan2 = getScan(repo, scanOpts, walked);
+    const scan2 = readScan();
     const fn = name2 === "replace_symbol_body" ? replaceSymbolBody : name2 === "insert_after_symbol" ? insertAfterSymbol : insertBeforeSymbol;
     const result = fn(scan2, namePath, body22, str(args2.file));
     sessionClear();
@@ -34385,15 +34746,15 @@ async function callTool(name2, args2, defaultRepo) {
     return JSON.stringify({ deleted: deleteMemory(repo, memName) }, null, 2);
   }
   if (name2 === "dead_code") {
-    const all = findDeadCode(getScan(repo, scanOpts, walked));
+    const all = findDeadCode(readScan());
     const limit = num(args2.limit);
     if (limit === void 0 || all.length <= limit) return JSON.stringify(all, null, 2);
     return JSON.stringify({ total: all.length, shown: limit, truncated: true, candidates: all.slice(0, limit) }, null, 2);
   }
   if (name2 === "duplicated_literals") {
-    const report = findLiteralDuplications(getScan(repo, scanOpts, walked), {
-      minFiles: num(args2.minFiles),
-      minCount: num(args2.minCount),
+    const report = findLiteralDuplications(readScan(), {
+      minFiles: positiveNum(args2.minFiles),
+      minCount: positiveNum(args2.minCount),
       includeTests: args2.includeTests === true
     });
     const limit = num(args2.limit);
@@ -34411,23 +34772,23 @@ async function callTool(name2, args2, defaultRepo) {
     );
   }
   if (name2 === "complexity") {
-    const scan2 = getScan(repo, scanOpts, walked);
+    const scan2 = readScan();
     if (args2.risk === true) {
       const { churn, ok } = gitChurn(repo, { since: str(args2.since) });
-      return JSON.stringify({ churnOk: ok, risks: riskHotspots(scan2, churn, num(args2.top)) }, null, 2);
+      return JSON.stringify({ churnOk: ok, risks: riskHotspots(scan2, churn, positiveNum(args2.top)) }, null, 2);
     }
-    return JSON.stringify(symbolComplexity(scan2, str(args2.file), num(args2.top)), null, 2);
+    return JSON.stringify(symbolComplexity(scan2, str(args2.file), positiveNum(args2.top)), null, 2);
   }
   if (name2 === "mermaid") {
-    const { graph } = getArtifacts(repo, scanOpts, walked);
-    return renderMermaid(graph, { module: str(args2.module), maxEdges: num(args2.maxEdges) });
+    const { graph } = readArtifacts();
+    return renderMermaid(graph, { module: str(args2.module), maxEdges: positiveNum(args2.maxEdges) });
   }
   if (name2 === "onboard") {
-    const scan2 = getScan(repo, scanOpts, walked);
-    const { graph } = getArtifacts(repo, scanOpts, walked);
+    const scan2 = readScan();
+    const { graph } = readArtifacts();
     return JSON.stringify(
       onboardBrief(scan2, graph, {
-        ...typeof args2.budgetTokens === "number" ? { budgetTokens: args2.budgetTokens } : {},
+        ...positiveNum(args2.budgetTokens) !== void 0 ? { budgetTokens: positiveNum(args2.budgetTokens) } : {},
         ...args2.remember === false ? { remember: false } : {}
       }),
       null,
@@ -34435,11 +34796,11 @@ async function callTool(name2, args2, defaultRepo) {
     );
   }
   if (name2 === "repo_map") {
-    const { scan: scan2, graph } = getArtifacts(repo, scanOpts, walked);
-    return renderRepoMap(scan2, graph, { budgetTokens: typeof args2.budgetTokens === "number" ? args2.budgetTokens : void 0 });
+    const { scan: scan2, graph } = readArtifacts();
+    return renderRepoMap(scan2, graph, { budgetTokens: positiveNum(args2.budgetTokens) });
   }
   if (name2 === "hotspots") {
-    const scan2 = getScan(repo, scanOpts, walked);
+    const scan2 = readScan();
     const { churn, ok } = gitChurn(repo, { since: str(args2.since) });
     return JSON.stringify({ churnOk: ok, hotspots: rankHotspots(scan2, churn) }, null, 2);
   }
@@ -34455,15 +34816,15 @@ async function callTool(name2, args2, defaultRepo) {
     const hits = grepRepo(repo, pattern, {
       globs: scope ? [...globs ?? [], `${scope.replace(/\/+$/, "")}/**`] : globs,
       ignoreCase: args2.ignoreCase === true,
-      maxHits: typeof args2.maxHits === "number" ? args2.maxHits : void 0
+      maxHits: positiveNum(args2.maxHits)
     });
     return JSON.stringify(hits, null, 2);
   }
   if (name2 === "search") {
     const query = str(args2.query);
     if (!query) throw new Error("`query` is required");
-    const scan2 = getScan(repo, scanOpts, walked);
-    const limit = typeof args2.limit === "number" ? args2.limit : void 0;
+    const scan2 = readScan();
+    const limit = num(args2.limit);
     const fuzzy = typeof args2.fuzzy === "boolean" ? args2.fuzzy : void 0;
     const exactOpt = args2.exact === true ? { exact: true } : {};
     if (args2.semantic === true) {
@@ -34506,8 +34867,8 @@ async function callTool(name2, args2, defaultRepo) {
   if (name2 === "explain_search") {
     const query = str(args2.query);
     if (!query) throw new Error("`query` is required");
-    const scan2 = getScan(repo, scanOpts, walked);
-    const limit = typeof args2.limit === "number" ? args2.limit : void 0;
+    const scan2 = readScan();
+    const limit = num(args2.limit);
     const fuzzy = typeof args2.fuzzy === "boolean" ? args2.fuzzy : void 0;
     const { results, explain } = explainQuery(scan2, query, {
       limit,
@@ -34532,7 +34893,7 @@ async function callTool(name2, args2, defaultRepo) {
     return JSON.stringify(status, null, 2);
   }
   if (name2 === "type_hierarchy") {
-    const hierarchy = hierarchyFor(getScan(repo, scanOpts, walked));
+    const hierarchy = hierarchyFor(readScan());
     const wanted = str(args2.name);
     if (!wanted) {
       const obj = {};
@@ -34546,7 +34907,7 @@ async function callTool(name2, args2, defaultRepo) {
   if (name2 === "implementations") {
     const wanted = str(args2.name);
     if (!wanted) throw new Error("`name` is required");
-    const hierarchy = hierarchyFor(getScan(repo, scanOpts, walked));
+    const hierarchy = hierarchyFor(readScan());
     if (!hierarchy.has(wanted)) return JSON.stringify({ error: `no type named ${wanted}` }, null, 2);
     return JSON.stringify({ name: wanted, implementations: implementationsOf(hierarchy, wanted) }, null, 2);
   }
@@ -34555,8 +34916,8 @@ async function callTool(name2, args2, defaultRepo) {
     if (!symbol) throw new Error("`symbol` is required");
     const direction = str(args2.direction);
     const dir = direction === "out" || direction === "in" ? direction : "both";
-    const result = neighborhood(symbolGraphFor(getScan(repo, scanOpts, walked)), symbol, {
-      ...typeof args2.depth === "number" ? { depth: args2.depth } : {},
+    const result = neighborhood(symbolGraphFor(readScan()), symbol, {
+      ...positiveNum(args2.depth) !== void 0 ? { depth: positiveNum(args2.depth) } : {},
       direction: dir
     });
     if (!result.root.length) return JSON.stringify({ error: `no symbol named ${symbol}` }, null, 2);
@@ -34575,7 +34936,7 @@ async function callTool(name2, args2, defaultRepo) {
     }
     if (payload === void 0) throw new Error("`rules` (or `configPath`) is required");
     const rules = parseRules(payload);
-    const { graph } = getArtifacts(repo, scanOpts, walked);
+    const { graph } = readArtifacts();
     return JSON.stringify(checkRules(graph, rules), null, 2);
   }
   throw new Error(`unknown tool: ${name2}`);
@@ -34587,31 +34948,81 @@ async function runMcpServer(opts = {}) {
   };
   let protocolVersion = PROTOCOL_VERSIONS[0];
   let tools = toolsFor(opts.defaultRepo, protocolVersion, opts.profile);
+  let watcher;
+  if (opts.watch && opts.defaultRepo) {
+    try {
+      watcher = watchFs(opts.defaultRepo, { recursive: true }, (_event, filename) => {
+        const rel2 = filename?.toString().replaceAll("\\", "/") ?? "";
+        const ignored = rel2.split("/").some(
+          (segment) => IGNORE_DIRS.has(segment) || segment.startsWith(".codeindex-edit-")
+        );
+        if (ignored) return;
+        sessionInvalidate(opts.defaultRepo, rel2 || void 0);
+      });
+      watcher.on("error", (error) => {
+        process.stderr.write(`codeindex: MCP watcher disabled (${error.message}); using freshness scans
+`);
+        watcher?.close();
+        watcher = void 0;
+        sessionInvalidate(opts.defaultRepo);
+      });
+    } catch (error) {
+      process.stderr.write(
+        `codeindex: MCP watcher unavailable (${error instanceof Error ? error.message : String(error)}); using freshness scans
+`
+      );
+    }
+  }
   const send = (msg) => {
-    process.stdout.write(JSON.stringify({ jsonrpc: "2.0", ...msg }) + "\n");
+    const wire = Array.isArray(msg) ? msg.map((entry) => ({ jsonrpc: "2.0", ...entry })) : { jsonrpc: "2.0", ...msg };
+    process.stdout.write(JSON.stringify(wire) + "\n");
   };
   const rl = createInterface({ input: process.stdin, terminal: false });
-  for await (const line of rl) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      send({ id: null, error: { code: -32700, message: "parse error" } });
-      continue;
+  try {
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        send({ id: null, error: { code: -32700, message: "parse error" } });
+        continue;
+      }
+      if (Array.isArray(parsed) && parsed.length === 0) {
+        send({ id: null, error: { code: -32600, message: "invalid request" } });
+        continue;
+      }
+      const dispatch2 = async (req) => {
+        if (isRpcResponse(req)) return void 0;
+        if (!isRpcRequest(req)) {
+          return { id: null, error: { code: -32600, message: "invalid request" } };
+        }
+        return handle2(req);
+      };
+      if (Array.isArray(parsed)) {
+        const replies = [];
+        for (const req of parsed) {
+          const reply = await dispatch2(req);
+          if (reply) replies.push(reply);
+        }
+        if (replies.length > 0) send(replies);
+      } else {
+        const reply = await dispatch2(parsed);
+        if (reply) send(reply);
+      }
     }
-    const requests = Array.isArray(parsed) ? parsed : [parsed];
-    for (const req of requests) await handle2(req);
+  } finally {
+    watcher?.close();
   }
   async function handle2(req) {
-    if (req.id === void 0 || req.id === null) return;
+    const notification = !("id" in req);
+    const respond = (body22) => notification ? void 0 : { id: req.id ?? null, ...body22 };
     try {
       if (req.method === "initialize") {
         protocolVersion = negotiateProtocol(req.params?.protocolVersion);
         tools = toolsFor(opts.defaultRepo, protocolVersion, opts.profile);
-        send({
-          id: req.id,
+        return respond({
           result: {
             protocolVersion,
             capabilities: { tools: {} },
@@ -34619,9 +35030,9 @@ async function runMcpServer(opts = {}) {
           }
         });
       } else if (req.method === "ping") {
-        send({ id: req.id, result: {} });
+        return respond({ result: {} });
       } else if (req.method === "tools/list") {
-        send({ id: req.id, result: { tools } });
+        return respond({ result: { tools } });
       } else if (req.method === "tools/call") {
         const params = req.params ?? {};
         const name2 = str(params.name) ?? "";
@@ -34638,24 +35049,22 @@ async function runMcpServer(opts = {}) {
           const capped = text !== raw;
           const link = capped && protocolVersion >= RICH_TOOLS_SINCE ? resourceLinkFor(text, name2) : void 0;
           const structured = protocolVersion >= RICH_TOOLS_SINCE ? structuredContentFor(text, capped, OUTPUT_SCHEMAS[name2] !== void 0) : void 0;
-          send({
-            id: req.id,
+          return respond({
             result: {
               content: link ? [{ type: "text", text }, link] : [{ type: "text", text }],
               ...structured ? { structuredContent: structured } : {}
             }
           });
         } catch (e) {
-          send({
-            id: req.id,
+          return respond({
             result: { content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }], isError: true }
           });
         }
       } else {
-        send({ id: req.id, error: { code: -32601, message: `method not found: ${req.method}` } });
+        return respond({ error: { code: -32601, message: `method not found: ${req.method}` } });
       }
     } catch (e) {
-      send({ id: req.id, error: { code: -32603, message: e instanceof Error ? e.message : String(e) } });
+      return respond({ error: { code: -32603, message: e instanceof Error ? e.message : String(e) } });
     }
   }
 }
@@ -34707,8 +35116,7 @@ var init_mcp = __esm({
       "delete_memory",
       "embed_status",
       // scan_summary counts and classifies by path only — it never parses, so the
-      // grammar warm (a whole extra walk) would be pure overhead. When a scan is
-      // already cached getScanSummary reuses it, warm grammars included.
+      // grammar warm (a whole extra walk) would be pure overhead.
       "scan_summary"
     ]);
   }
@@ -34832,129 +35240,7 @@ init_walk();
 init_scan();
 init_scan();
 init_preload();
-init_hash();
-init_walk();
-init_registry();
-init_loader();
-init_scan();
-function resolveEngineUrl() {
-  try {
-    const here = fileURLToPath2(import.meta.url);
-    if (here.endsWith("engine.mjs")) return pathToFileURL(here).href;
-    const adjacent = join4(dirname2(here), "engine.mjs");
-    if (existsSync2(adjacent)) return pathToFileURL(adjacent).href;
-    return void 0;
-  } catch {
-    return void 0;
-  }
-}
-var WORKER_TIMEOUT_MS = 10 * 60 * 1e3;
-function workerCount(requested) {
-  const env = process.env["CODEINDEX_WORKERS"];
-  const raw = requested ?? (env !== void 0 && env !== "" ? Number(env) : void 0);
-  if (raw !== void 0) return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 0;
-  let cores = 1;
-  try {
-    cores = availableParallelism();
-  } catch {
-    cores = 1;
-  }
-  return Math.max(0, Math.min(cores - 1, 8));
-}
-async function runExtractWorker(input, post) {
-  await ensureGrammars(input.grammarKeys);
-  const ready = input.grammarKeys.filter((k) => grammarReady(k));
-  const records = [];
-  for (const job of input.jobs) {
-    let size;
-    let mtimeMs;
-    try {
-      const st = statSync2(job.abs);
-      size = st.size;
-      mtimeMs = st.mtimeMs;
-    } catch {
-      continue;
-    }
-    const content = readText2(job.abs);
-    const record = buildCodeRecord(job.rel, job.ext, size, content, sha1(content), extToLang(job.ext), {
-      maxCallsPerFile: input.maxCallsPerFile
-    });
-    records.push({ rel: job.rel, size, mtimeMs, record });
-  }
-  post({ ready, records });
-}
-async function extractInParallel(jobs, grammarKeys, count, opts = {}) {
-  if (count < 2 || jobs.length === 0) return void 0;
-  const engineUrl = resolveEngineUrl();
-  if (!engineUrl) return void 0;
-  const wanted = grammarKeys.filter((k) => grammarReady(k)).sort();
-  const shards = Array.from({ length: Math.min(count, jobs.length) }, () => []);
-  jobs.forEach((j, i2) => shards[i2 % shards.length].push(j));
-  const bootstrap = `import { runExtractWorker } from ${JSON.stringify(engineUrl)};
-import { parentPort, workerData } from "node:worker_threads";
-runExtractWorker(workerData.input, (o) => parentPort.postMessage(o)).catch((e) => parentPort.postMessage({ error: String(e) }));
-`;
-  try {
-    const outputs = await Promise.all(
-      shards.map(
-        (jobsForShard) => new Promise((resolve52, reject) => {
-          const w = new Worker(bootstrap, {
-            eval: true,
-            workerData: { input: { jobs: jobsForShard, grammarKeys: wanted, maxCallsPerFile: opts.maxCallsPerFile } }
-          });
-          const timer = setTimeout(() => {
-            reject(new Error("extraction worker timed out"));
-            void w.terminate();
-          }, WORKER_TIMEOUT_MS);
-          const settle = (fn) => {
-            clearTimeout(timer);
-            fn();
-          };
-          w.once("message", (m) => {
-            settle(() => resolve52(m));
-            void w.terminate();
-          });
-          w.once("error", (e) => settle(() => reject(e)));
-          w.once("exit", (code2) => {
-            if (code2 !== 0) settle(() => reject(new Error(`extraction worker exited with ${code2}`)));
-          });
-        })
-      )
-    );
-    const out2 = /* @__PURE__ */ new Map();
-    for (const o of outputs) {
-      if ("error" in o) return void 0;
-      if (o.ready.slice().sort().join(",") !== wanted.join(",")) return void 0;
-      for (const r of o.records) out2.set(r.rel, { size: r.size, mtimeMs: r.mtimeMs, record: r.record });
-    }
-    return out2;
-  } catch {
-    return void 0;
-  }
-}
-async function scanRepoParallel(root, opts = {}) {
-  const count = workerCount(opts.workers);
-  if (count < 2) return scanRepo(root, opts);
-  const walked = opts.precomputedWalk ?? walk(root, {
-    maxFileBytes: opts.maxBytes,
-    maxFiles: opts.maxFiles,
-    gitignore: opts.gitignore,
-    ignoreDirs: opts.ignoreDirs
-  });
-  const scanOpts = { ...opts, precomputedWalk: walked };
-  const jobs = [];
-  for (const { f } of keptCodeFiles(root, scanOpts)) {
-    const cached = opts.cache?.get(f.rel);
-    if (!opts.fullHash && cached && cached.size !== void 0 && cached.mtimeMs !== void 0 && cached.size === f.size && cached.mtimeMs === f.mtimeMs) {
-      continue;
-    }
-    jobs.push({ abs: f.abs, rel: f.rel, ext: f.ext });
-  }
-  if (jobs.length === 0) return scanRepo(root, scanOpts);
-  const grammarKeys = grammarKeysForExts(walked.files.map((f) => f.ext));
-  const extracted = await extractInParallel(jobs, grammarKeys, count, { maxCallsPerFile: opts.maxCallsPerFile });
-  return scanRepo(root, extracted ? { ...scanOpts, extracted } : scanOpts);
-}
+init_pool();
 init_glob();
 init_ignore();
 init_classify();
@@ -35251,6 +35537,64 @@ function extractGrammarsTarball(bytes, destDir) {
   const raw = b.length >= 2 && b[0] === 31 && b[1] === 139 ? gunzipSync(b) : b;
   return extractTarInto(raw, destDir);
 }
+function installGrammarCacheAtomically(tempDir, cacheDir, markerPath, expectedSha256, rename = renameSync, cleanup = rmSync) {
+  const parent = dirname3(cacheDir);
+  const swapDir = mkdtempSync(join6(parent, ".grammars-swap-"));
+  const previousCache = join6(swapDir, "previous-cache");
+  const previousMarker = join6(swapDir, "previous-marker");
+  const nextMarker = join6(swapDir, "next-marker");
+  let cacheBackedUp = false;
+  let markerBackedUp = false;
+  let cacheInstalled = false;
+  let markerInstalled = false;
+  try {
+    if (expectedSha256) writeFileSync(nextMarker, expectedSha256 + "\n");
+    if (existsSync4(cacheDir)) {
+      rename(cacheDir, previousCache);
+      cacheBackedUp = true;
+    }
+    if (existsSync4(markerPath)) {
+      rename(markerPath, previousMarker);
+      markerBackedUp = true;
+    }
+    rename(tempDir, cacheDir);
+    cacheInstalled = true;
+    if (expectedSha256) {
+      rename(nextMarker, markerPath);
+      markerInstalled = true;
+    }
+  } catch (error) {
+    const rollbackErrors = [];
+    const attempt = (operation) => {
+      try {
+        operation();
+      } catch (rollback) {
+        rollbackErrors.push(rollback);
+      }
+    };
+    if (markerInstalled && existsSync4(markerPath)) attempt(() => rmSync(markerPath, { force: true }));
+    if (cacheInstalled && existsSync4(cacheDir)) attempt(() => rmSync(cacheDir, { recursive: true, force: true }));
+    if (markerBackedUp && existsSync4(previousMarker)) attempt(() => rename(previousMarker, markerPath));
+    if (cacheBackedUp && existsSync4(previousCache)) attempt(() => rename(previousCache, cacheDir));
+    if (rollbackErrors.length === 0) {
+      try {
+        rmSync(swapDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    if (rollbackErrors.length > 0) {
+      const rollbackError = rollbackErrors[0];
+      throw new Error(
+        `${error instanceof Error ? error.message : String(error)}; rollback failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)} (backup preserved at ${swapDir})`
+      );
+    }
+    throw error;
+  }
+  try {
+    cleanup(swapDir, { recursive: true, force: true });
+  } catch {
+  }
+}
 async function pullGrammars(cacheDir, opts = {}) {
   const note = opts.onNote ?? (() => {
   });
@@ -35299,10 +35643,8 @@ async function pullGrammars(cacheDir, opts = {}) {
     if (!existsSync4(join6(tmp, "web-tree-sitter.wasm"))) {
       throw new Error("archive is missing web-tree-sitter.wasm");
     }
-    if (existsSync4(cacheDir)) rmSync(cacheDir, { recursive: true, force: true });
-    renameSync(tmp, cacheDir);
+    installGrammarCacheAtomically(tmp, cacheDir, markerPath, expected);
     tmp = void 0;
-    if (expected) writeFileSync(markerPath, expected + "\n");
   } catch (e) {
     if (tmp) {
       try {
@@ -36066,6 +36408,7 @@ init_hash();
 init_graph_json();
 init_symbols_json();
 init_scan();
+init_pool();
 init_preload();
 init_walk();
 init_relations();
@@ -36192,7 +36535,8 @@ Commands:
               advertises a named subset (all | orient | find | impact | edit |
               risk, default all) \u2014 every advertised tool's schema costs an agent
               context on EVERY turn, and a tool left out is still answerable
-              when called by name
+              when called by name; --watch enables proactive invalidation for a
+              pinned repo while retaining per-request freshness verification
   version     Print the engine version
 
 Flags (accepted before OR after the subcommand: '--repo X scan' and
@@ -36343,6 +36687,7 @@ function parseMcpFlags(argv) {
   let name2;
   let maxResponseBytes;
   let profile;
+  let watch = false;
   for (let i2 = 0; i2 < argv.length; i2++) {
     const a = argv[i2];
     if (a === "--repo") {
@@ -36363,12 +36708,15 @@ function parseMcpFlags(argv) {
       if (!v) throw new Error(`--tools requires a profile: ${profileNames().join(", ")}`);
       toolsInProfiles(v);
       profile = v === "all" ? void 0 : v;
+    } else if (a === "--watch") {
+      watch = true;
     } else {
       throw new Error(`unknown flag for \`mcp\`: ${a}`);
     }
   }
   if (defaultRepo && !existsSync10(defaultRepo)) throw new Error(`--repo path does not exist: ${defaultRepo}`);
-  return { defaultRepo, serverInfo: name2 ? { name: name2 } : void 0, maxResponseBytes, profile };
+  if (watch && !defaultRepo) throw new Error("--watch requires --repo <dir>");
+  return { defaultRepo, serverInfo: name2 ? { name: name2 } : void 0, maxResponseBytes, profile, watch };
 }
 var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "--repo",
@@ -36392,7 +36740,12 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "--tools",
   "--workers",
   "--index",
-  "--max-response-bytes"
+  "--max-response-bytes",
+  "--base",
+  "--depth",
+  "--kind",
+  "--rank",
+  "--direction"
 ]);
 function hoistLeadingFlags(argv) {
   const lead = [];
@@ -36438,6 +36791,7 @@ async function runCli(rawArgv) {
   }
   const flags2 = parseFlags(rest);
   if (!existsSync10(flags2.repo)) throw new Error(`--repo path does not exist: ${flags2.repo}`);
+  if (!statSync9(flags2.repo).isDirectory()) throw new Error(`--repo path is not a directory: ${flags2.repo}`);
   const scans = !SCANLESS_COMMANDS.has(cmd) && !(cmd === "embed" && flags2.positional !== "build");
   let precomputedWalk;
   if (scans && !flags2.noAst) {
@@ -36447,25 +36801,45 @@ async function runCli(rawArgv) {
       gitignore: flags2.gitignore,
       ignoreDirs: flags2.ignoreDirs.length ? flags2.ignoreDirs : void 0
     });
-    await ensureGrammars(grammarKeysForExts(precomputedWalk.files.map((f) => f.ext)));
   }
+  let grammarsWarmed = false;
+  const warmPresentGrammars = async () => {
+    if (grammarsWarmed || flags2.noAst || !precomputedWalk) return;
+    await ensureGrammars(grammarKeysForExts(precomputedWalk.files.map((f) => f.ext)));
+    grammarsWarmed = true;
+  };
   const indexDir = flags2.indexDir ?? INDEX_DIR;
   let preloadTried = false;
+  let preloadPromise;
   let preloaded;
-  const tryPreload = () => {
+  const tryPreload = async () => {
+    if (preloadPromise) return preloadPromise;
     if (preloadTried) return preloaded;
     preloadTried = true;
     if (flags2.noIndexCache) return void 0;
-    const p = preloadSession(flags2.repo, scanOptions(flags2, precomputedWalk), indexDir);
-    if (p) preloaded = { scan: p.scan, arts: p.arts };
-    return preloaded;
+    preloadPromise = preloadSessionLazy(flags2.repo, scanOptions(flags2, precomputedWalk), warmPresentGrammars, indexDir).then((p) => {
+      if (p) preloaded = { scan: p.scan, arts: p.arts, loadArtifacts: p.loadArtifacts };
+      return preloaded;
+    });
+    return preloadPromise;
   };
-  const readScan = () => tryPreload()?.scan ?? scanRepo(flags2.repo, scanOptions(flags2, precomputedWalk));
-  const readArtifacts = () => {
-    const p = tryPreload();
+  let readScanPromise;
+  const readScan = async () => {
+    const preloadedScan = (await tryPreload())?.scan;
+    if (preloadedScan) return preloadedScan;
+    return readScanPromise ??= warmPresentGrammars().then(
+      () => scanRepoParallel(flags2.repo, {
+        ...scanOptions(flags2, precomputedWalk),
+        workers: flags2.workers
+      })
+    );
+  };
+  let readArtifactsPromise;
+  const readArtifacts = async () => {
+    const p = await tryPreload();
     if (p?.arts) return p.arts;
-    if (p) return buildArtifactsFromScan(p.scan, scanOptions(flags2, precomputedWalk));
-    return buildIndexArtifacts(flags2.repo, scanOptions(flags2, precomputedWalk));
+    if (p) return p.arts ??= p.loadArtifacts?.() ?? buildArtifactsFromScan(p.scan, scanOptions(flags2, precomputedWalk));
+    return readArtifactsPromise ??= readScan().then((scan2) => buildArtifactsFromScan(scan2, scanOptions(flags2, precomputedWalk)));
   };
   if (cmd === "index") {
     if (!flags2.out) throw new Error("index needs --out <dir>");
@@ -36488,6 +36862,7 @@ async function runCli(rawArgv) {
       }
     } catch {
     }
+    await warmPresentGrammars();
     const scan2 = await scanRepoParallel(flags2.repo, {
       ...scanOptions(flags2, precomputedWalk),
       cache,
@@ -36566,13 +36941,13 @@ async function runCli(rawArgv) {
     };
     emit(JSON.stringify(summary, null, 2) + "\n", flags2.out);
   } else if (cmd === "graph") {
-    const { graph } = readArtifacts();
+    const { graph } = await readArtifacts();
     emit(renderGraphJson(graph), flags2.out);
   } else if (cmd === "symbols") {
-    const { symbols } = readArtifacts();
+    const { symbols } = await readArtifacts();
     emit(renderSymbolsJson(symbols), flags2.out);
   } else if (cmd === "scip") {
-    const scan2 = readScan();
+    const scan2 = await readScan();
     const bytes = renderScip(scan2, { projectRoot: flags2.projectRoot });
     const out2 = flags2.out ?? resolve4("index.scip");
     if (out2 === "-") process.stdout.write(Buffer.from(bytes));
@@ -36582,13 +36957,13 @@ async function runCli(rawArgv) {
 `);
     }
   } else if (cmd === "callers") {
-    const scan2 = readScan();
+    const scan2 = await readScan();
     const index = buildCallerIndex(scan2, void 0, { recall: flags2.recall });
     const obj = {};
     for (const [name2, entry] of index) obj[name2] = entry;
     emit(JSON.stringify(obj, null, 2) + "\n", flags2.out);
   } else if (cmd === "hierarchy") {
-    const scan2 = readScan();
+    const scan2 = await readScan();
     const hierarchy = buildTypeHierarchy(scan2, computeImportPairs(scan2));
     if (flags2.positional) {
       const entry = hierarchy.get(flags2.positional);
@@ -36601,7 +36976,7 @@ async function runCli(rawArgv) {
     }
   } else if (cmd === "implementations") {
     if (!flags2.positional) throw new Error("implementations needs a type name: cli.mjs implementations <Name> --repo <dir>");
-    const scan2 = readScan();
+    const scan2 = await readScan();
     const hierarchy = buildTypeHierarchy(scan2, computeImportPairs(scan2));
     if (!hierarchy.has(flags2.positional)) throw new Error(`no type named ${flags2.positional}`);
     emit(
@@ -36610,7 +36985,7 @@ async function runCli(rawArgv) {
     );
   } else if (cmd === "callgraph") {
     if (!flags2.positional) throw new Error("callgraph needs a symbol: cli.mjs callgraph <Symbol> --repo <dir>");
-    const scan2 = readScan();
+    const scan2 = await readScan();
     const graph = buildSymbolGraph(scan2, computeImportPairs(scan2));
     const result = neighborhood(graph, flags2.positional, {
       ...flags2.depth !== void 0 ? { depth: flags2.depth } : {},
@@ -36620,7 +36995,7 @@ async function runCli(rawArgv) {
     emit(JSON.stringify(result, null, 2) + "\n", flags2.out);
   } else if (cmd === "search") {
     if (!flags2.positional) throw new Error('search needs a query: cli.mjs search "<query>" --repo <dir>');
-    const scan2 = readScan();
+    const scan2 = await readScan();
     const searchOpts = {
       limit: flags2.limit,
       fuzzy: flags2.fuzzy,
@@ -36725,7 +37100,7 @@ async function runCli(rawArgv) {
       }
       const model = loadEmbedModel(modelDir);
       mkdirSync3(flags2.out, { recursive: true });
-      const scan2 = readScan();
+      const scan2 = await readScan();
       const index = buildEmbeddingIndex(scan2, model);
       writeFileSync4(join23(flags2.out, "embeddings.bin"), serializeEmbeddings(index));
       process.stderr.write(`codeindex: ${index.records.length} embedding records \u2192 ${flags2.out}/embeddings.bin (model ${model.modelId})
@@ -36764,7 +37139,7 @@ async function runCli(rawArgv) {
   } else if (cmd === "lsp") {
     const sub = flags2.positional;
     if (sub !== "status") throw new Error("lsp needs a subcommand: status");
-    emit(JSON.stringify(await lspStatus(readScan(), flags2.repo, flags2.probe === true), null, 2) + "\n", flags2.out);
+    emit(JSON.stringify(await lspStatus(await readScan(), flags2.repo, flags2.probe === true), null, 2) + "\n", flags2.out);
   } else if (cmd === "grammars") {
     const sub = flags2.positional;
     const cacheDir = sharedGrammarsCacheDir();
@@ -36803,7 +37178,7 @@ async function runCli(rawArgv) {
   } else if (cmd === "rules") {
     if (!flags2.config) throw new Error("rules needs --config <codeindex.rules.json>");
     const rules = parseRules(JSON.parse(readFileSync13(flags2.config, "utf8")));
-    const { graph } = readArtifacts();
+    const { graph } = await readArtifacts();
     const violations = checkRules(graph, rules);
     const errors = violations.filter((v) => v.severity === "error").length;
     emit(JSON.stringify({ errors, warnings: violations.length - errors, violations }, null, 2) + "\n", flags2.out);
@@ -36824,33 +37199,33 @@ async function runCli(rawArgv) {
     for (const k of [...churn.keys()].sort()) sorted[k] = churn.get(k);
     emit(JSON.stringify({ ok, churn: sorted }, null, 2) + "\n", flags2.out);
   } else if (cmd === "repomap") {
-    const { scan: scan2, graph } = readArtifacts();
+    const { scan: scan2, graph } = await readArtifacts();
     emit(renderRepoMap(scan2, graph, { budgetTokens: flags2.budgetTokens }), flags2.out);
   } else if (cmd === "hotspots") {
-    const scan2 = readScan();
+    const scan2 = await readScan();
     const { churn, ok } = gitChurn(flags2.repo, { since: flags2.since });
     emit(JSON.stringify({ churnOk: ok, hotspots: rankHotspots(scan2, churn) }, null, 2) + "\n", flags2.out);
   } else if (cmd === "coupling") {
     const { ok, couplings } = changeCoupling(flags2.repo, { since: flags2.since });
     emit(JSON.stringify({ ok, couplings }, null, 2) + "\n", flags2.out);
   } else if (cmd === "deadcode") {
-    emit(JSON.stringify(findDeadCode(readScan()), null, 2) + "\n", flags2.out);
+    emit(JSON.stringify(findDeadCode(await readScan()), null, 2) + "\n", flags2.out);
   } else if (cmd === "literals") {
-    const report = findLiteralDuplications(readScan(), {
+    const report = findLiteralDuplications(await readScan(), {
       minFiles: flags2.minFiles,
       minCount: flags2.minCount,
       includeTests: flags2.includeTests
     });
     emit(JSON.stringify(report, null, 2) + "\n", flags2.out);
   } else if (cmd === "complexity") {
-    const scan2 = readScan();
+    const scan2 = await readScan();
     emit(JSON.stringify(symbolComplexity(scan2, flags2.positional), null, 2) + "\n", flags2.out);
   } else if (cmd === "risk") {
-    const scan2 = readScan();
+    const scan2 = await readScan();
     const { churn, ok } = gitChurn(flags2.repo, { since: flags2.since });
     emit(JSON.stringify({ churnOk: ok, risks: riskHotspots(scan2, churn) }, null, 2) + "\n", flags2.out);
   } else if (cmd === "delta") {
-    const { graph, symbols } = readArtifacts();
+    const { graph, symbols } = await readArtifacts();
     const res = deltaFor(flags2.repo, graph, symbols, {
       base: flags2.base,
       staged: flags2.staged,
@@ -36860,19 +37235,19 @@ async function runCli(rawArgv) {
     emit(flags2.json ? JSON.stringify(res, null, 2) + "\n" : formatDeltaPanel(res), flags2.out);
   } else if (cmd === "impact") {
     if (!flags2.positional) throw new Error("impact needs a target: cli.mjs impact <file|module> --repo <dir>");
-    const { graph } = readArtifacts();
+    const { graph } = await readArtifacts();
     const res = impactOf(graph, flags2.positional, flags2.depth ?? Infinity);
     if (!res) throw new Error(`no such file or module in the index: ${flags2.positional}`);
     emit(JSON.stringify(res, null, 2) + "\n", flags2.out);
   } else if (cmd === "neighbors") {
     if (!flags2.positional) throw new Error("neighbors needs a target: cli.mjs neighbors <file|module> --repo <dir>");
-    const { graph } = readArtifacts();
+    const { graph } = await readArtifacts();
     const kinds = flags2.kind ? new Set(flags2.kind.split(",").map((k) => k.trim()).filter(Boolean)) : void 0;
     const res = neighborsOf(graph, flags2.positional, flags2.depth ?? 1, kinds);
     if (!res) throw new Error(`no such file or module in the index: ${flags2.positional}`);
     emit(JSON.stringify(res, null, 2) + "\n", flags2.out);
   } else if (cmd === "mermaid") {
-    const { graph } = readArtifacts();
+    const { graph } = await readArtifacts();
     emit(renderMermaid(graph, { module: flags2.positional }), flags2.out);
   } else if (cmd === "grep") {
     if (!flags2.positional) throw new Error("grep needs a pattern: cli.mjs grep <pattern> --repo <dir>");
@@ -36976,7 +37351,7 @@ function expandInputs(inputs, opts = {}) {
       const acc = walkCached(staticBase(input), opts);
       for (const f of acc) if (match(toPosix(f)) && exts.has(ext(f))) files.add(f);
     } else if (existsSync11(input)) {
-      if (statSync6(input).isDirectory()) {
+      if (statSync10(input).isDirectory()) {
         const acc = walkCached(input, opts);
         for (const f of acc) if (exts.has(ext(f))) files.add(f);
       } else if (exts.has(ext(input))) {
@@ -37151,7 +37526,7 @@ function parseSourceWithAst(source, file, opts = {}) {
 
 // src/snapshot.ts
 import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync14, readdirSync as readdirSync4, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname5, join as join25 } from "path";
+import { dirname as dirname6, join as join25 } from "path";
 
 // src/collector.ts
 var COLLECTED_CSS = [
@@ -37476,7 +37851,7 @@ function align(doc, entries) {
 }
 function attachSignals(doc) {
   if (!isSnapshotDom(doc.file)) return;
-  const dir = dirname5(doc.file);
+  const dir = dirname6(doc.file);
   const styles = readJson2(join25(dir, "styles.json"));
   const boxes = readJson2(join25(dir, "boxes.json"));
   const axtree = readJson2(join25(dir, "axtree.json"));
@@ -50827,7 +51202,7 @@ function crossToFinding(doc, ruleId, def, cf) {
 import { resolve as absPath } from "path";
 
 // src/graph/resolve.ts
-import { dirname as dirname6, join as join26 } from "path";
+import { dirname as dirname7, join as join26 } from "path";
 var EXT_ORDER = [".tsx", ".jsx", ".ts", ".js"];
 function candidates(base) {
   const out2 = [base];
@@ -50849,7 +51224,7 @@ function matchKnown(base, known) {
 }
 function resolveSpecifier(fromFile, spec, known, aliases) {
   if (spec.startsWith(".")) {
-    return matchKnown(join26(dirname6(toPosix(fromFile)), spec), known);
+    return matchKnown(join26(dirname7(toPosix(fromFile)), spec), known);
   }
   if (aliases?.length) {
     for (const rule of aliases) {
@@ -50873,7 +51248,7 @@ function resolveSpecifier(fromFile, spec, known, aliases) {
 
 // src/graph/tsconfig.ts
 import { existsSync as existsSync13, readFileSync as readFileSync16 } from "fs";
-import { dirname as dirname7, join as join27, resolve as resolve5, relative } from "path";
+import { dirname as dirname8, join as join27, resolve as resolve5, relative } from "path";
 function readJsonish(path) {
   try {
     const raw = readFileSync16(path, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/[^\n]*/g, "$1").replace(/,(\s*[}\]])/g, "$1");
@@ -50887,7 +51262,7 @@ function findTsconfig(startDir) {
   for (let i2 = 0; i2 < 30; i2++) {
     const p = join27(dir, "tsconfig.json");
     if (existsSync13(p)) return p;
-    const parent = dirname7(dir);
+    const parent = dirname8(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -50907,7 +51282,7 @@ function tsconfigChain(startDir) {
     out2.push(p);
     const cfg = readJsonish(p);
     const exts = Array.isArray(cfg?.extends) ? cfg.extends : typeof cfg?.extends === "string" ? [cfg.extends] : [];
-    const dir = dirname7(p);
+    const dir = dirname8(p);
     for (const e of exts) {
       if (typeof e !== "string") continue;
       const cands = e.endsWith(".json") ? [resolve5(dir, e)] : [resolve5(dir, `${e}.json`), resolve5(dir, e, "tsconfig.json")];
@@ -50920,7 +51295,7 @@ function tsconfigChain(startDir) {
 function readTsAliases(startDir, cwd = process.cwd()) {
   const tsconfigPath = findTsconfig(startDir);
   if (!tsconfigPath) return [];
-  const root = dirname7(tsconfigPath);
+  const root = dirname8(tsconfigPath);
   const cfg = readJsonish(tsconfigPath);
   if (!cfg) return [];
   let co = cfg.compilerOptions ?? {};
@@ -51378,7 +51753,7 @@ function runPackRules(doc, pack) {
 }
 
 // src/graph/build.ts
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 
 // src/graph/imports.ts
 var NAME_PROPS2 = /* @__PURE__ */ new Set(["aria-label", "aria-labelledby", "title", "label", "alt"]);
@@ -51676,7 +52051,7 @@ function buildGraphAndDocs(files, opts = {}) {
     }
     nodes.push(extractGraphNode(ast, doc, file, { sfc }));
   }
-  const startDir = files[0] ? dirname8(files[0]) : process.cwd();
+  const startDir = files[0] ? dirname9(files[0]) : process.cwd();
   return { graph: buildGraph2(nodes, readTsAliases(startDir), startDir), docs };
 }
 
@@ -52498,7 +52873,7 @@ function baselineSummary(diff, lang = "fr") {
 }
 
 // src/config.ts
-import { existsSync as existsSync16, statSync as statSync7 } from "fs";
+import { existsSync as existsSync16, statSync as statSync11 } from "fs";
 import { join as join29, isAbsolute as isAbsolute2 } from "path";
 
 // src/pack.ts
@@ -56645,7 +57020,7 @@ function loadConfig(cwd) {
 }
 function packPaths(path) {
   if (!existsSync16(path)) return null;
-  if (statSync7(path).isDirectory()) {
+  if (statSync11(path).isDirectory()) {
     const pack = join29(path, "pack.json");
     if (!existsSync16(pack)) return null;
     const glossary = join29(path, "glossary.json");
@@ -60310,7 +60685,7 @@ function renderCriteriaReference() {
 
 // src/check.ts
 import { existsSync as existsSync21, readFileSync as readFileSync19, readdirSync as readdirSync5 } from "fs";
-import { dirname as dirname9, join as join34 } from "path";
+import { dirname as dirname10, join as join34 } from "path";
 
 // src/verify.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync9 } from "fs";
@@ -60874,7 +61249,7 @@ function checkSemantic(md, opts) {
   const standard = opts.standard ?? "wcag";
   const s = M[lang];
   const empty = { total: 0, grounded: 0, moved: 0, failed: 0 };
-  const artifact = opts.verdictsPath ?? join34(dirname9(opts.reportPath), "VERIFY.todo.json");
+  const artifact = opts.verdictsPath ?? join34(dirname10(opts.reportPath), "VERIFY.todo.json");
   if (!existsSync21(artifact)) return { ok: false, issues: [s.semanticMissing(artifact)], ...empty };
   let items;
   try {
@@ -61087,7 +61462,7 @@ function openPerPage(audit2, standard, lang) {
 }
 
 // src/adjudicate.ts
-import { mkdirSync as mkdirSync9, statSync as statSync8, writeFileSync as writeFileSync10 } from "fs";
+import { mkdirSync as mkdirSync9, statSync as statSync12, writeFileSync as writeFileSync10 } from "fs";
 import { isAbsolute as isAbsolute3, join as join35, relative as relative4, resolve as resolve10 } from "path";
 
 // src/data/adjudication.json
@@ -62124,7 +62499,7 @@ function withinAuditInput(file, audit2, cwd) {
     if (input === "-" || input === "<stdin>") continue;
     const root = resolve10(cwd ?? process.cwd(), input);
     try {
-      if (statSync8(root).isDirectory()) {
+      if (statSync12(root).isDirectory()) {
         const rel2 = relative4(root, target);
         if (rel2 === "" || rel2 !== ".." && !rel2.startsWith("../") && !isAbsolute3(rel2)) return true;
       } else if (root === target) return true;
@@ -63082,7 +63457,7 @@ function pruneRefuted(audit2, standard, items, lang = "en") {
 // src/ledger.ts
 import { createHash as createHash6 } from "crypto";
 import { existsSync as existsSync22, mkdirSync as mkdirSync10, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname10, join as join36 } from "path";
+import { dirname as dirname11, join as join36 } from "path";
 var LEDGER_DIR = ".ultra11y/verdicts";
 function ledgerPath(standard, root = ".") {
   return join36(root, LEDGER_DIR, `${standard}.json`);
@@ -63144,7 +63519,7 @@ function unreadableCaptures(audit2, cwd = ".") {
   return (audit2.scope.pagesAudited ?? []).filter((id) => !existsSync22(join36(cwd, PAGES_DIR, id, "dom.html")));
 }
 function writeLedger(path, ledger) {
-  mkdirSync10(dirname10(path), { recursive: true });
+  mkdirSync10(dirname11(path), { recursive: true });
   const sorted = { ...ledger, entries: [...ledger.entries].sort((a, b) => a.criteriaId.localeCompare(b.criteriaId, "en", { numeric: true })) };
   writeFileSync11(path, `${JSON.stringify(sorted, null, 2)}
 `);
@@ -63740,9 +64115,9 @@ async function runCli2(argv, prompt, opts, extract) {
 
 // src/agent-codex.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync24, mkdtempSync as mkdtempSync2, rmSync as rmSync3, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync24, mkdtempSync as mkdtempSync3, rmSync as rmSync4, writeFileSync as writeFileSync12 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { delimiter as delimiter2, dirname as dirname11, join as join38 } from "path";
+import { delimiter as delimiter2, dirname as dirname12, join as join38 } from "path";
 var MAX_ATTEMPTS3 = 4;
 var CODEX_EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh"];
 var DEFAULT_CODEX_TIMEOUT_MS = 10 * 6e4;
@@ -63806,7 +64181,7 @@ function codexArgv(opts, schemaPath) {
     "multi_agent",
     "--strict-config",
     "--cd",
-    dirname11(schemaPath),
+    dirname12(schemaPath),
     "--skip-git-repo-check",
     "--sandbox",
     "read-only",
@@ -63893,7 +64268,7 @@ function transient(message) {
 }
 async function runCodex(schema, prompt, opts, extract) {
   const run2 = opts.spawnImpl ?? realSpawn2;
-  const dir = mkdtempSync2(join38(tmpdir2(), "ultra11y-codex-"));
+  const dir = mkdtempSync3(join38(tmpdir2(), "ultra11y-codex-"));
   const schemaPath = join38(dir, "schema.json");
   writeFileSync12(schemaPath, `${JSON.stringify(schema)}
 `, { mode: 384 });
@@ -63927,7 +64302,7 @@ async function runCodex(schema, prompt, opts, extract) {
       return extract(env.result);
     }
   } finally {
-    rmSync3(dir, { recursive: true, force: true });
+    rmSync4(dir, { recursive: true, force: true });
   }
   throw new Error(`ultra11y judge: ${lastError || "Codex failed after every attempt."}`);
 }
@@ -63948,7 +64323,7 @@ async function refuteBatchCodex(items, prompt, opts, lang = "en") {
 
 // src/scan.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import { mkdtempSync as mkdtempSync3, writeFileSync as writeFileSync13, existsSync as existsSync26, statSync as statSync9, readdirSync as readdirSync6, rmSync as rmSync4, readFileSync as readFileSync21 } from "fs";
+import { mkdtempSync as mkdtempSync4, writeFileSync as writeFileSync13, existsSync as existsSync26, statSync as statSync13, readdirSync as readdirSync6, rmSync as rmSync5, readFileSync as readFileSync21 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import { join as join39, resolve as resolve11 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -64291,14 +64666,14 @@ function imageExists(tag) {
 }
 var CTX_PREFIX = "ultra11y-dyn-";
 function buildImage(tag = IMAGE_TAG) {
-  const ctx = mkdtempSync3(join39(tmpdir3(), CTX_PREFIX));
+  const ctx = mkdtempSync4(join39(tmpdir3(), CTX_PREFIX));
   try {
     writeFileSync13(join39(ctx, "runner.mjs"), RUNNER);
     writeFileSync13(join39(ctx, "package.json"), PKG);
     writeFileSync13(join39(ctx, "Dockerfile"), DOCKERFILE);
     execFileSync6("docker", ["build", "-t", tag, ctx], { stdio: "inherit", timeout: 9e5 });
   } finally {
-    rmSync4(ctx, { recursive: true, force: true });
+    rmSync5(ctx, { recursive: true, force: true });
   }
 }
 function cleanTempContexts() {
@@ -64306,7 +64681,7 @@ function cleanTempContexts() {
   const dir = tmpdir3();
   for (const name2 of readdirSync6(dir)) {
     if (!name2.startsWith(CTX_PREFIX)) continue;
-    rmSync4(join39(dir, name2), { recursive: true, force: true });
+    rmSync5(join39(dir, name2), { recursive: true, force: true });
     removed++;
   }
   return removed;
@@ -64518,7 +64893,7 @@ function runScan(opts) {
   }
   const tag = opts.tag ?? IMAGE_TAG;
   if (!imageExists(tag)) buildImage(tag);
-  const isFile = !isUrl3 && existsSync26(opts.target) && statSync9(opts.target).isFile();
+  const isFile = !isUrl3 && existsSync26(opts.target) && statSync13(opts.target).isFile();
   const out2 = runRunner(opts.target, isFile, tag, Boolean(opts.snapshotRoot));
   const id = opts.snapshotRoot ? writeRunnerSnapshot(opts.snapshotRoot, out2, opts.target) : void 0;
   return { ...toDynamicResult(out2, opts.target), testedScs: [...DOCKER_TESTED_SCS], ...id ? { snapshots: [id] } : {} };
@@ -64797,7 +65172,7 @@ function mergeSnapshotAudit(base, snap) {
 }
 
 // src/scan-local.ts
-import { existsSync as existsSync27, statSync as statSync10 } from "fs";
+import { existsSync as existsSync27, statSync as statSync14 } from "fs";
 import { createRequire } from "module";
 import { resolve as resolve12 } from "path";
 
@@ -64901,7 +65276,8 @@ function focusSetupExpr(scope = "", maxFocusables = PROBE_DEFAULTS.maxFocusables
   const rootExpr = scope ? `document.querySelectorAll(${JSON.stringify(scope)})` : `[document.documentElement]`;
   return `(() => { ${PRELUDE}
   const sel = 'a[href],button:not([disabled]),input:not([type=hidden]):not([disabled]),select:not([disabled]),textarea:not([disabled]),[tabindex]:not([tabindex="-1"]),[role=button]:not([disabled])';
-  const snap = (e) => { const s = getComputedStyle(e); return [s.outlineStyle, s.outlineWidth, s.outlineColor, s.boxShadow, s.borderColor, s.borderTopWidth, s.borderBottomWidth, s.backgroundColor, s.color, s.textDecorationLine].join('|'); };
+  const __style = (e, pseudo) => { const s = getComputedStyle(e, pseudo); return [s.outlineStyle, s.outlineWidth, s.outlineColor, s.boxShadow, s.borderColor, s.borderTopWidth, s.borderBottomWidth, s.backgroundColor, s.color, s.textDecorationLine].join('|'); };
+  const snap = (e) => [__style(e, null), __style(e, '::before'), __style(e, '::after')].join('#');
   // Visually-hidden radio/checkbox \u2192 measure its visible label/proxy, not the input.
   const proxyFor = (e) => {
     const type = (e.getAttribute('type') || '').toLowerCase();
@@ -64943,8 +65319,12 @@ var FOCUS_CHECK_PROBE = `(() => {
   if (!key || !window.__u11yF || !window.__u11yF[key]) return null;
   const rec = window.__u11yF[key];
   const proxy = document.querySelector('[data-u11y-fp="' + key + '"]') || e;
-  const s = getComputedStyle(proxy);
-  const now = [s.outlineStyle, s.outlineWidth, s.outlineColor, s.boxShadow, s.borderColor, s.borderTopWidth, s.borderBottomWidth, s.backgroundColor, s.color, s.textDecorationLine].join('|');
+  // THE SAME THREE BOXES pass 1 snapshotted, in the same order. A design system that paints
+  // its control in label::before -- DSFR, GOV.UK, USWDS, Bootstrap -- puts the focus ring
+  // there too, and reading only the element would report every one of them as unfocusable.
+  // (No backticks in this comment: it lives inside a template literal.)
+  const st = (pseudo) => { const s = getComputedStyle(proxy, pseudo); return [s.outlineStyle, s.outlineWidth, s.outlineColor, s.boxShadow, s.borderColor, s.borderTopWidth, s.borderBottomWidth, s.backgroundColor, s.color, s.textDecorationLine].join('|'); };
+  const now = [st(null), st('::before'), st('::after')].join('#');
   return { key: key, changed: now !== rec.rest, selector: rec.sel, html: rec.html };
 })()`;
 var FOCUS_OBSCURED_PROBE = `(() => { ${PRELUDE}
@@ -65605,7 +65985,7 @@ async function runScanLocal(opts) {
   if (!isUrl3 && !existsSync27(opts.target)) {
     throw new Error(`File not found: ${opts.target}. Pass an http(s):// URL or an existing HTML file.`);
   }
-  const isFile = !isUrl3 && statSync10(opts.target).isFile();
+  const isFile = !isUrl3 && statSync14(opts.target).isFile();
   const lang = opts.lang ?? "en";
   const interact = opts.interact !== false;
   const { chromium, AxeBuilder } = resolveLocalDeps(opts.cwd);
@@ -66252,7 +66632,7 @@ function fixSummary(r, lang = "fr", write = false, standard = CORE2) {
 }
 
 // src/init.ts
-import { writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, chmodSync, realpathSync as realpathSync2 } from "fs";
+import { writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, chmodSync as chmodSync2, realpathSync as realpathSync3 } from "fs";
 import { execFileSync as execFileSync7 } from "child_process";
 import { join as join40, relative as relative5, sep as sep4 } from "path";
 var EN_SEV = { bloquant: "blocking", majeur: "major", mineur: "minor" };
@@ -66266,7 +66646,7 @@ function repoRoot() {
 function resolveEnginePath(root) {
   const argv1 = process.argv[1] ?? "scripts/ultra11y.mjs";
   try {
-    const abs = realpathSync2(argv1);
+    const abs = realpathSync3(argv1);
     return abs.startsWith(root + sep4) ? relative5(root, abs) : abs;
   } catch {
     return argv1;
@@ -66376,7 +66756,7 @@ function writeHook(root, enginePath, failOn, mode = "staged") {
   mkdirSync11(dir, { recursive: true });
   const path = join40(dir, "pre-commit");
   writeFileSync15(path, mode === "baseline" ? hookScript(enginePath, failOn) : stagedHookScript(enginePath, failOn));
-  chmodSync(path, 493);
+  chmodSync2(path, 493);
   return path;
 }
 function writeCi(root, enginePath, failOn) {
@@ -66388,8 +66768,8 @@ function writeCi(root, enginePath, failOn) {
 }
 
 // src/install/json-edit.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync28, mkdirSync as mkdirSync12, readFileSync as readFileSync23, renameSync as renameSync2, rmSync as rmSync5, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname12 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync28, mkdirSync as mkdirSync12, readFileSync as readFileSync23, renameSync as renameSync3, rmSync as rmSync6, writeFileSync as writeFileSync16 } from "fs";
+import { dirname as dirname13 } from "path";
 var SettingsParseError = class extends Error {
   constructor(path, cause) {
     super(`${path} is not valid JSON (${cause}) \u2014 fix or move it, then run install again. It has NOT been modified.`);
@@ -66403,7 +66783,7 @@ function stamp() {
 }
 function writeTextWithBackup(path, content, marker = "ultra11y") {
   if (existsSync28(path) && readFileSync23(path, "utf8") === content) return { path, changed: false };
-  mkdirSync12(dirname12(path), { recursive: true });
+  mkdirSync12(dirname13(path), { recursive: true });
   let backup;
   if (existsSync28(path)) {
     backup = `${path}.${marker}-backup-${stamp()}`;
@@ -66412,9 +66792,9 @@ function writeTextWithBackup(path, content, marker = "ultra11y") {
   const tmp = `${path}.${process.pid}.tmp`;
   try {
     writeFileSync16(tmp, content, { mode: 420 });
-    renameSync2(tmp, path);
+    renameSync3(tmp, path);
   } catch (e) {
-    rmSync5(tmp, { force: true });
+    rmSync6(tmp, { force: true });
     throw e;
   }
   return { path, changed: true, backup };
@@ -66485,7 +66865,7 @@ function claudeCodeWired(settingsPath) {
 }
 
 // src/install/text-edit.ts
-import { existsSync as existsSync29, readFileSync as readFileSync24, rmSync as rmSync6 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync24, rmSync as rmSync7 } from "fs";
 var BLOCK_BEGIN = "<!-- BEGIN ultra11y (managed by `ultra11y install --agents-md`; edit outside this block) -->";
 var BLOCK_END = "<!-- END ultra11y -->";
 var blockRe = () => new RegExp(`${escapeRe2(BLOCK_BEGIN)}[\\s\\S]*?${escapeRe2(BLOCK_END)}\\n?`);
@@ -66509,7 +66889,7 @@ function removeManagedBlock(path) {
   if (!blockRe().test(current)) return { path, changed: false };
   const rest = current.replace(blockRe(), "");
   if (rest.trim() === "") {
-    rmSync6(path, { force: true });
+    rmSync7(path, { force: true });
     return { path, changed: true };
   }
   return writeTextWithBackup(path, rest.replace(/\n+$/, "\n"));
@@ -66580,9 +66960,9 @@ import { existsSync as existsSync31, readFileSync as readFileSync26 } from "fs";
 import { join as join43 } from "path";
 
 // src/install/paths.ts
-import { copyFileSync as copyFileSync3, cpSync, existsSync as existsSync30, mkdirSync as mkdirSync13, readFileSync as readFileSync25, realpathSync as realpathSync3, statSync as statSync11 } from "fs";
+import { copyFileSync as copyFileSync3, cpSync, existsSync as existsSync30, mkdirSync as mkdirSync13, readFileSync as readFileSync25, realpathSync as realpathSync4, statSync as statSync15 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname13, join as join42 } from "path";
+import { dirname as dirname14, join as join42 } from "path";
 function codexHome() {
   return process.env.CODEX_HOME || join42(homedir2(), ".codex");
 }
@@ -66602,7 +66982,7 @@ function installedCliCommand() {
   const argv1 = process.argv[1];
   let source = null;
   try {
-    if (argv1) source = realpathSync3(argv1);
+    if (argv1) source = realpathSync4(argv1);
   } catch {
   }
   const ephemeral = !source || /[/\\](?:_npx|\.npm[/\\]_npx|npm-cache|Temp|tmp)[/\\]/.test(source);
@@ -66617,13 +66997,13 @@ function installedCliCommand() {
 function packageRoot() {
   let dir;
   try {
-    dir = dirname13(realpathSync3(process.argv[1] ?? ""));
+    dir = dirname14(realpathSync4(process.argv[1] ?? ""));
   } catch {
     return null;
   }
   for (let i2 = 0; i2 < 6 && dir && dir !== "/"; i2++) {
     if (existsSync30(join42(dir, "skills", "review-a11y", "SKILL.md"))) return dir;
-    dir = dirname13(dir);
+    dir = dirname14(dir);
   }
   return null;
 }
@@ -66647,7 +67027,7 @@ function copySkillsInto(source, dest) {
       const a = join42(from, f);
       const b = join42(to, f);
       try {
-        return existsSync30(b) && statSync11(a).size === statSync11(b).size && readFileSync25(a).equals(readFileSync25(b));
+        return existsSync30(b) && statSync15(a).size === statSync15(b).size && readFileSync25(a).equals(readFileSync25(b));
       } catch {
         return false;
       }
@@ -66751,7 +67131,7 @@ function codexHooksEnabled(codexDir) {
 }
 
 // src/install/opencode.ts
-import { existsSync as existsSync32, readFileSync as readFileSync27, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync27, rmSync as rmSync8 } from "fs";
 import { join as join44 } from "path";
 var OPENCODE_MARKER = "ULTRA11Y_OPENCODE_PLUGIN";
 function pluginTarget(configDir) {
@@ -66780,8 +67160,8 @@ function uninstallOpencode({ configDir }) {
   const reports = [];
   const target = pluginTarget(configDir);
   if (existsSync32(target) && readFileSync27(target, "utf8").includes(OPENCODE_MARKER)) {
-    rmSync7(target, { force: true });
-    rmSync7(join44(configDir, "plugin", "ultra11y.mjs"), { force: true });
+    rmSync8(target, { force: true });
+    rmSync8(join44(configDir, "plugin", "ultra11y.mjs"), { force: true });
     reports.push({ path: target, changed: true });
   }
   const configPath = join44(configDir, "opencode.json");
@@ -68126,7 +68506,7 @@ function writeEvidence(result, opts) {
 }
 
 // src/html-emit.ts
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync29, statSync as statSync12, writeFileSync as writeFileSync18 } from "fs";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync29, statSync as statSync16, writeFileSync as writeFileSync18 } from "fs";
 import { join as join47 } from "path";
 
 // src/html.ts
@@ -68767,7 +69147,7 @@ var T5 = {
 var mb = (n) => (n / (1024 * 1024)).toFixed(1);
 function inlineSize(path) {
   try {
-    return Math.ceil(statSync12(path).size / 3) * 4;
+    return Math.ceil(statSync16(path).size / 3) * 4;
   } catch {
     return 0;
   }
@@ -68928,7 +69308,7 @@ function noticeRuns(notices) {
 // src/dev.ts
 import { createServer } from "http";
 import { mkdirSync as mkdirSync16, readFileSync as readFileSync30, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname14, join as join48 } from "path";
+import { dirname as dirname15, join as join48 } from "path";
 var DEV_DEFAULT_PORT = 4111;
 function criterionLabel3(f, standard) {
   if (isCore(standard)) return `WCAG ${f.criteriaId}`;
@@ -69286,7 +69666,7 @@ function startDevServer(opts) {
           let auditPath;
           if (applied.ok) {
             auditPath = join48(opts.root, "audits", "audit-latest.json");
-            mkdirSync16(dirname14(auditPath), { recursive: true });
+            mkdirSync16(dirname15(auditPath), { recursive: true });
             writeFileSync19(auditPath, `${JSON.stringify(applied.audit, null, 2)}
 `);
           }
@@ -69605,7 +69985,7 @@ function e2eSetupPlan(runners, paths, lang = "en") {
 }
 
 // src/orchestrate.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync17, readFileSync as readFileSync31, rmSync as rmSync8, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync17, readFileSync as readFileSync31, rmSync as rmSync9, writeFileSync as writeFileSync20 } from "fs";
 import { join as join50, resolve as resolve13 } from "path";
 
 // src/orchestrate-templates.ts
@@ -69990,7 +70370,7 @@ function orchestrateRun(runDir, engineAbs, opts = {}) {
     if (emitted.has(ph.name)) continue;
     const stale = join50(orchDir, `${ph.name}.workflow.mjs`);
     if (existsSync35(stale)) {
-      rmSync8(stale, { force: true });
+      rmSync9(stale, { force: true });
       notices.push(`phase "${ph.name}": stale workflow removed \u2014 its worklist ${ph.ready ? "is now empty" : "no longer exists"}.`);
     }
   }
@@ -70018,7 +70398,7 @@ function orchestrateRun(runDir, engineAbs, opts = {}) {
 import { createInterface as createInterface2 } from "readline";
 
 // src/mcp/handlers.ts
-import { existsSync as existsSync36, readFileSync as readFileSync32, realpathSync as realpathSync4, statSync as statSync13 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync32, realpathSync as realpathSync5, statSync as statSync17 } from "fs";
 import { isAbsolute as isAbsolute4, join as join51, resolve as resolve14, sep as sep5 } from "path";
 
 // src/criteria-view.ts
@@ -70504,7 +70884,7 @@ function requiredCwd(args2, defaults) {
   if (!cwd) throw new ToolError("`cwd` is required: an absolute path to the project root.");
   const abs = resolve14(cwd);
   if (!existsSync36(abs)) throw new ToolError(`project root not found: ${abs}`);
-  if (!statSync13(abs).isDirectory()) throw new ToolError(`\`cwd\` is not a directory: ${abs}`);
+  if (!statSync17(abs).isDirectory()) throw new ToolError(`\`cwd\` is not a directory: ${abs}`);
   return abs;
 }
 function optionalCwd(args2, defaults) {
@@ -70924,15 +71304,15 @@ function handleRead(args2, cwd) {
   const target = isAbsolute4(raw) ? raw : join51(cwd, raw);
   let real;
   try {
-    real = realpathSync4(target);
+    real = realpathSync5(target);
   } catch {
     throw new ToolError(`no such file: ${raw}`);
   }
-  const root = realpathSync4(cwd);
+  const root = realpathSync5(cwd);
   if (real !== root && !real.startsWith(root + sep5)) {
     throw new ToolError(`path is outside the project: ${raw}. Use your own file tool for anything else.`);
   }
-  const st = statSync13(real);
+  const st = statSync17(real);
   if (!st.isFile()) throw new ToolError(`not a file: ${raw}`);
   if (st.size > MAX_READ_BYTES) throw new ToolError(`file is too large to read (${st.size} bytes): ${raw}`);
   const lines = readFileSync32(real, "utf8").split("\n");
@@ -71590,13 +71970,13 @@ function str3(v) {
 var DECLARED = new Set([...TOOLS2, ...WRITE_TOOLS].map((t3) => t3.name));
 
 // src/mcp/resources.ts
-import { existsSync as existsSync37, readdirSync as readdirSync7, readFileSync as readFileSync33, realpathSync as realpathSync5, statSync as statSync14 } from "fs";
-import { basename as basename3, dirname as dirname15, join as join52, resolve as resolve15, sep as sep6 } from "path";
+import { existsSync as existsSync37, readdirSync as readdirSync7, readFileSync as readFileSync33, realpathSync as realpathSync6, statSync as statSync18 } from "fs";
+import { basename as basename4, dirname as dirname16, join as join52, resolve as resolve15, sep as sep6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var SKILL_NAME = "ultra11y";
 var URI_SCHEME = "skill://";
 function resolveSkillRoot(moduleDir) {
-  const here = moduleDir ?? dirname15(fileURLToPath4(import.meta.url));
+  const here = moduleDir ?? dirname16(fileURLToPath4(import.meta.url));
   const candidates2 = [resolve15(here, ".."), resolve15(here, "..", "skills", SKILL_NAME), resolve15(here, "..", "..", "skills", SKILL_NAME)];
   return candidates2.find((dir) => existsSync37(join52(dir, "SKILL.md")));
 }
@@ -71608,7 +71988,7 @@ function listResources(moduleDir) {
   if (!existsSync37(refDir)) return out2;
   for (const file of readdirSync7(refDir).sort()) {
     if (!file.endsWith(".md")) continue;
-    out2.push(describe(root, join52("references", file), `${SKILL_NAME} reference: ${basename3(file, ".md")}`));
+    out2.push(describe(root, join52("references", file), `${SKILL_NAME} reference: ${basename4(file, ".md")}`));
   }
   return out2;
 }
@@ -71621,17 +72001,17 @@ function readResource(uri, moduleDir) {
   const rel2 = uri.slice(URI_SCHEME.length);
   if (!rel2) throw new ResourceError("empty resource path");
   const target = resolve15(root, rel2);
-  const rootReal = realpathSync5(root);
+  const rootReal = realpathSync6(root);
   let targetReal;
   try {
-    targetReal = realpathSync5(target);
+    targetReal = realpathSync6(target);
   } catch {
     throw new ResourceError(`no such resource: ${uri}`);
   }
   if (targetReal !== rootReal && !targetReal.startsWith(rootReal + sep6)) {
     throw new ResourceError(`resource path escapes the skill root: ${uri}`);
   }
-  if (!statSync14(targetReal).isFile()) throw new ResourceError(`not a file: ${uri}`);
+  if (!statSync18(targetReal).isFile()) throw new ResourceError(`not a file: ${uri}`);
   return { uri, mimeType: "text/markdown", text: readFileSync33(targetReal, "utf8") };
 }
 var ResourceError = class extends Error {
@@ -73077,7 +73457,7 @@ async function cmdAudit(p) {
     const asFile = out2.toLowerCase().endsWith(".json");
     const target = asFile ? out2 : join53(out2, "audit-latest.json");
     try {
-      mkdirSync18(asFile ? dirname16(out2) : out2, { recursive: true });
+      mkdirSync18(asFile ? dirname17(out2) : out2, { recursive: true });
       writeFileSync21(target, JSON.stringify(document, null, 2) + "\n");
       console.error(lang === "fr" ? `\u2192 audit \xE9crit dans ${target}` : `\u2192 audit written to ${target}`);
     } catch {
@@ -74001,7 +74381,7 @@ function depsAt(root) {
 function engineRefFor(root) {
   let ref = process.argv[1] ?? "scripts/ultra11y.mjs";
   try {
-    const abs = realpathSync6(ref);
+    const abs = realpathSync7(ref);
     ref = abs.startsWith(root + sep7) ? relative6(root, abs) : abs;
   } catch {
   }
@@ -74064,7 +74444,7 @@ Fill in COMPONENTS, run it (e.g. npx tsx ${out2}), then: node scripts/ultra11y.m
     const rel2 = ".ultra11y/capture-setup.mjs";
     const out2 = join53(root, rel2);
     try {
-      mkdirSync18(dirname16(out2), { recursive: true });
+      mkdirSync18(dirname17(out2), { recursive: true });
       writeFileSync21(out2, captureSetup());
     } catch (e) {
       console.error(`ultra11y render: could not write ${out2}: ${e instanceof Error ? e.message : String(e)}`);
@@ -75627,7 +76007,7 @@ function cmdOrchestrate(p) {
     );
     return 2;
   }
-  const engineAbs = realpathSync6(fileURLToPath5(import.meta.url));
+  const engineAbs = realpathSync7(fileURLToPath5(import.meta.url));
   if (p.flags.list === true) {
     if (!existsSync38(runFlag)) {
       console.error(`ultra11y orchestrate: run dir not found: ${runFlag}.`);
@@ -75778,7 +76158,7 @@ function isInvokedDirectly() {
   if (argv1 === void 0) return false;
   const modulePath = fileURLToPath5(import.meta.url);
   try {
-    if (realpathSync6(argv1) === realpathSync6(modulePath)) return true;
+    if (realpathSync7(argv1) === realpathSync7(modulePath)) return true;
   } catch {
   }
   return import.meta.url === pathToFileURL3(argv1).href;