@inerrata-corporation/errata 2.0.4 → 2.0.5

package/errata.mjs

@@ -911,7 +911,7 @@ function lemma(token) {
   }
   return token;
 }
-function tokenize(text, resolve6) {
+function tokenize(text, resolve7) {
   const matches = text.normalize("NFC").toLowerCase().match(TOKEN_RE) ?? [];
   const out2 = /* @__PURE__ */ new Set();
   for (const raw2 of matches) {
@@ -921,7 +921,7 @@ function tokenize(text, resolve6) {
       out2.add(token);
       continue;
     }
-    const canonical = resolve6(token);
+    const canonical = resolve7(token);
     out2.add(canonical ?? lemma(token));
   }
   return [...out2].sort();
@@ -28165,17 +28165,117 @@ var init_identity2 = __esm({
   }
 });
 
+// src/git-remote.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6, statSync } from "node:fs";
+import { isAbsolute, join as join6, resolve } from "node:path";
+function resolveGitDir(root) {
+  const dotGit = join6(root, ".git");
+  try {
+    const st = statSync(dotGit);
+    if (st.isDirectory()) return dotGit;
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync6(dotGit, "utf8"));
+    if (!m) return null;
+    const dir = m[1];
+    return isAbsolute(dir) ? dir : resolve(root, dir);
+  } catch {
+    return null;
+  }
+}
+function gitConfigPath(gitDir) {
+  const commondirFile = join6(gitDir, "commondir");
+  if (existsSync8(commondirFile)) {
+    const common = readFileSync6(commondirFile, "utf8").trim();
+    const commonDir = isAbsolute(common) ? common : resolve(gitDir, common);
+    return join6(commonDir, "config");
+  }
+  return join6(gitDir, "config");
+}
+function readRemotes(root) {
+  const gitDir = resolveGitDir(root);
+  if (!gitDir) return [];
+  const cfgPath = gitConfigPath(gitDir);
+  if (!existsSync8(cfgPath)) return [];
+  let txt;
+  try {
+    txt = readFileSync6(cfgPath, "utf8");
+  } catch {
+    return [];
+  }
+  const out2 = [];
+  const sectionRe = /^\s*\[remote "([^"]+)"\]\s*$([\s\S]*?)(?=^\s*\[|\s*$(?![\s\S]))/gm;
+  for (const m of txt.matchAll(sectionRe)) {
+    const url2 = /^\s*url\s*=\s*(.+?)\s*$/m.exec(m[2])?.[1];
+    if (url2) out2.push({ name: m[1], url: url2 });
+  }
+  return out2;
+}
+function detectRepoLocator(root, remote) {
+  const remotes = readRemotes(root);
+  if (remotes.length === 0) return null;
+  const pick2 = remote ? remotes.find((r) => r.name === remote) ?? null : remotes.find((r) => r.name === "origin") ?? (remotes.length === 1 ? remotes[0] : null);
+  return pick2 ? normalizeRepoLocator(pick2.url) : null;
+}
+var init_git_remote = __esm({
+  "src/git-remote.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
+// src/checkout-root.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
+import { basename, dirname as dirname5, isAbsolute as isAbsolute2, join as join7, resolve as resolve2 } from "node:path";
+function nearestGitRoot(dir) {
+  let cur = resolve2(dir);
+  for (; ; ) {
+    if (existsSync9(join7(cur, ".git"))) return cur;
+    const parent = dirname5(cur);
+    if (parent === cur) return null;
+    cur = parent;
+  }
+}
+function mainCheckoutOfWorktree(root) {
+  const gitDir = resolveGitDir(root);
+  if (!gitDir || gitDir === join7(root, ".git")) return null;
+  const commondirFile = join7(gitDir, "commondir");
+  if (!existsSync9(commondirFile)) return null;
+  let common;
+  try {
+    common = readFileSync7(commondirFile, "utf8").trim();
+  } catch {
+    return null;
+  }
+  const commonDir = resolve2(isAbsolute2(common) ? common : resolve2(gitDir, common));
+  if (basename(commonDir) !== ".git") return null;
+  const main2 = dirname5(commonDir);
+  return existsSync9(join7(main2, ".git")) ? main2 : null;
+}
+function checkoutRootOf(cwd) {
+  const root = nearestGitRoot(cwd);
+  const main2 = root ? mainCheckoutOfWorktree(root) : null;
+  return main2 ?? resolve2(cwd);
+}
+function isLinkedWorktree(root) {
+  return mainCheckoutOfWorktree(root) !== null;
+}
+var init_checkout_root = __esm({
+  "src/checkout-root.ts"() {
+    "use strict";
+    init_git_remote();
+  }
+});
+
 // src/registry.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join8 } from "node:path";
 function registryPath() {
-  return process.env["ERRATA_REGISTRY_PATH"] ?? join6(globalDir(), "workspaces.json");
+  return process.env["ERRATA_REGISTRY_PATH"] ?? join8(globalDir(), "workspaces.json");
 }
 function read() {
   const p = registryPath();
-  if (!existsSync8(p)) return { version: 1, workspaces: {} };
+  if (!existsSync10(p)) return { version: 1, workspaces: {} };
   try {
-    const parsed = JSON.parse(readFileSync6(p, "utf8"));
+    const parsed = JSON.parse(readFileSync8(p, "utf8"));
     return { version: 1, workspaces: parsed.workspaces ?? {} };
   } catch {
     return { version: 1, workspaces: {} };
@@ -28183,9 +28283,9 @@ function read() {
 }
 function registryCorrupt() {
   const p = registryPath();
-  if (!existsSync8(p)) return false;
+  if (!existsSync10(p)) return false;
   try {
-    JSON.parse(readFileSync6(p, "utf8"));
+    JSON.parse(readFileSync8(p, "utf8"));
     return false;
   } catch {
     return true;
@@ -28196,6 +28296,7 @@ function write(reg) {
   writeFileSync7(registryPath(), JSON.stringify(reg, null, 2), "utf8");
 }
 function registerWorkspace(profile, root, now = Date.now()) {
+  if (isLinkedWorktree(root)) return;
   const reg = read();
   reg.workspaces[profile.id] = {
     ...reg.workspaces[profile.id],
@@ -28234,7 +28335,7 @@ function pruneMissingWorkspaces() {
   const reg = read();
   const removed = [];
   for (const [id, entry] of Object.entries(reg.workspaces)) {
-    if (!existsSync8(entry.path)) {
+    if (!existsSync10(entry.path)) {
       removed.push(entry);
       delete reg.workspaces[id];
     }
@@ -28243,13 +28344,13 @@ function pruneMissingWorkspaces() {
   return removed;
 }
 function workspaceStatus(entry) {
-  const missing = !existsSync8(entry.path);
+  const missing = !existsSync10(entry.path);
   const lockPath = workspacePaths(entry.path).daemonLock;
   let running = false;
   let webUiUrl = null;
-  if (existsSync8(lockPath)) {
+  if (existsSync10(lockPath)) {
     try {
-      const lock = JSON.parse(readFileSync6(lockPath, "utf8"));
+      const lock = JSON.parse(readFileSync8(lockPath, "utf8"));
       if (lock.pid && lock.webUiUrl && pidAlive(lock.pid)) {
         running = true;
         webUiUrl = lock.webUiUrl;
@@ -28277,6 +28378,7 @@ var init_registry = __esm({
   "src/registry.ts"() {
     "use strict";
     init_paths();
+    init_checkout_root();
   }
 });
 
@@ -29053,26 +29155,26 @@ function buildFileLexicon(store) {
   for (const n of store.findNodesByLabel("File")) {
     const relPath = typeof n.attrs["relPath"] === "string" && n.attrs["relPath"].length > 0 ? n.attrs["relPath"] : n.description;
     if (!relPath) continue;
-    const basename5 = relPath.split("/").pop();
-    if (!basename5.includes(".")) continue;
-    entries.push({ relPath, basename: basename5 });
-    basenameCount.set(basename5, (basenameCount.get(basename5) ?? 0) + 1);
-    const stem = basename5.slice(0, basename5.indexOf("."));
+    const basename6 = relPath.split("/").pop();
+    if (!basename6.includes(".")) continue;
+    entries.push({ relPath, basename: basename6 });
+    basenameCount.set(basename6, (basenameCount.get(basename6) ?? 0) + 1);
+    const stem = basename6.slice(0, basename6.indexOf("."));
     if (isBareMatchableStem(stem)) {
       let s = stemRelPaths.get(stem);
       if (!s) stemRelPaths.set(stem, s = /* @__PURE__ */ new Set());
       s.add(relPath);
     }
   }
-  for (const { relPath, basename: basename5 } of entries) {
+  for (const { relPath, basename: basename6 } of entries) {
     const entry = { relPath };
-    if (relPath !== basename5) byKey.set(relPath, entry);
-    const conventional = CONVENTION_FILENAMES.has(basename5) || (basenameCount.get(basename5) ?? 0) >= CONVENTION_BASENAME_MIN_FILES;
-    if (!conventional && !byKey.has(basename5)) byKey.set(basename5, entry);
-    const list = byBasename.get(basename5);
+    if (relPath !== basename6) byKey.set(relPath, entry);
+    const conventional = CONVENTION_FILENAMES.has(basename6) || (basenameCount.get(basename6) ?? 0) >= CONVENTION_BASENAME_MIN_FILES;
+    if (!conventional && !byKey.has(basename6)) byKey.set(basename6, entry);
+    const list = byBasename.get(basename6);
     if (list) list.push(entry);
-    else byBasename.set(basename5, [entry]);
-    const stem = basename5.slice(0, basename5.indexOf("."));
+    else byBasename.set(basename6, [entry]);
+    const stem = basename6.slice(0, basename6.indexOf("."));
     if (isBareMatchableStem(stem) && !CONVENTION_STEMS.has(stem) && !byStem.has(stem)) {
       const dirStems = new Set(
         [...stemRelPaths.get(stem) ?? []].map((p) => {
@@ -29089,8 +29191,8 @@ function resolveFileToken(token, lexicon) {
   const exact = lexicon.byKey.get(token);
   if (exact) return exact;
   if (!token.includes("/")) return null;
-  const basename5 = token.split("/").pop();
-  for (const entry of lexicon.byBasename.get(basename5) ?? []) {
+  const basename6 = token.split("/").pop();
+  for (const entry of lexicon.byBasename.get(basename6) ?? []) {
     if (entry.relPath === token || entry.relPath.endsWith(`/${token}`)) return entry;
   }
   return null;
@@ -29115,9 +29217,9 @@ function fileRolePhrase(relPath, level = 1) {
   return "a source file";
 }
 function isSourceFileToken(token) {
-  const basename5 = token.split(/[/\\]/).pop() ?? token;
-  if (CONVENTION_FILENAMES.has(basename5)) return false;
-  const ext = basename5.split(".").pop();
+  const basename6 = token.split(/[/\\]/).pop() ?? token;
+  if (CONVENTION_FILENAMES.has(basename6)) return false;
+  const ext = basename6.split(".").pop();
   return ext !== void 0 && SOURCE_EXTENSIONS.has(ext.toLowerCase());
 }
 function generalizeFileRefs(text, fileLexicon, level = 1) {
@@ -29702,7 +29804,7 @@ var init_diagnostic_matcher = __esm({
 });
 
 // ../../packages/generalizer/src/generalizer.ts
-import { isAbsolute, join as join7, relative } from "node:path";
+import { isAbsolute as isAbsolute3, join as join9, relative } from "node:path";
 async function runGeneralizer(opts) {
   const report = {
     eventsProcessed: 0,
@@ -29810,7 +29912,7 @@ function extractDiagnostics(ev) {
 function diagRelPath(file2, cwd, workspaceRoot) {
   const norm = (p) => p.replace(/\\/g, "/");
   if (!workspaceRoot) return norm(file2);
-  const abs = isAbsolute(file2) ? file2 : join7(cwd ?? workspaceRoot, file2);
+  const abs = isAbsolute3(file2) ? file2 : join9(cwd ?? workspaceRoot, file2);
   return norm(relative(workspaceRoot, abs));
 }
 function extractErrorSignature(ev) {
@@ -31453,22 +31555,22 @@ var init_src10 = __esm({
 
 // ../../packages/indexer/src/parse-cache.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync7, readdirSync as readdirSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync9, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join10 } from "node:path";
 function parseCacheDir() {
-  return process.env["ERRATA_PARSE_CACHE"] ?? join8(homedir3(), ".errata", "parse-cache");
+  return process.env["ERRATA_PARSE_CACHE"] ?? join10(homedir3(), ".errata", "parse-cache");
 }
 function parseCacheKey(source, providerId) {
   return createHash3("sha256").update(`${PARSE_CACHE_VERSION}:${providerId}:${source}`).digest("hex");
 }
 function entryPath(dir, key) {
-  return join8(dir, key.slice(0, 2), `${key.slice(2)}.json`);
+  return join10(dir, key.slice(0, 2), `${key.slice(2)}.json`);
 }
 function readParseCache(dir, key) {
   const file2 = entryPath(dir, key);
   try {
-    const raw2 = readFileSync7(file2, "utf8");
+    const raw2 = readFileSync9(file2, "utf8");
     const parsed = JSON.parse(raw2);
     if (parsed.v !== PARSE_CACHE_VERSION || !Array.isArray(parsed.symbols)) return null;
     return { symbols: parsed.symbols, reExports: parsed.reExports ?? [] };
@@ -31487,7 +31589,7 @@ function writeParseCache(dir, key, providerId, value) {
     const body2 = JSON.stringify(envelope);
     if (body2.length > MAX_ENTRY_BYTES) return;
     const file2 = entryPath(dir, key);
-    mkdirSync6(join8(dir, key.slice(0, 2)), { recursive: true });
+    mkdirSync6(join10(dir, key.slice(0, 2)), { recursive: true });
     writeFileSync8(file2, body2);
   } catch {
   }
@@ -31497,9 +31599,9 @@ function sweepParseCacheOnce(dir, now = Date.now()) {
   sweptThisProcess = true;
   let removed = 0;
   try {
-    if (!existsSync9(dir)) return 0;
+    if (!existsSync11(dir)) return 0;
     for (const bucket of readdirSync2(dir)) {
-      const bucketDir = join8(dir, bucket);
+      const bucketDir = join10(dir, bucket);
       let names;
       try {
         names = readdirSync2(bucketDir);
@@ -31507,9 +31609,9 @@ function sweepParseCacheOnce(dir, now = Date.now()) {
         continue;
       }
       for (const name2 of names) {
-        const file2 = join8(bucketDir, name2);
+        const file2 = join10(bucketDir, name2);
         try {
-          if (now - statSync(file2).mtimeMs > ENTRY_TTL_MS) {
+          if (now - statSync2(file2).mtimeMs > ENTRY_TTL_MS) {
             rmSync2(file2, { force: true });
             removed++;
           }
@@ -31755,9 +31857,9 @@ var init_identity3 = __esm({
 });
 
 // ../../packages/indexer/src/pipeline.ts
-import { appendFileSync, readFileSync as readFileSync8, statSync as statSync2 } from "node:fs";
+import { appendFileSync, readFileSync as readFileSync10, statSync as statSync3 } from "node:fs";
 import { readdir } from "node:fs/promises";
-import { extname, join as join9, relative as relative2, sep } from "node:path";
+import { extname, join as join11, relative as relative2, sep } from "node:path";
 import { createHash as createHash4 } from "node:crypto";
 import { execFileSync } from "node:child_process";
 function nowTs() {
@@ -31895,7 +31997,7 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
   for (const rel of [...changedRelPaths]) {
     let h;
     try {
-      h = createHash4("sha256").update(readFileSync8(join9(rootPath, rel))).digest("hex");
+      h = createHash4("sha256").update(readFileSync10(join11(rootPath, rel))).digest("hex");
     } catch {
       continue;
     }
@@ -31944,13 +32046,13 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
   let parsedFiles = 0;
   for (const rel of changedRelPaths) {
     if (parsedFiles++ > 0) await new Promise((r2) => setImmediate(r2));
-    const abs = join9(rootPath, ...rel.split("/"));
+    const abs = join11(rootPath, ...rel.split("/"));
     const ext = extname(abs).toLowerCase();
     const provider = providers.find((p) => p.fileExtensions.includes(ext));
     if (!provider) continue;
     let symbols;
     try {
-      symbols = provider.extractSymbols(readFileSync8(abs, "utf8"), abs);
+      symbols = provider.extractSymbols(readFileSync10(abs, "utf8"), abs);
     } catch {
       continue;
     }
@@ -32265,12 +32367,12 @@ async function runIndexer(store, opts) {
     }
     let source;
     try {
-      const st = statSync2(f.absPath);
+      const st = statSync3(f.absPath);
       if (st.size > maxBytes) {
         report.filesSkipped++;
         continue;
       }
-      source = readFileSync8(f.absPath, "utf8");
+      source = readFileSync10(f.absPath, "utf8");
     } catch {
       report.filesSkipped++;
       continue;
@@ -32342,7 +32444,7 @@ async function runIndexer(store, opts) {
     const depth = fileNode.relPath.split("/").length;
     if (depth !== 3) continue;
     try {
-      const pkg = JSON.parse(readFileSync8(fileNode.absPath, "utf8"));
+      const pkg = JSON.parse(readFileSync10(fileNode.absPath, "utf8"));
       if (!pkg.name) continue;
       const pkgDir = fileNode.relPath.replace(/\/package\.json$/, "");
       const candidates = [
@@ -32730,7 +32832,7 @@ async function scan(root, current, ignores, providers, out2) {
   for (const ent of entries) {
     if (ignores.has(ent.name)) continue;
     if (ent.name.startsWith(".") && ent.name !== ".") continue;
-    const abs = join9(current, ent.name);
+    const abs = join11(current, ent.name);
     if (ent.isDirectory()) {
       await scan(root, abs, ignores, providers, out2);
     } else if (ent.isFile()) {
@@ -32739,7 +32841,7 @@ async function scan(root, current, ignores, providers, out2) {
       const rel = relative2(root, abs).split(sep).join("/");
       let size = 0;
       try {
-        size = statSync2(abs).size;
+        size = statSync3(abs).size;
       } catch {
         continue;
       }
@@ -32785,10 +32887,10 @@ function gitListFiles(root, ignores, providers) {
   if (rels === null) return null;
   const out2 = [];
   for (const rel of rels) {
-    const abs = join9(root, rel);
+    const abs = join11(root, rel);
     let size;
     try {
-      size = statSync2(abs).size;
+      size = statSync3(abs).size;
     } catch {
       continue;
     }
@@ -32808,7 +32910,7 @@ function upsertFile(store, id, f, workspaceId2, skip) {
   const now = nowTs();
   let contentHash;
   try {
-    contentHash = createHash4("sha256").update(readFileSync8(f.absPath)).digest("hex");
+    contentHash = createHash4("sha256").update(readFileSync10(f.absPath)).digest("hex");
   } catch {
   }
   const node2 = {
@@ -33412,13 +33514,13 @@ async function Module2(moduleArg = {}) {
       }
       readAsync = /* @__PURE__ */ __name(async (url2) => {
         if (isFileURI(url2)) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve7, reject) => {
             var xhr = new XMLHttpRequest();
             xhr.open("GET", url2, true);
             xhr.responseType = "arraybuffer";
             xhr.onload = () => {
               if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                resolve6(xhr.response);
+                resolve7(xhr.response);
                 return;
               }
               reject(xhr.status);
@@ -33614,9 +33716,9 @@ async function Module2(moduleArg = {}) {
     __name(receiveInstantiationResult, "receiveInstantiationResult");
     var info2 = getWasmImports();
     if (Module["instantiateWasm"]) {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         Module["instantiateWasm"](info2, (mod, inst) => {
-          resolve6(receiveInstance(mod, inst));
+          resolve7(receiveInstance(mod, inst));
         });
       });
     }
@@ -34947,8 +35049,8 @@ async function Module2(moduleArg = {}) {
   if (runtimeInitialized) {
     moduleRtn = Module;
   } else {
-    moduleRtn = new Promise((resolve6, reject) => {
-      readyPromiseResolve = resolve6;
+    moduleRtn = new Promise((resolve7, reject) => {
+      readyPromiseResolve = resolve7;
       readyPromiseReject = reject;
     });
   }
@@ -37178,42 +37280,42 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 
 // ../../packages/indexer/src/languages/tree-sitter-loader.ts
 import { fileURLToPath } from "node:url";
-import { dirname as dirname5, join as join10 } from "node:path";
-import { existsSync as existsSync10, readdirSync as readdirSync3 } from "node:fs";
+import { dirname as dirname6, join as join12 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync3 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 function entryDir() {
   try {
     const url2 = import.meta?.url;
     if (typeof url2 === "string" && url2.length > 0) {
-      return dirname5(fileURLToPath(url2));
+      return dirname6(fileURLToPath(url2));
     }
   } catch {
   }
-  return dirname5(process.execPath);
+  return dirname6(process.execPath);
 }
 function findWasmDir() {
   const here = entryDir();
-  const seaWasm = join10(here, "resources", "wasm");
-  if (existsSync10(join10(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
+  const seaWasm = join12(here, "resources", "wasm");
+  if (existsSync12(join12(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const flat = join10(
+    const flat = join12(
       dir,
       "node_modules",
       "@vscode",
       "tree-sitter-wasm",
       "wasm"
     );
-    if (existsSync10(join10(flat, "tree-sitter-typescript.wasm"))) return flat;
-    dir = dirname5(dir);
+    if (existsSync12(join12(flat, "tree-sitter-typescript.wasm"))) return flat;
+    dir = dirname6(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const pnpmDir = join10(root, "node_modules", ".pnpm");
-    if (existsSync10(pnpmDir)) {
+    const pnpmDir = join12(root, "node_modules", ".pnpm");
+    if (existsSync12(pnpmDir)) {
       for (const entry of readdirSync3(pnpmDir)) {
         if (entry.startsWith("@vscode+tree-sitter-wasm@")) {
-          const candidate = join10(
+          const candidate = join12(
             pnpmDir,
             entry,
             "node_modules",
@@ -37221,13 +37323,13 @@ function findWasmDir() {
             "tree-sitter-wasm",
             "wasm"
           );
-          if (existsSync10(join10(candidate, "tree-sitter-typescript.wasm"))) {
+          if (existsSync12(join12(candidate, "tree-sitter-typescript.wasm"))) {
             return candidate;
           }
         }
       }
     }
-    root = dirname5(root);
+    root = dirname6(root);
   }
   throw new Error(
     "@vscode/tree-sitter-wasm grammar files not found \u2014 is the package installed?"
@@ -37235,33 +37337,33 @@ function findWasmDir() {
 }
 function findRuntimeDir() {
   const here = entryDir();
-  const seaRuntime = join10(here, "resources", "wasm");
-  if (existsSync10(join10(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
+  const seaRuntime = join12(here, "resources", "wasm");
+  if (existsSync12(join12(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const flat = join10(dir, "node_modules", "web-tree-sitter");
-    if (existsSync10(join10(flat, "web-tree-sitter.wasm"))) return flat;
-    dir = dirname5(dir);
+    const flat = join12(dir, "node_modules", "web-tree-sitter");
+    if (existsSync12(join12(flat, "web-tree-sitter.wasm"))) return flat;
+    dir = dirname6(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const pnpmDir = join10(root, "node_modules", ".pnpm");
-    if (existsSync10(pnpmDir)) {
+    const pnpmDir = join12(root, "node_modules", ".pnpm");
+    if (existsSync12(pnpmDir)) {
       for (const entry of readdirSync3(pnpmDir)) {
         if (entry.startsWith("web-tree-sitter@")) {
-          const candidate = join10(
+          const candidate = join12(
             pnpmDir,
             entry,
             "node_modules",
             "web-tree-sitter"
           );
-          if (existsSync10(join10(candidate, "web-tree-sitter.wasm"))) {
+          if (existsSync12(join12(candidate, "web-tree-sitter.wasm"))) {
             return candidate;
           }
         }
       }
     }
-    root = dirname5(root);
+    root = dirname6(root);
   }
   throw new Error("web-tree-sitter runtime WASM not found");
 }
@@ -37272,7 +37374,7 @@ async function loadWebTreeSitter() {
     void err2;
   }
   const here = entryDir();
-  const seaResourceBase = join10(here, "resources", "_resolve.js");
+  const seaResourceBase = join12(here, "resources", "_resolve.js");
   const resourceRequire = createRequire2(seaResourceBase);
   return resourceRequire("web-tree-sitter");
 }
@@ -37287,9 +37389,9 @@ async function ensureTreeSitterReady() {
     await Parser2.init({
       locateFile: (name2) => {
         if (name2 === "tree-sitter.wasm" || name2 === "web-tree-sitter.wasm") {
-          return join10(runtime, name2);
+          return join12(runtime, name2);
         }
-        return join10(grammars, name2);
+        return join12(grammars, name2);
       }
     });
   })();
@@ -37301,7 +37403,7 @@ async function loadGrammar(name2) {
   if (cached2) return cached2;
   if (!languageClass) throw new Error("tree-sitter not initialized");
   const grammars = findWasmDir();
-  const lang = await languageClass.load(join10(grammars, `${name2}.wasm`));
+  const lang = await languageClass.load(join12(grammars, `${name2}.wasm`));
   grammarCache.set(name2, lang);
   return lang;
 }
@@ -40204,8 +40306,8 @@ var init_src11 = __esm({
 
 // src/reconcile.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
-import { join as join11, relative as relative3, sep as sep2 } from "node:path";
+import { readdirSync as readdirSync4, statSync as statSync4 } from "node:fs";
+import { join as join13, relative as relative3, sep as sep2 } from "node:path";
 function indexerWouldScan(rel) {
   for (const seg of rel.split(/[\\/]/)) {
     if (seg.length === 0) continue;
@@ -40228,7 +40330,7 @@ function gitSourceFiles(root) {
   const out2 = [];
   for (const rel of stdout.split("\0")) {
     if (!rel || !SOURCE_RE.test(rel) || !indexerWouldScan(rel)) continue;
-    const abs = join11(root, rel);
+    const abs = join13(root, rel);
     if (IGNORED.test(abs)) continue;
     out2.push(abs);
   }
@@ -40243,7 +40345,7 @@ function* walkSource(dir) {
   }
   for (const e of entries) {
     const name2 = String(e.name);
-    const full = join11(dir, name2);
+    const full = join13(dir, name2);
     if (IGNORED.test(full)) continue;
     if (!indexerWouldScan(name2)) continue;
     if (e.isDirectory()) yield* walkSource(full);
@@ -40262,7 +40364,7 @@ async function findStaleFiles(store, rootPath, workspaceId2) {
     if (++scanned % SCAN_YIELD_EVERY === 0) await new Promise((r) => setImmediate(r));
     let mtimeMs;
     try {
-      mtimeMs = statSync3(abs).mtimeMs;
+      mtimeMs = statSync4(abs).mtimeMs;
     } catch {
       continue;
     }
@@ -40393,8 +40495,8 @@ __export(mcp_exports, {
   runTool: () => runTool,
   searchGraph: () => searchGraph
 });
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
 function collectEnrichmentPulls(store, opts = {}) {
   const pending = store.findNodesByLabel("Solution").filter((s) => s.attrs["enrichmentPending"] === true).filter((s) => !opts.onlyUnsurfaced || s.attrs["enrichmentSurfaced"] !== true);
   const byEpisode = /* @__PURE__ */ new Map();
@@ -40430,7 +40532,7 @@ function takeEnrichmentNudge(store) {
 ` + items;
 }
 function takeDiscriminatorNudge(path2) {
-  if (!path2 || !existsSync11(path2)) return null;
+  if (!path2 || !existsSync13(path2)) return null;
   let shared;
   try {
     shared = openGraphStore({ path: path2 });
@@ -40560,11 +40662,11 @@ function showNode(store, node2, maxLines) {
   const relPath = ownerFilePath(store, node2);
   if (!relPath) return { found: false, reason: "no file owner for node" };
   const workspaceRoot = process.cwd();
-  const absPath = resolve(workspaceRoot, relPath);
-  if (!existsSync11(absPath)) {
+  const absPath = resolve3(workspaceRoot, relPath);
+  if (!existsSync13(absPath)) {
     return { found: false, reason: `file not found on disk: ${absPath}` };
   }
-  const source = readFileSync9(absPath, "utf8");
+  const source = readFileSync11(absPath, "utf8");
   const attrs = node2.attrs;
   let startByte = attrs["bodyStartByte"] ?? attrs["startByte"];
   let endByte = attrs["bodyEndByte"] ?? attrs["endByte"];
@@ -40790,7 +40892,7 @@ function buildToolContext(workspaceRoot) {
   const base = { switchInstallationProfile: useInstallationProfile };
   try {
     const cfg = loadConfig();
-    const entry = workspaceRoot ? workspaceEntryForPath(resolve(workspaceRoot)) : null;
+    const entry = workspaceRoot ? workspaceEntryForPath(resolve3(workspaceRoot)) : null;
     const identity = resolveWorkspaceIdentity(cfg, entry);
     if (identity.invalid) {
       console.error(`[errata mcp] cloud DISABLED for this workspace: ${identity.reason}`);
@@ -41318,7 +41420,7 @@ var init_mcp = __esm({
           const local = causalChain(store, { seedId: id, direction: "both", maxHops, limit });
           try {
             const path2 = sharedStorePath();
-            if (!existsSync11(path2)) return { found: true, ...local };
+            if (!existsSync13(path2)) return { found: true, ...local };
             const shared = openGraphStore({ path: path2 });
             try {
               if (!shared.getNode(id)) return { found: true, ...local };
@@ -41918,7 +42020,7 @@ var init_mcp = __esm({
         inputSchema: { type: "object", properties: {} },
         handler: () => {
           const path2 = sharedStorePath();
-          if (!existsSync11(path2)) return { count: 0, pending: [] };
+          if (!existsSync13(path2)) return { count: 0, pending: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const pending = pendingAbstractions(shared);
@@ -41946,7 +42048,7 @@ var init_mcp = __esm({
         },
         handler: (args2) => {
           const path2 = sharedStorePath();
-          if (!existsSync11(path2)) return { count: 0, pending: [] };
+          if (!existsSync13(path2)) return { count: 0, pending: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const pending = pendingDiscriminators(shared, {
@@ -41990,7 +42092,7 @@ var init_mcp = __esm({
         },
         handler: (args2) => {
           const path2 = sharedStorePath();
-          if (!existsSync11(path2)) return { count: 0, routes: [] };
+          if (!existsSync13(path2)) return { count: 0, routes: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const result = triageOf(shared, {
@@ -42376,7 +42478,7 @@ __export(vfile_exports, {
   segmentsOf: () => segmentsOf
 });
 import { writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join12, resolve as resolve2, sep as sep3 } from "node:path";
+import { join as join14, resolve as resolve4, sep as sep3 } from "node:path";
 function segmentsOf(rawPath) {
   let p = rawPath.replace(/\\/g, "/");
   p = p.replace(/^.*\.errata\/g\//, "").replace(/^\/?g\//, "").replace(/^\/+/, "");
@@ -42450,8 +42552,8 @@ async function renderVFile(rawPath, store, ctx = {}) {
 }
 async function materializeVFile(rawPath, workspaceRoot, store, ctx = {}) {
   const segs = segmentsOf(rawPath);
-  const gRoot = join12(workspaceRoot, ".errata", "g");
-  const abs = resolve2(gRoot, ...segs.length ? segs : ["index"]);
+  const gRoot = join14(workspaceRoot, ".errata", "g");
+  const abs = resolve4(gRoot, ...segs.length ? segs : ["index"]);
   if (abs !== gRoot && !abs.startsWith(gRoot + sep3)) {
     throw new Error(`refusing to materialize outside .errata/g: ${rawPath}`);
   }
@@ -49877,25 +49979,25 @@ var init_tool_index = __esm({
 
 // src/outbox.ts
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync14,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync12,
   renameSync,
   unlinkSync,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join15 } from "node:path";
 import { createHash as createHash12 } from "node:crypto";
 function enqueueOutbox(paths, payload) {
   ensureDir(paths.outbox);
   const id = createHash12("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 16);
-  const file2 = join13(paths.outbox, `${Date.now()}-${id}.json`);
+  const file2 = join15(paths.outbox, `${Date.now()}-${id}.json`);
   writeFileSync10(file2, JSON.stringify(payload, null, 2), "utf8");
   return file2;
 }
 async function flushOutbox(paths, client, store) {
   ensureDir(paths.outbox);
-  const entries = existsSync12(paths.outbox) ? readdirSync5(paths.outbox) : [];
+  const entries = existsSync14(paths.outbox) ? readdirSync5(paths.outbox) : [];
   let uploaded = 0;
   let failed = 0;
   const quarantine = (abs, reason) => {
@@ -49906,10 +50008,10 @@ async function flushOutbox(paths, client, store) {
     }
   };
   for (const f of entries.filter((e) => e.endsWith(".json")).sort()) {
-    const abs = join13(paths.outbox, f);
+    const abs = join15(paths.outbox, f);
     let payload;
     try {
-      payload = JSON.parse(readFileSync10(abs, "utf8"));
+      payload = JSON.parse(readFileSync12(abs, "utf8"));
     } catch {
       failed++;
       quarantine(abs, "unparseable JSON");
@@ -49954,7 +50056,7 @@ async function flushOutbox(paths, client, store) {
       }
     }
   }
-  const remainingFiles = existsSync12(paths.outbox) ? readdirSync5(paths.outbox).filter((e) => e.endsWith(".json")) : [];
+  const remainingFiles = existsSync14(paths.outbox) ? readdirSync5(paths.outbox).filter((e) => e.endsWith(".json")) : [];
   return { uploaded, failed, remaining: remainingFiles.length };
 }
 var init_outbox = __esm({
@@ -50663,16 +50765,16 @@ __export(witness_ledger_exports, {
   summarizeWitnessLedger: () => summarizeWitnessLedger,
   witnessLedgerPath: () => witnessLedgerPath
 });
-import { appendFileSync as appendFileSync3, existsSync as existsSync22, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join27 } from "node:path";
+import { appendFileSync as appendFileSync3, existsSync as existsSync23, readFileSync as readFileSync23, writeFileSync as writeFileSync19 } from "node:fs";
+import { join as join28 } from "node:path";
 function witnessLedgerPath(configDir) {
-  return join27(configDir, "witness-ledger.jsonl");
+  return join28(configDir, "witness-ledger.jsonl");
 }
 function appendWitnessLedger(configDir, entry) {
   const path2 = witnessLedgerPath(configDir);
   try {
     appendFileSync3(path2, JSON.stringify(entry) + "\n");
-    const lines = readFileSync22(path2, "utf8").split("\n").filter(Boolean);
+    const lines = readFileSync23(path2, "utf8").split("\n").filter(Boolean);
     if (lines.length > LEDGER_MAX_LINES) {
       writeFileSync19(path2, lines.slice(-Math.floor(LEDGER_MAX_LINES / 2)).join("\n") + "\n");
     }
@@ -50681,9 +50783,9 @@ function appendWitnessLedger(configDir, entry) {
 }
 function readWitnessLedger(configDir) {
   const path2 = witnessLedgerPath(configDir);
-  if (!existsSync22(path2)) return [];
+  if (!existsSync23(path2)) return [];
   try {
-    return readFileSync22(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
+    return readFileSync23(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
   } catch {
     return [];
   }
@@ -51122,12 +51224,12 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src6();
-import { closeSync as closeSync2, existsSync as existsSync30, openSync as openSync2, readFileSync as readFileSync28, renameSync as renameSync4, statSync as statSync7 } from "node:fs";
-import { join as join32, resolve as pathResolve } from "node:path";
+import { closeSync as closeSync2, existsSync as existsSync31, openSync as openSync2, readFileSync as readFileSync29, renameSync as renameSync4, statSync as statSync7 } from "node:fs";
+import { join as join33, resolve as pathResolve } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 
 // src/daemon.ts
-import { existsSync as existsSync24, writeFileSync as writeFileSync21 } from "node:fs";
+import { existsSync as existsSync25, writeFileSync as writeFileSync21 } from "node:fs";
 
 // ../../node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.8/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -51557,7 +51659,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
         });
         if (!chunk) {
           if (i2 === 1) {
-            await new Promise((resolve6) => setTimeout(resolve6));
+            await new Promise((resolve7) => setTimeout(resolve7));
             maxReadCount = 3;
             continue;
           }
@@ -51707,8 +51809,8 @@ init_config();
 
 // src/engine.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync23, statSync as statSync6, appendFileSync as appendFileSync4, readdirSync as readdirSync10, renameSync as renameSync3, readFileSync as readFileSync23, writeFileSync as writeFileSync20 } from "node:fs";
-import { join as join28, relative as relative6, sep as sep4 } from "node:path";
+import { existsSync as existsSync24, statSync as statSync6, appendFileSync as appendFileSync4, readdirSync as readdirSync10, renameSync as renameSync3, readFileSync as readFileSync24, writeFileSync as writeFileSync20 } from "node:fs";
+import { join as join29, relative as relative6, sep as sep4 } from "node:path";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -51863,10 +51965,10 @@ var ReaddirpStream = class extends Readable2 {
   }
   async _formatEntry(dirent, path2) {
     let entry;
-    const basename5 = this._isDirent ? dirent.name : dirent;
+    const basename6 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path2, basename5));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
+      const fullPath = presolve(pjoin(path2, basename6));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err2) {
       this._onError(err2);
@@ -52405,9 +52507,9 @@ var NodeFsHandler = class {
   _watchWithNodeFs(path2, listener) {
     const opts = this.fsw.options;
     const directory = sysPath.dirname(path2);
-    const basename5 = sysPath.basename(path2);
+    const basename6 = sysPath.basename(path2);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename5);
+    parent.add(basename6);
     const absolutePath = sysPath.resolve(path2);
     const options = {
       persistent: opts.persistent
@@ -52417,7 +52519,7 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path2, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -52439,11 +52541,11 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname11 = sysPath.dirname(file2);
-    const basename5 = sysPath.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname11);
+    const dirname12 = sysPath.dirname(file2);
+    const basename6 = sysPath.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname12);
     let prevStats = stats;
-    if (parent.has(basename5))
+    if (parent.has(basename6))
       return;
     const listener = async (path2, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -52468,9 +52570,9 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname11, basename5);
+          this.fsw._remove(dirname12, basename6);
         }
-      } else if (parent.has(basename5)) {
+      } else if (parent.has(basename6)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -52564,7 +52666,7 @@ var NodeFsHandler = class {
         this._addToNodeFs(path2, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -52573,7 +52675,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve6(void 0);
+        resolve7(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -53656,8 +53758,8 @@ init_src10();
 init_review2();
 
 // src/turn.ts
-import { closeSync, existsSync as existsSync13, fstatSync, openSync, readdirSync as readdirSync6, readSync, realpathSync, statSync as statSync4 } from "node:fs";
-import { basename as basename3, dirname as dirname8, join as join16 } from "node:path";
+import { closeSync, existsSync as existsSync15, fstatSync, openSync, readdirSync as readdirSync6, readSync, realpathSync, statSync as statSync5 } from "node:fs";
+import { basename as basename4, dirname as dirname9, join as join18 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { createHash as createHash13 } from "node:crypto";
 function readFrom(path2, fromByte, maxBytes) {
@@ -54035,11 +54137,11 @@ function turnsSince(turns, mark) {
   return at >= 0 ? turns.slice(at + 1) : turns;
 }
 function claudeProjectDir(cwd, home = homedir4()) {
-  return join16(home, ".claude", "projects", cwd.replace(/[\\/:.]/g, "-"));
+  return join18(home, ".claude", "projects", cwd.replace(/[\\/:.]/g, "-"));
 }
 function recentTranscripts(cwd, opts = {}) {
   const dir = claudeProjectDir(cwd, opts.home ?? homedir4());
-  if (!existsSync13(dir)) return [];
+  if (!existsSync15(dir)) return [];
   let names;
   try {
     names = readdirSync6(dir);
@@ -54050,23 +54152,23 @@ function recentTranscripts(cwd, opts = {}) {
   const refs = [];
   for (const name2 of names) {
     if (!name2.endsWith(".jsonl")) continue;
-    const path2 = join16(dir, name2);
+    const path2 = join18(dir, name2);
     let mtimeMs;
     try {
-      mtimeMs = statSync4(path2).mtimeMs;
+      mtimeMs = statSync5(path2).mtimeMs;
     } catch {
       continue;
     }
     if (mtimeMs < since) continue;
-    refs.push({ path: path2, sessionId: basename3(name2, ".jsonl"), mtimeMs });
+    refs.push({ path: path2, sessionId: basename4(name2, ".jsonl"), mtimeMs });
   }
   refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   return opts.limit ? refs.slice(0, opts.limit) : refs;
 }
 function subagentTranscripts(mainTranscriptPath, sessionId) {
   if (!mainTranscriptPath || !sessionId) return [];
-  const dir = join16(dirname8(mainTranscriptPath), sessionId, "subagents");
-  if (!existsSync13(dir)) return [];
+  const dir = join18(dirname9(mainTranscriptPath), sessionId, "subagents");
+  if (!existsSync15(dir)) return [];
   let names;
   try {
     names = readdirSync6(dir);
@@ -54076,14 +54178,14 @@ function subagentTranscripts(mainTranscriptPath, sessionId) {
   const refs = [];
   for (const name2 of names) {
     if (!name2.endsWith(".jsonl")) continue;
-    const path2 = join16(dir, name2);
+    const path2 = join18(dir, name2);
     let mtimeMs;
     try {
-      mtimeMs = statSync4(path2).mtimeMs;
+      mtimeMs = statSync5(path2).mtimeMs;
     } catch {
       continue;
     }
-    refs.push({ path: path2, sessionId: basename3(name2, ".jsonl"), mtimeMs });
+    refs.push({ path: path2, sessionId: basename4(name2, ".jsonl"), mtimeMs });
   }
   refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   return refs;
@@ -54094,8 +54196,8 @@ function codexSessionRoots(env2 = process.env, home = homedir4()) {
   if (explicit) {
     for (const d of explicit.split(":")) if (d.trim()) roots.add(d.trim());
   }
-  if (env2["CODEX_HOME"]) roots.add(join16(env2["CODEX_HOME"], "sessions"));
-  roots.add(join16(home, ".codex", "sessions"));
+  if (env2["CODEX_HOME"]) roots.add(join18(env2["CODEX_HOME"], "sessions"));
+  roots.add(join18(home, ".codex", "sessions"));
   return [...roots];
 }
 function readCodexRolloutCwd(path2) {
@@ -54140,7 +54242,7 @@ function codexRolloutsForCwd(cwd, opts = {}) {
   const limit = opts.limit ?? 25;
   const out2 = [];
   for (const root of codexSessionRoots(opts.env, opts.home)) {
-    if (!existsSync13(root)) continue;
+    if (!existsSync15(root)) continue;
     const stack = [{ dir: root, depth: 0 }];
     while (stack.length > 0) {
       const { dir, depth } = stack.pop();
@@ -54151,10 +54253,10 @@ function codexRolloutsForCwd(cwd, opts = {}) {
         continue;
       }
       for (const name2 of names) {
-        const full = join16(dir, name2);
+        const full = join18(dir, name2);
         let st;
         try {
-          st = statSync4(full);
+          st = statSync5(full);
         } catch {
           continue;
         }
@@ -54166,7 +54268,7 @@ function codexRolloutsForCwd(cwd, opts = {}) {
         if (!name2.startsWith("rollout-") || !name2.endsWith(".jsonl")) continue;
         if (st.mtimeMs < sinceMs) continue;
         if (readCodexRolloutCwd(full) !== cwd) continue;
-        out2.push({ path: full, sessionId: `codex:${basename3(name2, ".jsonl")}`, mtimeMs: st.mtimeMs });
+        out2.push({ path: full, sessionId: `codex:${basename4(name2, ".jsonl")}`, mtimeMs: st.mtimeMs });
       }
     }
   }
@@ -54179,8 +54281,8 @@ function geminiSessionRoots(env2 = process.env, home = homedir4()) {
   if (explicit) {
     for (const d of explicit.split(":")) if (d.trim()) roots.add(d.trim());
   }
-  if (env2["GEMINI_CLI_HOME"]) roots.add(join16(env2["GEMINI_CLI_HOME"], ".gemini", "tmp"));
-  roots.add(join16(home, ".gemini", "tmp"));
+  if (env2["GEMINI_CLI_HOME"]) roots.add(join18(env2["GEMINI_CLI_HOME"], ".gemini", "tmp"));
+  roots.add(join18(home, ".gemini", "tmp"));
   return [...roots];
 }
 function geminiProjectHash(cwd) {
@@ -54220,7 +54322,7 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
   const hashes = geminiHashesFor(cwd);
   const out2 = [];
   for (const root of geminiSessionRoots(opts.env, opts.home)) {
-    if (!existsSync13(root)) continue;
+    if (!existsSync15(root)) continue;
     let slugs;
     try {
       slugs = readdirSync6(root);
@@ -54228,7 +54330,7 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
       continue;
     }
     for (const slug2 of slugs) {
-      const chats = join16(root, slug2, "chats");
+      const chats = join18(root, slug2, "chats");
       let names;
       try {
         names = readdirSync6(chats);
@@ -54237,17 +54339,17 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
       }
       for (const name2 of names) {
         if (!name2.startsWith("session-") || !name2.endsWith(".jsonl")) continue;
-        const full = join16(chats, name2);
+        const full = join18(chats, name2);
         let st;
         try {
-          st = statSync4(full);
+          st = statSync5(full);
         } catch {
           continue;
         }
         if (!st.isFile() || st.mtimeMs < sinceMs) continue;
         const h = readGeminiTranscriptProjectHash(full);
         if (!h || !hashes.has(h)) continue;
-        out2.push({ path: full, sessionId: `gemini:${basename3(name2, ".jsonl")}`, mtimeMs: st.mtimeMs });
+        out2.push({ path: full, sessionId: `gemini:${basename4(name2, ".jsonl")}`, mtimeMs: st.mtimeMs });
       }
     }
   }
@@ -54260,8 +54362,8 @@ function opencodeSessionRoots(env2 = process.env, home = homedir4()) {
   if (explicit) {
     for (const d of explicit.split(":")) if (d.trim()) roots.add(d.trim());
   }
-  if (env2["XDG_DATA_HOME"]) roots.add(join16(env2["XDG_DATA_HOME"], "opencode", "errata"));
-  roots.add(join16(home, ".local", "share", "opencode", "errata"));
+  if (env2["XDG_DATA_HOME"]) roots.add(join18(env2["XDG_DATA_HOME"], "opencode", "errata"));
+  roots.add(join18(home, ".local", "share", "opencode", "errata"));
   return [...roots];
 }
 function readOpencodeTranscriptDirectory(path2) {
@@ -54294,7 +54396,7 @@ function opencodeTranscriptsForCwd(cwd, opts = {}) {
   }
   const out2 = [];
   for (const root of opencodeSessionRoots(opts.env, opts.home)) {
-    if (!existsSync13(root)) continue;
+    if (!existsSync15(root)) continue;
     let names;
     try {
       names = readdirSync6(root);
@@ -54303,17 +54405,17 @@ function opencodeTranscriptsForCwd(cwd, opts = {}) {
     }
     for (const name2 of names) {
       if (!name2.endsWith(".jsonl")) continue;
-      const full = join16(root, name2);
+      const full = join18(root, name2);
       let st;
       try {
-        st = statSync4(full);
+        st = statSync5(full);
       } catch {
         continue;
       }
       if (!st.isFile() || st.mtimeMs < sinceMs) continue;
       const dir = readOpencodeTranscriptDirectory(full);
       if (!dir || !(want.has(dir) || want.has(dir.replace(/\/+$/, "")))) continue;
-      out2.push({ path: full, sessionId: `opencode:${basename3(name2, ".jsonl")}`, mtimeMs: st.mtimeMs });
+      out2.push({ path: full, sessionId: `opencode:${basename4(name2, ".jsonl")}`, mtimeMs: st.mtimeMs });
     }
   }
   out2.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -54326,7 +54428,7 @@ init_src2();
 init_agent_signals();
 init_tool_index();
 init_src5();
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "node:fs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "node:fs";
 var NEG = /n['']t|\b(?:not|never|no|none|neither|nor|unrelated|irrelevant|would|might|could|if)\b/i;
 var CITE_GROUP_RE = /\(((?:[^()\n]|\([^()\n]*\)){1,200})\)/g;
 var HANDLE_RE = /\[([a-z0-9][\w-]{0,80})\]|((?:pat|sol|drc|dcause|dfix|dprob|prob|claim|err)_[0-9a-f]{6,})/gi;
@@ -54865,7 +54967,7 @@ function writePrimingHandles(path2, nodes, now = Date.now()) {
 }
 function readPrimingHandles(path2) {
   try {
-    return JSON.parse(readFileSync11(path2, "utf8"));
+    return JSON.parse(readFileSync13(path2, "utf8"));
   } catch {
     return {};
   }
@@ -55340,8 +55442,8 @@ ${conversation}` }]
 // src/constraint-backfill.ts
 init_src5();
 init_src2();
-import { existsSync as existsSync14, readFileSync as readFileSync12, readdirSync as readdirSync7, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync14, readdirSync as readdirSync7, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join19 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 var BACKFILL_VERSION = 1;
 var EMPTY = {
@@ -55355,13 +55457,13 @@ var EMPTY = {
   recoverable: 0
 };
 function markerPath(configDir) {
-  return join17(configDir, "constraint-backfill.json");
+  return join19(configDir, "constraint-backfill.json");
 }
 function alreadyDone(configDir) {
   const p = markerPath(configDir);
-  if (!existsSync14(p)) return false;
+  if (!existsSync16(p)) return false;
   try {
-    const raw2 = JSON.parse(readFileSync12(p, "utf8"));
+    const raw2 = JSON.parse(readFileSync14(p, "utf8"));
     return raw2?.version === BACKFILL_VERSION;
   } catch {
     return false;
@@ -55371,7 +55473,7 @@ function replay(root) {
   const statements = /* @__PURE__ */ new Set();
   const citedByFix = /* @__PURE__ */ new Set();
   const dir = claudeProjectDir(root, homedir5());
-  if (!existsSync14(dir)) return { statements, citedByFix };
+  if (!existsSync16(dir)) return { statements, citedByFix };
   let names;
   try {
     names = readdirSync7(dir).filter((n) => n.endsWith(".jsonl"));
@@ -55381,7 +55483,7 @@ function replay(root) {
   for (const f of names) {
     let lines;
     try {
-      lines = readFileSync12(join17(dir, f), "utf8").split("\n");
+      lines = readFileSync14(join19(dir, f), "utf8").split("\n");
     } catch {
       continue;
     }
@@ -55508,8 +55610,8 @@ function backfillConstraintKind(store, opts) {
 // src/edge-repair.ts
 init_src();
 init_src5();
-import { existsSync as existsSync15, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join20 } from "node:path";
 function citeEdgeId(from, type, to) {
   return `edge_${digest({ from, type, to })}`.slice(0, 24);
 }
@@ -55524,13 +55626,13 @@ var EMPTY2 = {
   byType: {}
 };
 function markerPath2(configDir) {
-  return join18(configDir, "edge-repair.json");
+  return join20(configDir, "edge-repair.json");
 }
 function alreadyDone2(configDir) {
   const p = markerPath2(configDir);
-  if (!existsSync15(p)) return false;
+  if (!existsSync17(p)) return false;
   try {
-    return JSON.parse(readFileSync13(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
+    return JSON.parse(readFileSync15(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
   } catch {
     return false;
   }
@@ -55593,8 +55695,8 @@ function repairInvalidEdges(store, opts) {
 init_reconcile();
 
 // src/pass-ledger.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync16, readFileSync as readFileSync14, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join19 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync18, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "node:fs";
+import { join as join21 } from "node:path";
 
 // src/isolate-census.ts
 var live = 0;
@@ -55617,7 +55719,7 @@ var PER_KIND_MAX = 100;
 var TRIM_EVERY = 50;
 var appendsSinceTrim = /* @__PURE__ */ new Map();
 function passLedgerPath(configDir) {
-  return join19(configDir, "pass-ledger.jsonl");
+  return join21(configDir, "pass-ledger.jsonl");
 }
 function appendPassLedger(configDir, kind, durationMs, counts) {
   const path2 = passLedgerPath(configDir);
@@ -55646,7 +55748,7 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
       return;
     }
     appendsSinceTrim.set(path2, 0);
-    const lines = readFileSync14(path2, "utf8").split("\n").filter(Boolean);
+    const lines = readFileSync16(path2, "utf8").split("\n").filter(Boolean);
     const keptByKind = /* @__PURE__ */ new Map();
     const kept = [];
     for (let i2 = lines.length - 1; i2 >= 0; i2--) {
@@ -55669,9 +55771,9 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
 }
 function readPassLedger(configDir) {
   const path2 = passLedgerPath(configDir);
-  if (!existsSync16(path2)) return [];
+  if (!existsSync18(path2)) return [];
   try {
-    return readFileSync14(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter(
+    return readFileSync16(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter(
       (e) => typeof e?.ts === "number" && typeof e?.kind === "string" && typeof e?.durationMs === "number"
     ).map((e) => ({ ...e, counts: e.counts ?? {} }));
   } catch {
@@ -55954,8 +56056,8 @@ var PassWorker = class {
       const id = this.nextId++;
       try {
         await this.ready;
-        return await new Promise((resolve6, reject) => {
-          this.pending.set(id, { resolve: resolve6, reject });
+        return await new Promise((resolve7, reject) => {
+          this.pending.set(id, { resolve: resolve7, reject });
           this.worker.postMessage({ id, kind, ...payload !== void 0 ? { payload } : {} });
         });
       } finally {
@@ -55989,12 +56091,12 @@ var PassWorker = class {
     });
     noteIsolateSpawned();
     this.worker = worker;
-    this.ready = new Promise((resolve6, reject) => {
+    this.ready = new Promise((resolve7, reject) => {
       const onReady = (m) => {
         if (m?.ready) {
           worker.off("message", onReady);
           worker.off("error", onErr);
-          resolve6();
+          resolve7();
         }
       };
       const onErr = (err2) => reject(err2);
@@ -56039,11 +56141,11 @@ init_outbox();
 init_src9();
 init_src();
 init_src2();
-import { readFileSync as readFileSync15 } from "node:fs";
-import { join as join20 } from "node:path";
+import { readFileSync as readFileSync17 } from "node:fs";
+import { join as join22 } from "node:path";
 function loadClaimIgnorePatterns(workspaceRoot) {
   try {
-    return readFileSync15(join20(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
+    return readFileSync17(join22(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
   } catch {
     return [];
   }
@@ -56404,22 +56506,22 @@ async function pullCloudTriage(shared, cloud, profile, limit = 50) {
 }
 
 // src/git-sensor.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16, watch as fsWatch } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync18, watch as fsWatch } from "node:fs";
+import { join as join23 } from "node:path";
 function readFirstLine(path2) {
   try {
-    return readFileSync16(path2, "utf8").split(/\r?\n/, 1)[0].trim();
+    return readFileSync18(path2, "utf8").split(/\r?\n/, 1)[0].trim();
   } catch {
     return null;
   }
 }
 function readGitRefState(gitDir) {
-  const head2 = readFirstLine(join21(gitDir, "HEAD"));
+  const head2 = readFirstLine(join23(gitDir, "HEAD"));
   const m = head2 ? /^ref:\s*refs\/heads\/(.+)$/.exec(head2) : null;
   const branch = m ? m[1] : null;
   let sha2 = null;
   if (branch) {
-    sha2 = readFirstLine(join21(gitDir, "refs", "heads", branch));
+    sha2 = readFirstLine(join23(gitDir, "refs", "heads", branch));
     if (!sha2) sha2 = shaFromPackedRefs(gitDir, `refs/heads/${branch}`);
   } else if (head2 && /^[0-9a-f]{7,40}$/i.test(head2)) {
     sha2 = head2;
@@ -56427,13 +56529,13 @@ function readGitRefState(gitDir) {
   return {
     branch,
     sha: sha2,
-    mergeHeadExists: existsSync17(join21(gitDir, "MERGE_HEAD")),
-    origHeadExists: existsSync17(join21(gitDir, "ORIG_HEAD"))
+    mergeHeadExists: existsSync19(join23(gitDir, "MERGE_HEAD")),
+    origHeadExists: existsSync19(join23(gitDir, "ORIG_HEAD"))
   };
 }
 function shaFromPackedRefs(gitDir, ref) {
   try {
-    for (const line of readFileSync16(join21(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync18(join23(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
       const [sha2, name2] = line.split(/\s+/);
       if (name2 === ref && sha2) return sha2;
     }
@@ -56467,7 +56569,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
   const settle = () => {
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      if (existsSync17(join21(gitDir, "index.lock"))) {
+      if (existsSync19(join23(gitDir, "index.lock"))) {
         settle();
         return;
       }
@@ -56478,7 +56580,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
     }, debounceMs);
   };
   for (const sub of ["HEAD", "logs/HEAD", "MERGE_HEAD", "ORIG_HEAD"]) {
-    const p = join21(gitDir, sub);
+    const p = join23(gitDir, sub);
     try {
       watchers.push(fsWatch(p, settle));
     } catch {
@@ -56498,7 +56600,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
 // src/git-delta.ts
 import { execFile } from "node:child_process";
 function git(repoDir, args2) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     execFile(
       "git",
       ["-C", repoDir, ...args2],
@@ -56509,7 +56611,7 @@ function git(repoDir, args2) {
         // git-sensor runs on every commit/checkout.
         windowsHide: true
       },
-      (err2, stdout) => err2 ? reject(err2) : resolve6(stdout)
+      (err2, stdout) => err2 ? reject(err2) : resolve7(stdout)
     );
   });
 }
@@ -56703,21 +56805,21 @@ var TelemetryRecorder = class {
 
 // src/skills.ts
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync19,
   readdirSync as readdirSync8,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync15
 } from "node:fs";
-import { basename as basename4, join as join22 } from "node:path";
+import { basename as basename5, join as join24 } from "node:path";
 function skillFileName(id) {
   return `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.md`;
 }
 function readSkillManifest(manifestPath) {
-  if (!existsSync18(manifestPath)) return [];
+  if (!existsSync20(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync17(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync19(manifestPath, "utf8"));
     return (parsed.skills ?? []).map((s) => ({
       title: s.title ?? "",
       layer: s.layer ?? "technique",
@@ -56741,7 +56843,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
   for (const s of res.skills) {
     const fileName = skillFileName(s.id);
     keep.add(fileName);
-    writeFileSync15(join22(paths.skillsDir, fileName), s.markdown, "utf8");
+    writeFileSync15(join24(paths.skillsDir, fileName), s.markdown, "utf8");
     rows.push({
       id: s.id,
       title: s.title,
@@ -56754,7 +56856,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     const fileName = skillFileName(p.id);
     if (keep.has(fileName)) continue;
     keep.add(fileName);
-    writeFileSync15(join22(paths.skillsDir, fileName), p.markdown, "utf8");
+    writeFileSync15(join24(paths.skillsDir, fileName), p.markdown, "utf8");
     rows.push({
       id: p.id,
       title: p.title,
@@ -56766,9 +56868,9 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
   let pruned = 0;
   for (const f of readdirSync8(paths.skillsDir)) {
     if (!f.endsWith(".md")) continue;
-    if (keep.has(basename4(f))) continue;
+    if (keep.has(basename5(f))) continue;
     try {
-      unlinkSync2(join22(paths.skillsDir, f));
+      unlinkSync2(join24(paths.skillsDir, f));
       pruned++;
     } catch {
     }
@@ -56786,22 +56888,22 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
 init_src2();
 import {
   cpSync,
-  existsSync as existsSync19,
+  existsSync as existsSync21,
   lstatSync,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync20,
   readdirSync as readdirSync9,
   rmSync as rmSync3,
   symlinkSync,
   writeFileSync as writeFileSync16
 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join25 } from "node:path";
 var SKILL_NS = "errata-";
 var HARNESS_SKILL_DIRS = [
-  { configDir: ".claude", skillsDir: join23(".claude", "skills") },
+  { configDir: ".claude", skillsDir: join25(".claude", "skills") },
   // Cursor adopted the standard; its exact project dir is still moving — kept
   // best-effort and gated on `.cursor/` presence so we never create it blind.
-  { configDir: ".cursor", skillsDir: join23(".cursor", "skills") }
+  { configDir: ".cursor", skillsDir: join25(".cursor", "skills") }
 ];
 function skillSlug(title, id) {
   const base = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || id.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "skill";
@@ -56846,12 +56948,12 @@ function skillCiteHandle(s) {
   return priorHandle({ id: s.id, description: s.title });
 }
 function reconcileNamespaced(dir, keep) {
-  if (!existsSync19(dir)) return 0;
+  if (!existsSync21(dir)) return 0;
   let pruned = 0;
   for (const name2 of readdirSync9(dir)) {
     if (!name2.startsWith(SKILL_NS) || keep.has(name2)) continue;
     try {
-      rmSync3(join23(dir, name2), { recursive: true, force: true });
+      rmSync3(join25(dir, name2), { recursive: true, force: true });
       pruned++;
     } catch {
     }
@@ -56860,7 +56962,7 @@ function reconcileNamespaced(dir, keep) {
 }
 function linkOrCopy(linkPath, target) {
   try {
-    if (existsSync19(linkPath) || safeLstat(linkPath)) rmSync3(linkPath, { recursive: true, force: true });
+    if (existsSync21(linkPath) || safeLstat(linkPath)) rmSync3(linkPath, { recursive: true, force: true });
   } catch {
   }
   try {
@@ -56881,7 +56983,7 @@ function safeLstat(p) {
   }
 }
 function emitAndProjectSkills(root, skills) {
-  const agentsSkillsDir = join23(root, ".agents", "skills");
+  const agentsSkillsDir = join25(root, ".agents", "skills");
   mkdirSync8(agentsSkillsDir, { recursive: true });
   const slugs = [];
   const keep = /* @__PURE__ */ new Set();
@@ -56889,7 +56991,7 @@ function emitAndProjectSkills(root, skills) {
   for (const s of skills) {
     let body2;
     try {
-      body2 = readFileSync18(s.bodyPath, "utf8");
+      body2 = readFileSync20(s.bodyPath, "utf8");
     } catch {
       continue;
     }
@@ -56898,9 +57000,9 @@ function emitAndProjectSkills(root, skills) {
     keep.add(slug2);
     slugs.push(slug2);
     const description = deriveDescription(s.title, s.layer, body2);
-    mkdirSync8(join23(agentsSkillsDir, slug2), { recursive: true });
+    mkdirSync8(join25(agentsSkillsDir, slug2), { recursive: true });
     writeFileSync16(
-      join23(agentsSkillsDir, slug2, "SKILL.md"),
+      join25(agentsSkillsDir, slug2, "SKILL.md"),
       renderSkillMd(slug2, description, body2, skillCiteHandle(s)),
       "utf8"
     );
@@ -56909,11 +57011,11 @@ function emitAndProjectSkills(root, skills) {
   reconcileNamespaced(agentsSkillsDir, keep);
   let projected = 0;
   for (const h of HARNESS_SKILL_DIRS) {
-    if (!existsSync19(join23(root, h.configDir))) continue;
-    const dir = join23(root, h.skillsDir);
+    if (!existsSync21(join25(root, h.configDir))) continue;
+    const dir = join25(root, h.skillsDir);
     mkdirSync8(dir, { recursive: true });
     for (const slug2 of slugs) {
-      linkOrCopy(join23(dir, slug2), join23(agentsSkillsDir, slug2));
+      linkOrCopy(join25(dir, slug2), join25(agentsSkillsDir, slug2));
       projected++;
     }
     reconcileNamespaced(dir, keep);
@@ -56922,15 +57024,15 @@ function emitAndProjectSkills(root, skills) {
   return { slugs, emitted, projected };
 }
 function emitInputsFromManifest(erretaDir, manifestPath) {
-  if (!existsSync19(manifestPath)) return [];
+  if (!existsSync21(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync18(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync20(manifestPath, "utf8"));
     return (parsed.skills ?? []).filter((s) => Boolean(s.id && s.file)).map((s) => ({
       id: s.id,
       title: s.title ?? s.id,
       layer: s.layer ?? "technique",
       confidence: s.confidence ?? 0,
-      bodyPath: join23(erretaDir, s.file)
+      bodyPath: join25(erretaDir, s.file)
     }));
   } catch {
     return [];
@@ -56944,10 +57046,10 @@ var GITIGNORE_LINES = [
   ".cursor/skills/errata-*/"
 ];
 function ensureSkillGitignore(root) {
-  const path2 = join23(root, ".gitignore");
+  const path2 = join25(root, ".gitignore");
   let current = "";
   try {
-    current = existsSync19(path2) ? readFileSync18(path2, "utf8") : "";
+    current = existsSync21(path2) ? readFileSync20(path2, "utf8") : "";
   } catch {
     return;
   }
@@ -57051,63 +57153,10 @@ init_paths();
 // src/profile.ts
 init_src2();
 init_paths();
-import { existsSync as existsSync21, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "node:fs";
+init_git_remote();
+import { existsSync as existsSync22, readFileSync as readFileSync21, writeFileSync as writeFileSync17 } from "node:fs";
 import { createHash as createHash14 } from "node:crypto";
-import { join as join25 } from "node:path";
-
-// src/git-remote.ts
-init_src();
-import { existsSync as existsSync20, readFileSync as readFileSync19, statSync as statSync5 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join24, resolve as resolve5 } from "node:path";
-function resolveGitDir(root) {
-  const dotGit = join24(root, ".git");
-  try {
-    const st = statSync5(dotGit);
-    if (st.isDirectory()) return dotGit;
-    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync19(dotGit, "utf8"));
-    if (!m) return null;
-    const dir = m[1];
-    return isAbsolute3(dir) ? dir : resolve5(root, dir);
-  } catch {
-    return null;
-  }
-}
-function gitConfigPath(gitDir) {
-  const commondirFile = join24(gitDir, "commondir");
-  if (existsSync20(commondirFile)) {
-    const common = readFileSync19(commondirFile, "utf8").trim();
-    const commonDir = isAbsolute3(common) ? common : resolve5(gitDir, common);
-    return join24(commonDir, "config");
-  }
-  return join24(gitDir, "config");
-}
-function readRemotes(root) {
-  const gitDir = resolveGitDir(root);
-  if (!gitDir) return [];
-  const cfgPath = gitConfigPath(gitDir);
-  if (!existsSync20(cfgPath)) return [];
-  let txt;
-  try {
-    txt = readFileSync19(cfgPath, "utf8");
-  } catch {
-    return [];
-  }
-  const out2 = [];
-  const sectionRe = /^\s*\[remote "([^"]+)"\]\s*$([\s\S]*?)(?=^\s*\[|\s*$(?![\s\S]))/gm;
-  for (const m of txt.matchAll(sectionRe)) {
-    const url2 = /^\s*url\s*=\s*(.+?)\s*$/m.exec(m[2])?.[1];
-    if (url2) out2.push({ name: m[1], url: url2 });
-  }
-  return out2;
-}
-function detectRepoLocator(root, remote) {
-  const remotes = readRemotes(root);
-  if (remotes.length === 0) return null;
-  const pick2 = remote ? remotes.find((r) => r.name === remote) ?? null : remotes.find((r) => r.name === "origin") ?? (remotes.length === 1 ? remotes[0] : null);
-  return pick2 ? normalizeRepoLocator(pick2.url) : null;
-}
-
-// src/profile.ts
+import { join as join26 } from "node:path";
 function workspaceId(root) {
   return "wp_" + createHash14("sha256").update(root).digest("hex").slice(0, 12);
 }
@@ -57130,8 +57179,8 @@ function refreshRepoLocator(root, profile) {
 }
 function loadProfile(root) {
   const p = workspacePaths(root);
-  if (!existsSync21(p.workspaceJson)) return null;
-  return JSON.parse(readFileSync20(p.workspaceJson, "utf8"));
+  if (!existsSync22(p.workspaceJson)) return null;
+  return JSON.parse(readFileSync21(p.workspaceJson, "utf8"));
 }
 function saveProfile(root, profile) {
   const p = workspacePaths(root);
@@ -57144,10 +57193,10 @@ function autodetectProfile(root) {
   const p = emptyProfile(id, name2);
   const locator = detectRepoLocator(root);
   if (locator) p.repoLocator = locator;
-  const pkgPath = join25(root, "package.json");
-  if (existsSync21(pkgPath)) {
+  const pkgPath = join26(root, "package.json");
+  if (existsSync22(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync20(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync21(pkgPath, "utf8"));
       p.languages.push("typescript", "javascript");
       const nodeVer = pkg.engines?.node ?? "node";
       p.stack.push(`node@${nodeVer}`);
@@ -57168,10 +57217,10 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const pyproject = join25(root, "pyproject.toml");
-  if (existsSync21(pyproject)) {
+  const pyproject = join26(root, "pyproject.toml");
+  if (existsSync22(pyproject)) {
     try {
-      const txt = readFileSync20(pyproject, "utf8");
+      const txt = readFileSync21(pyproject, "utf8");
       const py = /python\s*=\s*"([^"]+)"/.exec(txt)?.[1];
       p.languages.push("python");
       p.stack.push(`python@${py ?? "3"}`);
@@ -57182,16 +57231,16 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const reqs = join25(root, "requirements.txt");
-  if (existsSync21(reqs)) {
+  const reqs = join26(root, "requirements.txt");
+  if (existsSync22(reqs)) {
     if (!p.languages.includes("python")) p.languages.push("python");
     if (!p.stack.includes("python@3")) p.stack.push("python@3");
   }
-  if (existsSync21(join25(root, "go.mod"))) {
+  if (existsSync22(join26(root, "go.mod"))) {
     p.languages.push("go");
     p.stack.push("go");
   }
-  if (existsSync21(join25(root, "Cargo.toml"))) {
+  if (existsSync22(join26(root, "Cargo.toml"))) {
     p.languages.push("rust");
     p.stack.push("rust");
   }
@@ -57201,18 +57250,18 @@ function autodetectProfile(root) {
 }
 
 // src/witness-queue.ts
-import { readFileSync as readFileSync21, renameSync as renameSync2, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname9, join as join26 } from "node:path";
+import { readFileSync as readFileSync22, renameSync as renameSync2, writeFileSync as writeFileSync18 } from "node:fs";
+import { dirname as dirname10, join as join27 } from "node:path";
 var WITNESS_QUEUE_CAP = 500;
 var WITNESS_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
 var WITNESS_MAX_ATTEMPTS = 5;
 function witnessQueuePath(workspaceConfigDir) {
-  return join26(workspaceConfigDir, "witness-queue.json");
+  return join27(workspaceConfigDir, "witness-queue.json");
 }
 function loadWitnessQueueWithLosses(path2) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync21(path2, "utf8"));
+    raw2 = JSON.parse(readFileSync22(path2, "utf8"));
   } catch (err2) {
     const absent = err2?.code === "ENOENT";
     return { queue: [], fileUnreadable: !absent, malformedEntries: 0 };
@@ -57225,7 +57274,7 @@ function loadWitnessQueueWithLosses(path2) {
 }
 function saveWitnessQueue(path2, queue) {
   try {
-    const tmp = join26(dirname9(path2), `.${Date.now()}.witness-queue.tmp`);
+    const tmp = join27(dirname10(path2), `.${Date.now()}.witness-queue.tmp`);
     writeFileSync18(tmp, JSON.stringify(queue), "utf8");
     renameSync2(tmp, path2);
   } catch {
@@ -57799,7 +57848,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.4" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.5" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -57810,7 +57859,7 @@ var CODEX_SWEEP_LOOKBACK_MS = 10 * 6e4;
 function appendIdentityAudit(path2, record2, line) {
   if (!record2.accepted && record2.score <= 0) return;
   try {
-    if (existsSync23(path2) && statSync6(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
+    if (existsSync24(path2) && statSync6(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
       renameSync3(path2, `${path2}.1`);
     }
     appendFileSync4(path2, line);
@@ -57820,7 +57869,7 @@ function appendIdentityAudit(path2, record2, line) {
 var yieldToLoop = () => new Promise((r) => setImmediate(r));
 function loadTurnCursors(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync23(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync24(path2, "utf8"));
     return new Map(
       Object.entries(raw2).map(([k, v]) => [k, typeof v === "string" ? v : String(v?.uuid ?? "")])
     );
@@ -57830,7 +57879,7 @@ function loadTurnCursors(path2) {
 }
 function loadTurnOffsets(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync23(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync24(path2, "utf8"));
     const out2 = /* @__PURE__ */ new Map();
     for (const [k, v] of Object.entries(raw2)) {
       const off = typeof v === "object" && v !== null ? v.offset : void 0;
@@ -57868,7 +57917,7 @@ function gitSourceWatchTargets(root) {
         ["-C", root, "ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"],
         { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }
       );
-      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join28(root, d) + sep4));
+      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join29(root, d) + sep4));
     } catch {
     }
     const hasIgnoredChild = (dir) => ignoredDirs.some((ig) => ig.startsWith(dir + "/"));
@@ -57880,19 +57929,19 @@ function gitSourceWatchTargets(root) {
         if (!f.startsWith(prefix)) continue;
         const rest2 = f.slice(prefix.length);
         if (rest2.includes("/")) children.add(dir === "" ? rest2.slice(0, rest2.indexOf("/")) : dir + "/" + rest2.slice(0, rest2.indexOf("/")));
-        else targets.add(join28(root, f));
+        else targets.add(join29(root, f));
       }
       for (const c of children) {
-        if (IGNORED_PATH.test(join28(root, c) + sep4)) continue;
+        if (IGNORED_PATH.test(join29(root, c) + sep4)) continue;
         if (hasIgnoredChild(c)) addUnder(c);
-        else targets.add(join28(root, c));
+        else targets.add(join29(root, c));
       }
     };
     addUnder("");
     if (targets.size > 0) return [...targets];
   } catch {
   }
-  return readdirSync10(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join28(root, String(e.name)) + sep4)).map((e) => join28(root, String(e.name)));
+  return readdirSync10(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join29(root, String(e.name)) + sep4)).map((e) => join29(root, String(e.name)));
 }
 function createWorkspaceEngine(opts) {
   const paths = workspacePaths(opts.workspaceRoot);
@@ -58085,7 +58134,7 @@ function createWorkspaceEngine(opts) {
       const srcPaths = diff.changedPaths.filter((p) => /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i.test(p));
       let episodeId2;
       if (srcPaths.length > 0) {
-        const abs = srcPaths.map((p) => join28(opts.workspaceRoot, p));
+        const abs = srcPaths.map((p) => join29(opts.workspaceRoot, p));
         try {
           const r = await runReindexPass(
             `git-reindex:${profile.name} (${abs.length} files)`,
@@ -58121,8 +58170,8 @@ function createWorkspaceEngine(opts) {
         `[errata] git: ${ev.kind} ${ev.newSha.slice(0, 7)} by ${meta3.authorName} \u2014 ${diff.changedPaths.length} file(s), ${diff.renames.length} rename(s)`
       );
     };
-    const gitDir = join28(opts.workspaceRoot, ".git");
-    if (existsSync23(gitDir)) {
+    const gitDir = join29(opts.workspaceRoot, ".git");
+    if (existsSync24(gitDir)) {
       stopGit = startGitSensor(gitDir, (ev) => {
         void handleGitEvent(ev).catch((err2) => {
           console.warn("[errata] git event handler failed:", err2);
@@ -58303,10 +58352,10 @@ function createWorkspaceEngine(opts) {
       console.warn("[errata] render ledger failed:", err2.message?.slice(0, 120));
     }
     writeContextFile(opts.workspaceRoot, body2);
-    const target = join28(opts.workspaceRoot, "AGENTS.md");
+    const target = join29(opts.workspaceRoot, "AGENTS.md");
     writeManagedBlock(target, { body: AGENTS_POINTER_BODY, stable: true, force: true });
     if (elicit) {
-      writePrimingHandles(join28(paths.configDir, "priming-handles.json"), [
+      writePrimingHandles(join29(paths.configDir, "priming-handles.json"), [
         ...snapshot.recentProblems.map((r) => r.node),
         // Resolved-band handles: the ✓ problem AND its Solution are citable
         // (a fix tag on an already-resolved problem no-ops idempotently; the
@@ -58607,7 +58656,7 @@ function createWorkspaceEngine(opts) {
       resultSummary: { exitCode: e.exitCode ?? 1, errorTokens: e.errorTokens }
     });
   };
-  const turnCursorPath = join28(paths.configDir, "turn-cursors.json");
+  const turnCursorPath = join29(paths.configDir, "turn-cursors.json");
   const lastTurnUuid = loadTurnCursors(turnCursorPath);
   const turnOffset = loadTurnOffsets(turnCursorPath);
   const readLosses = { parseFailures: 0, ioFailures: 0, bytesUnreachable: 0, sliceGuardHits: 0 };
@@ -58662,7 +58711,7 @@ function createWorkspaceEngine(opts) {
     let processedTurns = 0;
     const seqAtStart = store.currentIngestSeq();
     const elicit = isEdgeElicitationEnabled();
-    const handleMap = elicit ? readPrimingHandles(join28(paths.configDir, "priming-handles.json")) : {};
+    const handleMap = elicit ? readPrimingHandles(join29(paths.configDir, "priming-handles.json")) : {};
     const wsRoot = (opts.workspaceRoot ?? "").replace(/\\/g, "/");
     const toRel = (abs) => {
       const p = abs.replace(/\\/g, "/");
@@ -59463,7 +59512,7 @@ function createWorkspaceEngine(opts) {
       }
       turns = next.turns;
       nextOffset = next.nextOffset;
-      await new Promise((resolve6) => setImmediate(resolve6));
+      await new Promise((resolve7) => setImmediate(resolve7));
     }
   };
   const seenMessageIds = /* @__PURE__ */ new Set();
@@ -59666,7 +59715,7 @@ B: ${b}`,
     try {
       const inputs = emitInputsFromManifest(paths.configDir, paths.skillsManifest);
       emitAndProjectSkills(opts.workspaceRoot, inputs);
-      writePrimingHandles(join28(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
+      writePrimingHandles(join29(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
     } catch (err2) {
       console.warn("[skills] agent-skills projection failed (non-fatal):", err2 instanceof Error ? err2.message : err2);
     }
@@ -59959,7 +60008,7 @@ B: ${b}`,
         console.log(
           "[errata] sync skipped \u2014 cloud sync consent is off (enable with `errata consent sync on`)"
         );
-        const pending = existsSync23(paths.outbox) ? readdirSync10(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync24(paths.outbox) ? readdirSync10(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       try {
@@ -60093,7 +60142,7 @@ async function startDaemon(opts) {
       );
       await engine.stop();
       try {
-        if (existsSync24(engine.paths.daemonLock)) {
+        if (existsSync25(engine.paths.daemonLock)) {
         }
       } catch {
       }
@@ -60101,9 +60150,9 @@ async function startDaemon(opts) {
   };
 }
 async function listenServer(fetchFn, port) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const server = serve({ fetch: fetchFn, hostname: "127.0.0.1", port }, (info2) => {
-      resolve6({ server, port: info2.port });
+      resolve7({ server, port: info2.port });
     });
   });
 }
@@ -60115,7 +60164,7 @@ init_identity2();
 // src/multi.ts
 init_dist();
 init_src5();
-import { existsSync as existsSync29, readFileSync as readFileSync27, unlinkSync as unlinkSync3, writeFileSync as writeFileSync22 } from "node:fs";
+import { existsSync as existsSync30, readFileSync as readFileSync28, unlinkSync as unlinkSync3, writeFileSync as writeFileSync22 } from "node:fs";
 
 // src/principle-sync.ts
 init_src5();
@@ -60143,8 +60192,8 @@ init_reconcile();
 
 // src/lockfile-auto.ts
 init_src();
-import { existsSync as existsSync25, readFileSync as readFileSync24 } from "node:fs";
-import { join as join29 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync25 } from "node:fs";
+import { join as join30 } from "node:path";
 
 // src/package-index.ts
 init_src();
@@ -60293,11 +60342,11 @@ function runLockfilePass(opts) {
     { file: "package-lock.json", parse: parsePackageLockJson }
   ];
   for (const c of candidates) {
-    const p = join29(opts.root, c.file);
-    if (!existsSync25(p)) continue;
+    const p = join30(opts.root, c.file);
+    if (!existsSync26(p)) continue;
     let sbom;
     try {
-      sbom = c.parse(readFileSync24(p, "utf8"));
+      sbom = c.parse(readFileSync25(p, "utf8"));
     } catch {
       continue;
     }
@@ -60354,8 +60403,8 @@ function noveltyAgainst(node2, neighbors, opts = {}) {
 }
 
 // src/public-symbols.ts
-import { readFileSync as readFileSync25, readdirSync as readdirSync11, existsSync as existsSync26 } from "node:fs";
-import { join as join30 } from "node:path";
+import { readFileSync as readFileSync26, readdirSync as readdirSync11, existsSync as existsSync27 } from "node:fs";
+import { join as join31 } from "node:path";
 var HEAD_BYTES = 8 * 1024;
 var INDEX_TTL_MS = 10 * 60 * 1e3;
 var MIN_SYMBOL_LEN = 4;
@@ -60388,20 +60437,20 @@ function bindingNames(clause) {
 function internalPackageNames(workspaceRoot) {
   const names = /* @__PURE__ */ new Set();
   const tryRead = (dir) => {
-    const pj = join30(dir, "package.json");
-    if (!existsSync26(pj)) return;
+    const pj = join31(dir, "package.json");
+    if (!existsSync27(pj)) return;
     try {
-      const name2 = JSON.parse(readFileSync25(pj, "utf8")).name;
+      const name2 = JSON.parse(readFileSync26(pj, "utf8")).name;
       if (typeof name2 === "string" && name2.length > 0) names.add(name2);
     } catch {
     }
   };
   tryRead(workspaceRoot);
   for (const group of ["packages", "apps"]) {
-    const groupDir = join30(workspaceRoot, group);
-    if (!existsSync26(groupDir)) continue;
+    const groupDir = join31(workspaceRoot, group);
+    if (!existsSync27(groupDir)) continue;
     try {
-      for (const entry of readdirSync11(groupDir)) tryRead(join30(groupDir, entry));
+      for (const entry of readdirSync11(groupDir)) tryRead(join31(groupDir, entry));
     } catch {
     }
   }
@@ -60414,7 +60463,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   if (cached2 && now - cached2.builtAt < INDEX_TTL_MS) return cached2;
   const readHead = deps.readHead ?? ((absPath) => {
     try {
-      return readFileSync25(absPath, "utf8").slice(0, HEAD_BYTES);
+      return readFileSync26(absPath, "utf8").slice(0, HEAD_BYTES);
     } catch {
       return "";
     }
@@ -60434,7 +60483,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const symbols = /* @__PURE__ */ new Set();
   for (const rel of files) {
-    const head2 = readHead(join30(workspaceRoot, rel));
+    const head2 = readHead(join31(workspaceRoot, rel));
     if (!head2) continue;
     for (const re of [NAMED_IMPORT_RE, REQUIRE_RE]) {
       re.lastIndex = 0;
@@ -60966,8 +61015,8 @@ var ConsolidateWorker = class {
       const id = this.nextId++;
       try {
         await this.ready;
-        return await new Promise((resolve6, reject) => {
-          this.pending.set(id, { resolve: resolve6, reject });
+        return await new Promise((resolve7, reject) => {
+          this.pending.set(id, { resolve: resolve7, reject });
           this.worker.postMessage({ ...req, id });
         });
       } finally {
@@ -60996,12 +61045,12 @@ var ConsolidateWorker = class {
     });
     noteIsolateSpawned();
     this.worker = worker;
-    this.ready = new Promise((resolve6, reject) => {
+    this.ready = new Promise((resolve7, reject) => {
       const onReady = (m) => {
         if (m?.ready) {
           worker.off("message", onReady);
           worker.off("error", onErr);
-          resolve6();
+          resolve7();
         }
       };
       const onErr = (err2) => {
@@ -61046,7 +61095,7 @@ var ConsolidateWorker = class {
 init_paths();
 
 // src/lock.ts
-import { existsSync as existsSync27, readFileSync as readFileSync26 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync27 } from "node:fs";
 function isProcessAlive(pid) {
   if (!pid || pid <= 0) return false;
   try {
@@ -61057,9 +61106,9 @@ function isProcessAlive(pid) {
   }
 }
 function readDaemonLock(lockPath) {
-  if (!existsSync27(lockPath)) return null;
+  if (!existsSync28(lockPath)) return null;
   try {
-    const lock = JSON.parse(readFileSync26(lockPath, "utf8"));
+    const lock = JSON.parse(readFileSync27(lockPath, "utf8"));
     return typeof lock.pid === "number" ? lock : null;
   } catch {
     return null;
@@ -61187,13 +61236,13 @@ function startUpdatePoller(opts) {
   };
 }
 function runNpmInstall(channel) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = spawn2("npm", ["install", "-g", `${PACKAGE_NAME}@${channel}`], {
       stdio: "inherit",
       shell: true
     });
-    child.on("close", (code) => resolve6(code ?? 1));
-    child.on("error", () => resolve6(1));
+    child.on("close", (code) => resolve7(code ?? 1));
+    child.on("error", () => resolve7(1));
   });
 }
 
@@ -61347,13 +61396,14 @@ async function reanchorProject(opts) {
 init_registry();
 
 // src/adopt.ts
-import { existsSync as existsSync28 } from "node:fs";
-import { dirname as dirname10, join as join31 } from "node:path";
+init_git_remote();
+import { existsSync as existsSync29 } from "node:fs";
+import { dirname as dirname11, join as join32 } from "node:path";
 function findGitRoot(absPath) {
   let dir = absPath;
   for (let depth = 0; depth < 64; depth++) {
-    if (existsSync28(join31(dir, ".git"))) return dir;
-    const parent = dirname10(dir);
+    if (existsSync29(join32(dir, ".git"))) return dir;
+    const parent = dirname11(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -61871,10 +61921,6 @@ async function startMultiDaemon(opts = {}) {
     }
     records.push(rec);
     void ambientLinkAll();
-    if (!mountedIds.has(rec.id)) {
-      mountedIds.add(rec.id);
-      app.route(`/ws/${rec.id}`, rec.webApp);
-    }
     try {
       writeFileSync22(
         rec.engine.paths.daemonLock,
@@ -61964,11 +62010,13 @@ async function startMultiDaemon(opts = {}) {
     }
     return hit?.count ?? -1;
   };
+  let lastHook = null;
   app.get(
     "/health",
     (c) => c.json({
       ok: true,
       daemonVersion: DAEMON_VERSION,
+      lastHook,
       // What the daemon is DOING, not just what it holds. Without these a
       // pegged daemon is only diagnosable by attaching a CPU profiler to the
       // live process — see watch-census.ts for the incident that proved it.
@@ -61999,6 +62047,7 @@ async function startMultiDaemon(opts = {}) {
     } catch {
       return c.json({ error: "bad-json" }, 400);
     }
+    lastHook = { at: Date.now(), event: typeof body2["hook_event_name"] === "string" ? body2["hook_event_name"] : c.req.path };
     let owner = ownerOf(records, pathInBody(body2));
     if (!owner) {
       const missPath = pathInBody(body2);
@@ -62053,6 +62102,18 @@ async function startMultiDaemon(opts = {}) {
     mountedIds.add(r.id);
     app.route(`/ws/${r.id}`, r.webApp);
   }
+  const dispatchHot = async (c) => {
+    const id = c.req.param("id");
+    const rec = records.find((r) => r.id === id);
+    if (!rec) return c.notFound();
+    const url2 = new URL(c.req.url);
+    url2.pathname = url2.pathname.slice(`/ws/${id}`.length) || "/";
+    const method = c.req.method;
+    const body2 = method === "GET" || method === "HEAD" ? void 0 : await c.req.raw.arrayBuffer();
+    return rec.webApp.fetch(new Request(url2.toString(), { method, headers: c.req.raw.headers, body: body2 }));
+  };
+  app.all("/ws/:id", dispatchHot);
+  app.all("/ws/:id/*", dispatchHot);
   const retireWorkspace = async (rec, reason) => {
     const idx = records.indexOf(rec);
     if (idx === -1) return;
@@ -62074,7 +62135,7 @@ async function startMultiDaemon(opts = {}) {
         lastActiveAt = Math.max(lastActiveAt, rec.engine.lastActivityAt());
       } catch {
       }
-      const reason = retireDecision({ exists: existsSync29(rec.root), lastActiveAt, now });
+      const reason = retireDecision({ exists: existsSync30(rec.root), lastActiveAt, now });
       if (reason) void retireWorkspace(rec, reason);
     }
   };
@@ -62236,7 +62297,7 @@ async function startMultiDaemon(opts = {}) {
   const packageAutoAll = async () => {
     const out2 = /* @__PURE__ */ new Map();
     for (const r of records) {
-      await new Promise((resolve6) => setImmediate(resolve6));
+      await new Promise((resolve7) => setImmediate(resolve7));
       const done = markPass(`package-index:${r.entry.name}`);
       try {
         out2.set(
@@ -62830,7 +62891,7 @@ async function startMultiDaemon(opts = {}) {
       clearInterval(codexWake);
       clearTimeout(codexWakeBoot);
       try {
-        const cur = readFileSync27(lockPath, "utf8");
+        const cur = readFileSync28(lockPath, "utf8");
         if (JSON.parse(cur).pid === process.pid) unlinkSync3(lockPath);
       } catch {
       }
@@ -62878,6 +62939,7 @@ async function startMultiDaemon(opts = {}) {
 
 // src/cli.ts
 init_src5();
+init_git_remote();
 init_config();
 init_src7();
 init_cloud_auth();
@@ -63037,7 +63099,7 @@ async function loginOAuthDevice(opts) {
   let deviceSession = null;
   let approvedInstallation = null;
   while (Date.now() < deadline) {
-    await (opts.sleep ?? ((ms) => new Promise((resolve6) => setTimeout(resolve6, ms))))(intervalMs);
+    await (opts.sleep ?? ((ms) => new Promise((resolve7) => setTimeout(resolve7, ms))))(intervalMs);
     const poll = await fetchFn(device.token, {
       method: "POST",
       headers: { "content-type": "application/json", accept: "application/json" },
@@ -63141,7 +63203,7 @@ async function loginOAuthLoopback(opts) {
   const state = randomState();
   const scope = opts.scope ?? DEFAULT_OAUTH_SCOPE;
   const { code, redirectUri, clientId } = await new Promise(
-    (resolve6, reject) => {
+    (resolve7, reject) => {
       const server = createServer((req, res) => {
         const u = new URL(req.url ?? "/", "http://127.0.0.1");
         if (u.pathname !== "/callback") {
@@ -63164,7 +63226,7 @@ async function loginOAuthLoopback(opts) {
         res.writeHead(200, { "content-type": "text/html" });
         res.end("<html><body>inErrata: you're logged in. You can close this tab.</body></html>");
         server.close();
-        resolve6({ code: code2, redirectUri: `http://127.0.0.1:${port}/callback`, clientId: activeClientId });
+        resolve7({ code: code2, redirectUri: `http://127.0.0.1:${port}/callback`, clientId: activeClientId });
       });
       let activeClientId = oauthClientId();
       server.on("error", reject);
@@ -63405,6 +63467,7 @@ function openInBrowser(url2) {
 
 // src/cli.ts
 init_paths();
+init_checkout_root();
 
 // src/cli-args.ts
 var BURST_VALUE_FLAGS = /* @__PURE__ */ new Set(["--limit", "--hops", "--max-hops"]);
@@ -63824,7 +63887,7 @@ var exitCleanOnEpipe = (err2) => {
 };
 process.stdout.on("error", exitCleanOnEpipe);
 process.stderr.on("error", exitCleanOnEpipe);
-var ROOT = process.cwd();
+var ROOT = checkoutRootOf(process.cwd());
 var argv = process.argv.slice(2);
 var cmd = argv[0] ?? "help";
 var rest = argv.slice(1);
@@ -64081,21 +64144,21 @@ async function cmdInit() {
   if (!skipHooks) {
     console.log("");
     console.log("installing harness hooks...");
-    const { existsSync: existsSync31 } = await import("node:fs");
-    const { join: join33 } = await import("node:path");
+    const { existsSync: existsSync32 } = await import("node:fs");
+    const { join: join34 } = await import("node:path");
     try {
       await installClaudeHooks(port);
     } catch (err2) {
       console.warn(`  \u26A0\uFE0F  Claude hook install failed: ${err2 instanceof Error ? err2.message : err2}`);
     }
-    if (existsSync31(join33(ROOT, ".cursor"))) {
+    if (existsSync32(join34(ROOT, ".cursor"))) {
       try {
         await installCursorMcpConfig();
       } catch (err2) {
         console.warn(`  \u26A0\uFE0F  Cursor MCP config failed: ${err2 instanceof Error ? err2.message : err2}`);
       }
     }
-    if (existsSync31(join33(ROOT, ".codex"))) {
+    if (existsSync32(join34(ROOT, ".codex"))) {
       try {
         await installCodexHooks(port);
       } catch (err2) {
@@ -64272,9 +64335,9 @@ async function cmdStatus() {
     console.log(`    stack:     ${profile.stack.join(", ") || "(none)"}`);
     console.log(`    languages: ${profile.languages.join(", ") || "(none)"}`);
   }
-  console.log(`  graph db:  ${existsSync30(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
-  console.log(`  event log: ${existsSync30(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
-  if (existsSync30(paths.castalia)) {
+  console.log(`  graph db:  ${existsSync31(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
+  console.log(`  event log: ${existsSync31(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
+  if (existsSync31(paths.castalia)) {
     try {
       const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src5(), src_exports2));
       const store = openGraphStore2({ path: paths.castalia });
@@ -64336,6 +64399,15 @@ async function cmdStatus() {
           const line = watchCensusLine(h.watch);
           if (line) console.log(`  watcher:   ${line}`);
         }
+        if (h.lastHook !== void 0) {
+          if (h.lastHook === null) {
+            console.log(`  hooks:     none received since the daemon started`);
+          } else {
+            const min = Math.round((Date.now() - h.lastHook.at) / 6e4);
+            const ago2 = min < 1 ? "just now" : min < 60 ? `${min}m ago` : `${Math.floor(min / 60)}h ${min % 60}m ago`;
+            console.log(`  hooks:     last received ${ago2} (${h.lastHook.event})`);
+          }
+        }
       }
     } catch {
     }
@@ -65068,11 +65140,11 @@ function cmdInstallationProfile(args2) {
 }
 async function cmdReview() {
   const paths = workspacePaths(ROOT);
-  if (!existsSync30(paths.reviewQueue)) {
+  if (!existsSync31(paths.reviewQueue)) {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync28(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync29(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -65743,7 +65815,7 @@ async function gatherRepo(store, ws) {
   };
 }
 async function gatherReportData(generatedAt) {
-  const { existsSync: existsSync31 } = await import("node:fs");
+  const { existsSync: existsSync32 } = await import("node:fs");
   const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src5(), src_exports2));
   const cfg = loadConfig();
   const outbound = cfg.consent.sync ? "auto" : "off";
@@ -65751,7 +65823,7 @@ async function gatherReportData(generatedAt) {
   for (const ws of listWorkspaces()) {
     if (ws.missing) continue;
     const dbPath = workspacePaths(ws.path).castalia;
-    if (!existsSync31(dbPath)) continue;
+    if (!existsSync32(dbPath)) continue;
     let store = null;
     try {
       store = openGraphStore2({ path: dbPath });
@@ -65795,8 +65867,8 @@ async function cmdReport(args2) {
   const outDir = workspacePaths(ROOT).configDir;
   mkdirSync9(outDir, { recursive: true });
   const files = renderReport2(data, { includeFutureVerbs });
-  for (const f of files) writeFileSync23(join32(outDir, f.name), f.html, "utf8");
-  const indexPath = join32(outDir, "report.html");
+  for (const f of files) writeFileSync23(join33(outDir, f.name), f.html, "utf8");
+  const indexPath = join33(outDir, "report.html");
   console.log(`report \u2192 ${indexPath}`);
   console.log(
     `  ${data.repos.length} repo(s) \xB7 ${files.length} file(s) \xB7 ${data.rollup.nodes.toLocaleString("en-US")} nodes`
@@ -65916,24 +65988,24 @@ async function cmdInstallHooks(args2) {
   }
 }
 async function installOpencodePlugin(port) {
-  const { mkdirSync: mkdirSync9, existsSync: existsSync31, readFileSync: readFileSync29, writeFileSync: writeFileSync23 } = await import("node:fs");
-  const { join: join33 } = await import("node:path");
-  const dir = join33(ROOT, ".opencode", "plugin");
-  if (!existsSync31(dir)) mkdirSync9(dir, { recursive: true });
-  const file2 = join33(dir, "inerrata.js");
-  if (existsSync31(file2)) {
-    const head2 = readFileSync29(file2, "utf8").split("\n")[0] ?? "";
+  const { mkdirSync: mkdirSync9, existsSync: existsSync32, readFileSync: readFileSync30, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join34 } = await import("node:path");
+  const dir = join34(ROOT, ".opencode", "plugin");
+  if (!existsSync32(dir)) mkdirSync9(dir, { recursive: true });
+  const file2 = join34(dir, "inerrata.js");
+  if (existsSync32(file2)) {
+    const head2 = readFileSync30(file2, "utf8").split("\n")[0] ?? "";
     if (head2.trim() !== OPENCODE_PLUGIN_MARKER) {
       console.error(`refusing to overwrite ${file2}: not an errata-managed plugin (line 1 lacks the marker)`);
       process.exit(2);
     }
   }
   writeFileSync23(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
-  const cfgFile = join33(ROOT, "opencode.json");
+  const cfgFile = join34(ROOT, "opencode.json");
   let cfg = { $schema: "https://opencode.ai/config.json" };
-  if (existsSync31(cfgFile)) {
+  if (existsSync32(cfgFile)) {
     try {
-      cfg = JSON.parse(readFileSync29(cfgFile, "utf8"));
+      cfg = JSON.parse(readFileSync30(cfgFile, "utf8"));
     } catch {
       console.error(`refusing to touch invalid JSON at ${cfgFile} \u2014 fix it and re-run`);
       process.exit(2);
@@ -65964,15 +66036,15 @@ function errataMcpInvocation() {
   return { command: cmd2, args: args2 };
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync9, existsSync: existsSync31, readFileSync: readFileSync29, writeFileSync: writeFileSync23 } = await import("node:fs");
-  const { join: join33 } = await import("node:path");
-  const dir = join33(ROOT, ".claude");
-  if (!existsSync31(dir)) mkdirSync9(dir, { recursive: true });
-  const file2 = join33(dir, "settings.json");
+  const { mkdirSync: mkdirSync9, existsSync: existsSync32, readFileSync: readFileSync30, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join34 } = await import("node:path");
+  const dir = join34(ROOT, ".claude");
+  if (!existsSync32(dir)) mkdirSync9(dir, { recursive: true });
+  const file2 = join34(dir, "settings.json");
   let settings = {};
-  if (existsSync31(file2)) {
+  if (existsSync32(file2)) {
     try {
-      settings = JSON.parse(readFileSync29(file2, "utf8"));
+      settings = JSON.parse(readFileSync30(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -66021,7 +66093,7 @@ async function installClaudeHooks(port) {
   writeFileSync23(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code hooks \u2192 ${file2}`);
   await installClaudeMcpConfig();
-  const claudeMd = join33(ROOT, "CLAUDE.md");
+  const claudeMd = join34(ROOT, "CLAUDE.md");
   const recall = writeManagedBlock(claudeMd, { body: RECALL_FIRST_BLOCK });
   if (recall.kind === "collision") {
     console.warn(
@@ -66033,15 +66105,15 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync9, existsSync: existsSync31, readFileSync: readFileSync29, writeFileSync: writeFileSync23 } = await import("node:fs");
-  const { join: join33, dirname: dirname11 } = await import("node:path");
-  const file2 = join33(ROOT, ".mcp.json");
-  const dir = dirname11(file2);
-  if (!existsSync31(dir)) mkdirSync9(dir, { recursive: true });
+  const { mkdirSync: mkdirSync9, existsSync: existsSync32, readFileSync: readFileSync30, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join34, dirname: dirname12 } = await import("node:path");
+  const file2 = join34(ROOT, ".mcp.json");
+  const dir = dirname12(file2);
+  if (!existsSync32(dir)) mkdirSync9(dir, { recursive: true });
   let cfg = {};
-  if (existsSync31(file2)) {
+  if (existsSync32(file2)) {
     try {
-      cfg = JSON.parse(readFileSync29(file2, "utf8"));
+      cfg = JSON.parse(readFileSync30(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -66055,15 +66127,15 @@ async function installClaudeMcpConfig() {
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync9, existsSync: existsSync31, readFileSync: readFileSync29, writeFileSync: writeFileSync23 } = await import("node:fs");
-  const { join: join33 } = await import("node:path");
-  const dir = join33(ROOT, ".cursor");
-  if (!existsSync31(dir)) mkdirSync9(dir, { recursive: true });
-  const file2 = join33(dir, "mcp.json");
+  const { mkdirSync: mkdirSync9, existsSync: existsSync32, readFileSync: readFileSync30, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join34 } = await import("node:path");
+  const dir = join34(ROOT, ".cursor");
+  if (!existsSync32(dir)) mkdirSync9(dir, { recursive: true });
+  const file2 = join34(dir, "mcp.json");
   let cfg = {};
-  if (existsSync31(file2)) {
+  if (existsSync32(file2)) {
     try {
-      cfg = JSON.parse(readFileSync29(file2, "utf8"));
+      cfg = JSON.parse(readFileSync30(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -66079,14 +66151,14 @@ async function installCursorMcpConfig() {
   console.log(`  \u26A0\uFE0F  reload Cursor (Cmd/Ctrl-Shift-P \u2192 "Reload Window") to pick it up.`);
 }
 async function installCodexHooks(port) {
-  const { mkdirSync: mkdirSync9, existsSync: existsSync31, readFileSync: readFileSync29, writeFileSync: writeFileSync23 } = await import("node:fs");
-  const { join: join33 } = await import("node:path");
-  const dir = join33(ROOT, ".codex");
-  if (!existsSync31(dir)) mkdirSync9(dir, { recursive: true });
-  const file2 = join33(dir, "config.toml");
+  const { mkdirSync: mkdirSync9, existsSync: existsSync32, readFileSync: readFileSync30, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join34 } = await import("node:path");
+  const dir = join34(ROOT, ".codex");
+  if (!existsSync32(dir)) mkdirSync9(dir, { recursive: true });
+  const file2 = join34(dir, "config.toml");
   let existing = "";
-  if (existsSync31(file2)) {
-    existing = readFileSync29(file2, "utf8");
+  if (existsSync32(file2)) {
+    existing = readFileSync30(file2, "utf8");
     const beginIdx = existing.indexOf(CODEX_HOOKS_BEGIN);
     const endIdx = existing.indexOf(CODEX_HOOKS_END);
     if (beginIdx >= 0 && endIdx > beginIdx) {
@@ -66363,7 +66435,7 @@ async function cmdDash(args2) {
   const hotspotScanMark = /* @__PURE__ */ new Map();
   const HOTSPOT_FANIN = 20;
   const runNightlyPass = async (dueIds) => {
-    const yieldToLoop2 = () => new Promise((resolve6) => setImmediate(resolve6));
+    const yieldToLoop2 = () => new Promise((resolve7) => setImmediate(resolve7));
     const fullReclusterPass = nightlyCount++ % FULL_RECLUSTER_EVERY === 0;
     const m = dueIds ? await handle2.nightlyFor(dueIds) : await handle2.nightlyAll();
     let skillsLearned = 0;
@@ -66441,7 +66513,7 @@ async function cmdDash(args2) {
       await yieldToLoop2();
       try {
         const items = selectDurableMemory(handle2.sharedStore, r.engine.profile);
-        const res = bleedRules(join32(r.root, ".claude", "rules"), items);
+        const res = bleedRules(join33(r.root, ".claude", "rules"), items);
         if (res.written || res.pruned) {
           console.log(
             `[rules:${r.entry.name}] ${res.written} collective principle(s) \u2192 .claude/rules` + (res.pruned ? `, ${res.pruned} pruned` : "")