@plumpslabs/kuma 2.4.14 → 2.4.16

package/dist/index.js

@@ -1220,8 +1220,8 @@ async function runDoctor() {
     } catch {
     }
     try {
-      const { execSync: execSync9 } = await import("child_process");
-      const psOutput = execSync9(
+      const { execSync: execSync10 } = await import("child_process");
+      const psOutput = execSync10(
         `ps -eo pid,ppid,command | grep -E "(jest|pnpm test|npm test|yarn test)" | grep -v grep | head -10`,
         { encoding: "utf-8", timeout: 5e3 }
       ).trim();
@@ -3251,6 +3251,18 @@ function parseFallbackRegex(filePath, content) {
     if (impMatch && (impMatch[1].startsWith(".") || impMatch[1].startsWith("/"))) {
       result.imports.push({ source: impMatch[1], symbols: [], isDefault: false });
     }
+    if (!fnMatch && !clsMatch) {
+      const callRe = /([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g;
+      let m;
+      let count = 0;
+      while ((m = callRe.exec(line)) !== null && count < 5) {
+        const name = m[1];
+        if (!isJsBuiltin(name) && !result.calledSymbols.includes(name)) {
+          result.calledSymbols.push(name);
+          count++;
+        }
+      }
+    }
   }
   return result;
 }
@@ -4577,6 +4589,326 @@ var init_workspaceIntelligence = __esm({
   }
 });
 
+// src/engine/mapBackbone.ts
+var mapBackbone_exports = {};
+__export(mapBackbone_exports, {
+  BACKBONE_MAX_FILES: () => BACKBONE_MAX_FILES,
+  buildBackbone: () => buildBackbone,
+  ensureBackbone: () => ensureBackbone,
+  ensureMapped: () => ensureMapped,
+  extractImportSources: () => extractImportSources,
+  formatBackbone: () => formatBackbone,
+  isMapEmpty: () => isMapEmpty,
+  readMapMeta: () => readMapMeta
+});
+import fs9 from "fs";
+import path11 from "path";
+import fastGlob3 from "fast-glob";
+function extractImportSources(line) {
+  const out = [];
+  const t = line.trim();
+  if (t.startsWith("//") || t.startsWith("#") || t.startsWith("*")) return out;
+  for (const re of IMPORT_RES) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(line)) !== null) {
+      if (m[1] && m[1].startsWith(".")) out.push(m[1]);
+    }
+  }
+  return out;
+}
+function mapMetaPath(root) {
+  return path11.join(root || getProjectRoot(), MAP_META);
+}
+function readMapMeta(root) {
+  try {
+    const fp = mapMetaPath(root);
+    if (fs9.existsSync(fp)) return JSON.parse(fs9.readFileSync(fp, "utf-8"));
+  } catch {
+  }
+  return {};
+}
+function writeMapMeta(patch, root) {
+  try {
+    const fp = mapMetaPath(root);
+    const prev = readMapMeta(root);
+    fs9.writeFileSync(fp, JSON.stringify({ ...prev, ...patch }, null, 2), "utf-8");
+  } catch {
+  }
+}
+async function isMapEmpty() {
+  try {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
+    const db = await getDb2();
+    const stmt = db.prepare(`SELECT COUNT(*) as cnt FROM nodes WHERE type = 'file'`);
+    let n = 0;
+    if (stmt.step()) n = Number(stmt.getAsObject().cnt) || 0;
+    stmt.free();
+    return n === 0;
+  } catch {
+    return true;
+  }
+}
+async function buildBackbone(maxFiles = BACKBONE_MAX_FILES) {
+  const started = Date.now();
+  const root = getProjectRoot();
+  const result = { files: 0, capped: false, nodes: 0, edges: 0, ms: 0, filesPerSec: 0 };
+  let files = [];
+  try {
+    files = await fastGlob3([...DEFAULT_SOURCE_INCLUDES], {
+      cwd: root,
+      ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**", "**/*.d.ts", "**/.kuma/**"],
+      onlyFiles: true,
+      deep: 7,
+      dot: false
+    });
+  } catch {
+    return result;
+  }
+  const capped = files.length > maxFiles;
+  const batch = files.slice(0, maxFiles);
+  result.files = batch.length;
+  result.capped = capped;
+  const existingEdges = /* @__PURE__ */ new Set();
+  const existingFiles = /* @__PURE__ */ new Set();
+  try {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
+    const db = await getDb2();
+    const stmt = db.prepare(`SELECT source_id, target_id FROM edges WHERE type = 'imports'`);
+    while (stmt.step()) {
+      const r = stmt.getAsObject();
+      existingEdges.add(`${r.source_id}\u2192${r.target_id}`);
+    }
+    stmt.free();
+    const fStmt = db.prepare(`SELECT id FROM nodes WHERE type = 'file'`);
+    while (fStmt.step()) existingFiles.add(fStmt.getAsObject().id);
+    fStmt.free();
+  } catch {
+  }
+  for (const filePath of batch) {
+    try {
+      const full = path11.join(root, filePath);
+      const stat = fs9.statSync(full);
+      if (!stat.isFile() || stat.size > 512 * 1024) continue;
+      const fileId = `file::${filePath}`;
+      if (!existingFiles.has(fileId)) {
+        try {
+          await upsertNode({ id: fileId, type: "file", name: filePath, filePath, metadata: { backbone: true } });
+          existingFiles.add(fileId);
+          result.nodes++;
+        } catch {
+          continue;
+        }
+      }
+      const content = fs9.readFileSync(full, "utf-8");
+      const seen = /* @__PURE__ */ new Set();
+      for (const line of content.split("\n")) {
+        for (const src of extractImportSources(line)) {
+          if (seen.has(src)) continue;
+          seen.add(src);
+          try {
+            const resolved = resolveImportPath(filePath, src, root);
+            const key = resolved ? `${fileId}\u2192file::${resolved}` : "";
+            if (resolved && !existingEdges.has(key)) {
+              await addEdge({ sourceId: fileId, targetId: `file::${resolved}`, type: "imports" });
+              existingEdges.add(key);
+              result.edges++;
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  result.ms = Date.now() - started;
+  result.filesPerSec = result.ms > 0 ? Math.round(result.files / result.ms * 1e3) : result.files;
+  writeMapMeta({
+    backboneAt: Date.now(),
+    backboneFiles: result.files,
+    backboneCapped: result.capped,
+    backboneMs: result.ms,
+    filesPerSec: result.filesPerSec
+  });
+  return result;
+}
+async function ensureBackbone() {
+  try {
+    if (!await isMapEmpty()) return null;
+    return await buildBackbone();
+  } catch {
+    return null;
+  }
+}
+function formatBackbone(r) {
+  return `\u{1F5FA}\uFE0F Backbone: ${r.files} file(s)${r.capped ? ` (capped at ${BACKBONE_MAX_FILES})` : ""}, ${r.edges} import edge(s) in ${r.ms}ms (~${r.filesPerSec} files/s) \u2014 approximate tier, symbols fill in on demand.`;
+}
+async function ensureMapped(files) {
+  const targets = [...new Set(files.map((f) => f.trim()).filter(Boolean))].slice(0, 10);
+  if (targets.length === 0) return { filled: 0 };
+  let missing = [];
+  try {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
+    const db = await getDb2();
+    for (const f of targets) {
+      const stmt = db.prepare(
+        `SELECT COUNT(*) as cnt FROM nodes WHERE type IN ('function','class','method','interface') AND file_path LIKE ?`
+      );
+      stmt.bind([`%${path11.basename(f)}%`]);
+      let n = 0;
+      if (stmt.step()) n = Number(stmt.getAsObject().cnt) || 0;
+      stmt.free();
+      if (n === 0) missing.push(f);
+    }
+  } catch {
+    missing = targets;
+  }
+  if (missing.length === 0) return { filled: 0 };
+  try {
+    const { scanCodebase: scanCodebase2 } = await Promise.resolve().then(() => (init_kumaCodeScanner(), kumaCodeScanner_exports));
+    const res = await scanCodebase2({ include: missing, force: true, maxFiles: missing.length });
+    if (res.filesScanned > 0) writeMapMeta({ precisionAt: Date.now() });
+    return { filled: Math.min(missing.length, res.filesScanned) };
+  } catch {
+    return { filled: 0 };
+  }
+}
+var BACKBONE_MAX_FILES, MAP_META, IMPORT_RES;
+var init_mapBackbone = __esm({
+  "src/engine/mapBackbone.ts"() {
+    "use strict";
+    init_pathValidator();
+    init_kumaGraph();
+    init_kumaCodeScanner();
+    init_languageSupport();
+    BACKBONE_MAX_FILES = 2e3;
+    MAP_META = ".kuma/map-meta.json";
+    IMPORT_RES = [
+      /(?:import)\s+(?:[\w*{},\s]+\s+from\s+|[\w$]+\s+)?['"]([^'"]+)['"]/g,
+      /(?:from)\s+["']?([a-zA-Z0-9_./-]+)["']?\s+import\s+/g,
+      /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+    ];
+  }
+});
+
+// src/engine/symbolReach.ts
+var symbolReach_exports = {};
+__export(symbolReach_exports, {
+  formatReachability: () => formatReachability,
+  symbolReachability: () => symbolReachability
+});
+import fs10 from "fs";
+import path12 from "path";
+import { execSync as execSync4 } from "child_process";
+async function graphReach(symbol, limit) {
+  const rows = [];
+  try {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
+    const db = await getDb2();
+    const symStmt = db.prepare(
+      `SELECT id, file_path FROM nodes WHERE type IN ('function','class','method') AND (name = ? OR name LIKE ?) LIMIT 5`
+    );
+    symStmt.bind([symbol, `%::${symbol}`]);
+    const symIds = [];
+    while (symStmt.step()) {
+      const r = symStmt.getAsObject();
+      symIds.push({ id: r.id, file: r.file_path });
+    }
+    symStmt.free();
+    if (symIds.length === 0) return [];
+    for (const s of symIds) {
+      const cStmt = db.prepare(
+        `SELECT DISTINCT n_src.file_path as fp FROM edges e JOIN nodes n_src ON n_src.id = e.source_id WHERE e.target_id = ? AND e.type = 'calls' LIMIT 20`
+      );
+      cStmt.bind([s.id]);
+      const callers = /* @__PURE__ */ new Set();
+      while (cStmt.step()) {
+        const fp = cStmt.getAsObject().fp;
+        if (fp) callers.add(fp);
+      }
+      cStmt.free();
+      for (const fp of [...callers, s.file]) {
+        const tStmt = db.prepare(
+          `SELECT DISTINCT n.file_path as tfp FROM edges e JOIN nodes n ON n.id = e.source_id WHERE e.type = 'tests' AND (e.target_id LIKE ? OR e.target_id LIKE ?) LIMIT 5`
+        );
+        tStmt.bind([`%${fp}%`, `%${s.id}%`]);
+        while (tStmt.step()) {
+          const tfp = tStmt.getAsObject().tfp;
+          if (tfp && !rows.some((r) => r.test === tfp)) {
+            rows.push({ test: tfp, via: fp, evidence: `${tfp} tests ${fp} (graph edge)` });
+          }
+          if (rows.length >= limit) break;
+        }
+        tStmt.free();
+        if (rows.length >= limit) break;
+      }
+      if (rows.length >= limit) break;
+    }
+  } catch {
+  }
+  return rows;
+}
+function ripgrepReach(symbol, root, limit) {
+  const rows = [];
+  try {
+    const out = execSync4(
+      `grep -rn -F --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" --include="*.py" --include="*.go" --include="*.rs" "${symbol.replace(/"/g, "")}" . 2>/dev/null | grep -v node_modules | grep -v "/dist/" | grep -v "/.git/" | grep -v "/.kuma/" | head -40`,
+      { cwd: root, encoding: "utf-8", timeout: 8e3, maxBuffer: 256 * 1024 }
+    ).trim();
+    if (!out) return [];
+    const callers = /* @__PURE__ */ new Set();
+    for (const line of out.split("\n")) {
+      const m = line.match(/^([^:]+):(\d+):(.*)$/);
+      if (!m) continue;
+      const [, fp, ln, code] = m;
+      if (new RegExp(`\\b${symbol}\\s*\\(`).test(code)) callers.add(`${fp}:${ln}`);
+    }
+    for (const c of [...callers].slice(0, BERBEDA)) {
+      const [fp] = c.split(":");
+      const dir = path12.dirname(fp);
+      const stem = path12.basename(fp, path12.extname(fp)).split(/[-_.]/)[0];
+      try {
+        const dirFull = path12.join(root, dir);
+        if (!fs10.existsSync(dirFull)) continue;
+        for (const f of fs10.readdirSync(dirFull)) {
+          if (!/(\.test\.|\.spec\.|_test\.)/i.test(f)) continue;
+          const low = f.toLowerCase();
+          if (low.includes(stem.toLowerCase()) || low.includes(symbol.toLowerCase())) {
+            const rel = path12.join(dir, f);
+            if (!rows.some((r) => r.test === rel)) {
+              rows.push({ test: rel, via: fp, evidence: `${rel} sibling-matches caller ${fp} (called at ${c})` });
+            }
+          }
+          if (rows.length >= limit) break;
+        }
+      } catch {
+      }
+      if (rows.length >= limit) break;
+    }
+  } catch {
+  }
+  return rows;
+}
+async function symbolReachability(symbol, limit = 10, root) {
+  const g = await graphReach(symbol, limit);
+  if (g.length > 0) return { tier: 1, rows: g };
+  return { tier: 2, rows: ripgrepReach(symbol, root || getProjectRoot(), limit) };
+}
+function formatReachability(symbol, tier, rows) {
+  if (rows.length === 0) return `\u{1F50E} Reachability \`${symbol}\` (tier ${tier}): no tests reach this symbol.`;
+  const lines = [`\u{1F50E} Reachability \`${symbol}\` (tier ${tier}, ${rows.length} test(s)):`];
+  for (const r of rows.slice(0, 5)) lines.push(`  \u2022 \`${r.test}\` via \`${r.via}\` \u2014 ${r.evidence}`);
+  return lines.join("\n");
+}
+var BERBEDA;
+var init_symbolReach = __esm({
+  "src/engine/symbolReach.ts"() {
+    "use strict";
+    init_pathValidator();
+    BERBEDA = 10;
+  }
+});
+
 // src/engine/testHistory.ts
 var testHistory_exports = {};
 __export(testHistory_exports, {
@@ -4692,17 +5024,17 @@ __export(impactAnalysis_exports, {
   classifyDiffShape: () => classifyDiffShape,
   getIndexerStatus: () => getIndexerStatus
 });
-import fs9 from "fs";
-import path11 from "path";
-import { execSync as execSync4 } from "child_process";
-import fastGlob3 from "fast-glob";
+import fs11 from "fs";
+import path13 from "path";
+import { execSync as execSync5 } from "child_process";
+import fastGlob4 from "fast-glob";
 function extOf(target) {
-  const base = path11.basename(target);
+  const base = path13.basename(target);
   const dot = base.lastIndexOf(".");
   return dot > 0 ? base.slice(dot).toLowerCase() : "";
 }
 function isExampleOrDocName(target) {
-  const base = path11.basename(target).toLowerCase();
+  const base = path13.basename(target).toLowerCase();
   return base.endsWith(".example") || base.startsWith(".env") || base.endsWith(".md") || base.endsWith(".txt") || base.endsWith(".rst") || base === "license" || base.startsWith("license.");
 }
 function classifyDiffShape(target, root) {
@@ -4715,7 +5047,7 @@ function classifyDiffShape(target, root) {
   }
   try {
     const cwd = root || getProjectRoot();
-    const diff = execSync4(`git diff --unified=0 -- "${target}"`, {
+    const diff = execSync5(`git diff --unified=0 -- "${target}"`, {
       cwd,
       encoding: "utf-8",
       timeout: 4e3,
@@ -4735,7 +5067,7 @@ function classifyDiffShape(target, root) {
   return { shape: "runtime-code", detail: "runtime code change" };
 }
 async function findImportingFiles(targetFile, root) {
-  const normTarget = normalizeScope(path11.normalize(targetFile)) || path11.normalize(targetFile);
+  const normTarget = normalizeScope(path13.normalize(targetFile)) || path13.normalize(targetFile);
   try {
     const db = await getDb();
     const targetFileId = `file::${normTarget}`;
@@ -4774,10 +5106,10 @@ async function findImportingFiles(targetFile, root) {
     }
   } catch {
   }
-  const baseName = path11.basename(normTarget, path11.extname(normTarget));
-  const relTarget = path11.isAbsolute(normTarget) ? path11.relative(root, normTarget) : normTarget;
+  const baseName = path13.basename(normTarget, path13.extname(normTarget));
+  const relTarget = path13.isAbsolute(normTarget) ? path13.relative(root, normTarget) : normTarget;
   try {
-    const files = await fastGlob3(
+    const files = await fastGlob4(
       ["**/*.{ts,tsx,js,jsx,mjs,cjs,py,go,rs}"],
       {
         cwd: root,
@@ -4788,14 +5120,14 @@ async function findImportingFiles(targetFile, root) {
     const dependents = [];
     const evidence = [];
     const importRegex = new RegExp(
-      `(?:import|from|require\\s*\\(|export\\s+.*from)\\s*['"][^'"]*\\b${baseName}(?:\\.[a-zA-Z0-9]+)?['"]`,
+      `(?:import|from|require\\s*\\()[\\w{}*,.\\s]*['"][^'"]*\\b${baseName}(?:\\.[a-zA-Z0-9]+)?['"]`,
       "i"
     );
     for (const f of files) {
-      if (path11.normalize(f) === path11.normalize(relTarget)) continue;
-      const fullPath = path11.join(root, f);
+      if (path13.normalize(f) === path13.normalize(relTarget)) continue;
+      const fullPath = path13.join(root, f);
       try {
-        const content = fs9.readFileSync(fullPath, "utf-8");
+        const content = fs11.readFileSync(fullPath, "utf-8");
         const lines = content.split("\n");
         const hitIdx = lines.findIndex((l) => importRegex.test(l));
         if (hitIdx >= 0) {
@@ -4811,7 +5143,7 @@ async function findImportingFiles(targetFile, root) {
   }
 }
 async function findRelatedTests(targetFile, root, owningPackage, additionalDependents = [], exactOnly = false) {
-  const normTarget = normalizeScope(path11.normalize(targetFile)) || path11.normalize(targetFile);
+  const normTarget = normalizeScope(path13.normalize(targetFile)) || path13.normalize(targetFile);
   try {
     const db = await getDb();
     const targetFileId = `file::${normTarget}`;
@@ -4835,13 +5167,13 @@ async function findRelatedTests(targetFile, root, owningPackage, additionalDepen
     }
   } catch {
   }
-  const baseName = path11.basename(normTarget, path11.extname(normTarget));
+  const baseName = path13.basename(normTarget, path13.extname(normTarget));
   const testFiles = [];
   const stems = /* @__PURE__ */ new Set();
   if (baseName) stems.add(baseName);
   if (!exactOnly) {
     for (const dep of additionalDependents.slice(0, 3)) {
-      const depBase = path11.basename(dep, path11.extname(dep));
+      const depBase = path13.basename(dep, path13.extname(dep));
       if (depBase) stems.add(depBase);
     }
   }
@@ -4857,7 +5189,7 @@ async function findRelatedTests(targetFile, root, owningPackage, additionalDepen
     );
   }
   try {
-    const matches = await fastGlob3(testPatterns, {
+    const matches = await fastGlob4(testPatterns, {
       cwd: root,
       ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/.kuma/**"],
       onlyFiles: true
@@ -4876,13 +5208,13 @@ async function findRelatedTests(targetFile, root, owningPackage, additionalDepen
           `**/__tests__/**/*${stem}*.*`
         );
       }
-      const pkgTests = await fastGlob3(pkgPatterns, {
-        cwd: path11.join(root, owningPackage.path),
+      const pkgTests = await fastGlob4(pkgPatterns, {
+        cwd: path13.join(root, owningPackage.path),
         ignore: ["**/node_modules/**", "**/dist/**"],
         onlyFiles: true
       });
       for (const pt of pkgTests) {
-        const fullRel = path11.join(owningPackage.path, pt);
+        const fullRel = path13.join(owningPackage.path, pt);
         if (!testFiles.includes(fullRel)) {
           testFiles.push(fullRel);
         }
@@ -4933,18 +5265,29 @@ function assessRisk(target, targetType, directDependents, downstreamPackages, af
 }
 async function getIndexerStatus() {
   let graphEdges = false;
+  let backboneOnly = false;
   try {
     const db = await getDb();
     const stmt = db.prepare(`SELECT COUNT(*) as cnt FROM edges WHERE type IN ('imports','depends_on','calls','tests')`);
     if (stmt.step()) graphEdges = Number(stmt.getAsObject().cnt) > 0;
     stmt.free();
+    const fStmt = db.prepare(`SELECT COUNT(*) as cnt FROM nodes WHERE type = 'file'`);
+    let files = 0;
+    if (fStmt.step()) files = Number(fStmt.getAsObject().cnt) || 0;
+    fStmt.free();
+    const sStmt = db.prepare(`SELECT COUNT(*) as cnt FROM nodes WHERE type IN ('function','class','method','interface')`);
+    let syms = 0;
+    if (sStmt.step()) syms = Number(sStmt.getAsObject().cnt) || 0;
+    sStmt.free();
+    backboneOnly = files > 0 && syms === 0;
   } catch {
   }
   return {
     tier: graphEdges ? 1 : 2,
     graphEdges,
+    backboneOnly,
     languages: ["ts", "tsx", "js", "jsx", "mjs", "cjs", "py", "go", "rs"],
-    note: graphEdges ? "Tier 1: graph edges grounded the verdict (Tier 2 ripgrep fallback available)" : "Tier 2: ripgrep import-regex fallback (no graph edges; run a scan to reach Tier 1; LSP indexers are future work per #35)"
+    note: backboneOnly ? "Backbone-tier coverage: import graph only (approximate) \u2014 symbols fill in on demand when impact/research touches an area" : graphEdges ? "Tier 1: graph edges grounded the verdict (Tier 2 ripgrep fallback available)" : "Tier 2: ripgrep import-regex fallback (no graph edges; run a scan to reach Tier 1; LSP indexers are future work per #35)"
   };
 }
 async function calculateBlastRadius(target, options = {}) {
@@ -4970,6 +5313,13 @@ async function calculateBlastRadius(target, options = {}) {
     const rev = getReverseDependencies(owningPackage.name, wsInfo);
     downstreamPackages.push(...rev.map((p) => p.name));
   }
+  if (targetType === "file") {
+    try {
+      const { ensureMapped: ensureMapped2 } = await Promise.resolve().then(() => (init_mapBackbone(), mapBackbone_exports));
+      await ensureMapped2([target]);
+    } catch {
+    }
+  }
   let directDependents = [];
   let evidence = [];
   if (targetType === "file" || targetType === "symbol") {
@@ -4981,6 +5331,20 @@ async function calculateBlastRadius(target, options = {}) {
   const nonRuntime = diffShape !== "runtime-code";
   const affectedTests = await findRelatedTests(target, root, owningPackage, directDependents, nonRuntime);
   let testReasons = /* @__PURE__ */ new Map();
+  if (targetType === "symbol") {
+    try {
+      const { symbolReachability: symbolReachability2 } = await Promise.resolve().then(() => (init_symbolReach(), symbolReach_exports));
+      const reach = await symbolReachability2(target, 10, root);
+      for (const r of reach.rows) {
+        if (!affectedTests.includes(r.test)) {
+          affectedTests.push(r.test);
+          testReasons.set(r.test, `reachability tier ${reach.tier}: ${r.evidence.substring(0, 80)}`);
+        }
+        evidence.push(r.evidence);
+      }
+    } catch {
+    }
+  }
   try {
     const { rankTestsByHistory: rankTestsByHistory2 } = await Promise.resolve().then(() => (init_testHistory(), testHistory_exports));
     const ranked = await rankTestsByHistory2(target, affectedTests);
@@ -6195,27 +6559,27 @@ async function codebaseSearchFallback(query, limit = 20) {
         if (results.length >= limit || depth > MAX_WALK_DEPTH) return;
         let entries = [];
         try {
-          entries = fs32.readdirSync(dir);
+          entries = fs35.readdirSync(dir);
         } catch {
           return;
         }
         for (const entry of entries) {
           if (entry.startsWith(".") || entry === "node_modules" || entry === "dist" || entry === "build") continue;
-          const full = path35.join(dir, entry);
+          const full = path38.join(dir, entry);
           try {
-            const stat = fs32.statSync(full);
+            const stat = fs35.statSync(full);
             if (stat.isDirectory()) {
               walk2(full, depth + 1);
             } else if (entry.toLowerCase().includes(query.toLowerCase())) {
-              results.push(path35.relative(root, full));
+              results.push(path38.relative(root, full));
             }
           } catch {
           }
         }
       };
       var walk = walk2;
-      const fs32 = await import("fs");
-      const path35 = await import("path");
+      const fs35 = await import("fs");
+      const path38 = await import("path");
       const root = process.cwd();
       const results = [];
       const MAX_WALK_DEPTH = 8;
@@ -6348,9 +6712,9 @@ ${summary}`;
 }
 async function codebaseImpactFallback(target) {
   try {
-    const { execSync: execSync9 } = await import("child_process");
+    const { execSync: execSync10 } = await import("child_process");
     const root = process.cwd();
-    const grepResult = execSync9(
+    const grepResult = execSync10(
       `grep -rn ${grepIncludeFlags()} --include="*.json" --include="*.md" -l "${target.replace(/"/g, '\\"')}" . 2>/dev/null | grep -v node_modules | grep -v .git | grep -v dist | grep -v .kuma | head -50`,
       { cwd: root, encoding: "utf-8", timeout: 5e3, maxBuffer: 256 * 1024 }
     ).trim();
@@ -6496,9 +6860,9 @@ __export(kumaShared_exports, {
   isReadTool: () => isReadTool,
   isTestTool: () => isTestTool
 });
-import { execSync as execSync5 } from "child_process";
-import fs10 from "fs";
-import path12 from "path";
+import { execSync as execSync6 } from "child_process";
+import fs12 from "fs";
+import path14 from "path";
 function isEditTool(toolName) {
   const n = (toolName || "").toLowerCase();
   return n.includes("edit") || n.includes("write") || n.includes("patch") || n.includes("apply") || n.includes("replace");
@@ -6536,7 +6900,7 @@ function getSessionStats(inputGoal) {
 function getGitDiffStat(timeout = 3e3) {
   try {
     const root = getProjectRoot();
-    return execSync5("git diff --stat", {
+    return execSync6("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
       timeout
@@ -6549,7 +6913,7 @@ function getUncommittedFiles(timeout = 3e3) {
   const files = /* @__PURE__ */ new Set();
   try {
     const root = getProjectRoot();
-    const porcelain = execSync5("git status --porcelain", {
+    const porcelain = execSync6("git status --porcelain", {
       cwd: root,
       encoding: "utf-8",
       timeout,
@@ -6568,17 +6932,17 @@ function getBranchCommittedFiles(timeout = 5e3) {
   let base = "";
   try {
     const root = getProjectRoot();
-    const branch = execSync5("git rev-parse --abbrev-ref HEAD", {
+    const branch = execSync6("git rev-parse --abbrev-ref HEAD", {
       cwd: root,
       encoding: "utf-8",
       timeout,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const baseRef = execSync5(
+    const baseRef = execSync6(
       `git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null || echo origin/${branch === "main" || branch === "master" ? "HEAD" : "main"}`,
       { cwd: root, encoding: "utf-8", timeout, stdio: ["pipe", "pipe", "pipe"] }
     ).trim().replace("refs/remotes/", "");
-    const mergeBase = execSync5(`git merge-base HEAD ${baseRef} 2>/dev/null || git rev-list --max-parents=0 HEAD`, {
+    const mergeBase = execSync6(`git merge-base HEAD ${baseRef} 2>/dev/null || git rev-list --max-parents=0 HEAD`, {
       cwd: root,
       encoding: "utf-8",
       timeout,
@@ -6586,7 +6950,7 @@ function getBranchCommittedFiles(timeout = 5e3) {
     }).trim().split("\n")[0];
     base = baseRef;
     if (mergeBase) {
-      const out = execSync5(`git diff --name-only ${mergeBase} HEAD`, {
+      const out = execSync6(`git diff --name-only ${mergeBase} HEAD`, {
         cwd: root,
         encoding: "utf-8",
         timeout,
@@ -6604,10 +6968,10 @@ function hasVerificationEvidence(toolCalls) {
 }
 function hasVerificationInHookLog(hours = 24) {
   try {
-    const fp = path12.join(getProjectRoot(), ".kuma", "injections.jsonl");
-    if (!fs10.existsSync(fp)) return false;
+    const fp = path14.join(getProjectRoot(), ".kuma", "injections.jsonl");
+    if (!fs12.existsSync(fp)) return false;
     const cutoff = Date.now() - hours * 60 * 60 * 1e3;
-    const lines = fs10.readFileSync(fp, "utf-8").split("\n");
+    const lines = fs12.readFileSync(fp, "utf-8").split("\n");
     for (const line of lines) {
       if (!line.trim()) continue;
       try {
@@ -6710,7 +7074,7 @@ function detectTestWeakening(files, root) {
   for (const f of files) {
     if (!TEST_FILE_PATTERN.test(f)) continue;
     try {
-      const diff = execSync5(`git diff --unified=0 -- "${f}"`, {
+      const diff = execSync6(`git diff --unified=0 -- "${f}"`, {
         cwd,
         encoding: "utf-8",
         timeout: 4e3,
@@ -6749,19 +7113,19 @@ __export(kumaMemory_exports, {
   scoreMemoryRelevance: () => scoreMemoryRelevance,
   shouldRecordDecision: () => shouldRecordDecision
 });
-import fs11 from "fs";
-import path13 from "path";
+import fs13 from "fs";
+import path15 from "path";
 function scoreMemoryRelevance(context, limit = 5) {
   const results = [];
-  const kumaDir = path13.join(getProjectRoot(), MEMORY_DIR);
-  if (!fs11.existsSync(kumaDir)) return [];
+  const kumaDir = path15.join(getProjectRoot(), MEMORY_DIR);
+  if (!fs13.existsSync(kumaDir)) return [];
   const terms = Array.from(new Set(context.toLowerCase().split(/[\s/._-]+/).filter((w) => w.length > 2)));
   if (terms.length === 0) return [];
   try {
-    const files = fs11.readdirSync(kumaDir).filter((f) => f.endsWith(".md"));
+    const files = fs13.readdirSync(kumaDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       try {
-        const content = fs11.readFileSync(path13.join(kumaDir, file), "utf-8");
+        const content = fs13.readFileSync(path15.join(kumaDir, file), "utf-8");
         const lower = content.toLowerCase();
         let matchCount = 0;
         for (const term of terms) {
@@ -6943,8 +7307,8 @@ __export(cacheFreshness_exports, {
   isStale: () => isStale,
   markDirty: () => markDirty
 });
-import fs12 from "fs";
-import path14 from "path";
+import fs14 from "fs";
+import path16 from "path";
 function isStale(savedAtMs, ttlMs, nowMs = Date.now()) {
   if (!savedAtMs) return true;
   return nowMs - savedAtMs > ttlMs;
@@ -6957,13 +7321,13 @@ function formatAge(savedAtMs, nowMs = Date.now()) {
   return `${Math.floor(s / 86400)}d`;
 }
 function dirtyPath() {
-  return path14.join(getProjectRoot(), DIRTY_FILE);
+  return path16.join(getProjectRoot(), DIRTY_FILE);
 }
 function loadDirty() {
   try {
     const fp = dirtyPath();
-    if (fs12.existsSync(fp)) {
-      const parsed = JSON.parse(fs12.readFileSync(fp, "utf-8"));
+    if (fs14.existsSync(fp)) {
+      const parsed = JSON.parse(fs14.readFileSync(fp, "utf-8"));
       if (parsed && typeof parsed === "object") return parsed;
     }
   } catch {
@@ -6973,14 +7337,14 @@ function loadDirty() {
 function markDirty(filePath) {
   try {
     const fp = dirtyPath();
-    const dir = path14.dirname(fp);
-    if (!fs12.existsSync(dir)) fs12.mkdirSync(dir, { recursive: true });
+    const dir = path16.dirname(fp);
+    if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
     const dirty = loadDirty();
     dirty[filePath] = Date.now();
     const keys = Object.keys(dirty).sort((a, b) => dirty[b] - dirty[a]).slice(0, 200);
     const bounded = {};
     for (const k of keys) bounded[k] = dirty[k];
-    fs12.writeFileSync(fp, JSON.stringify(bounded), "utf-8");
+    fs14.writeFileSync(fp, JSON.stringify(bounded), "utf-8");
   } catch {
   }
 }
@@ -6990,7 +7354,7 @@ function getDirtyFiles() {
 function clearDirty() {
   try {
     const fp = dirtyPath();
-    if (fs12.existsSync(fp)) fs12.rmSync(fp, { force: true });
+    if (fs14.existsSync(fp)) fs14.rmSync(fp, { force: true });
   } catch {
   }
 }
@@ -7010,8 +7374,8 @@ var codeReuseEngine_exports = {};
 __export(codeReuseEngine_exports, {
   findReusableSymbols: () => findReusableSymbols
 });
-import path15 from "path";
-import fs13 from "fs";
+import path17 from "path";
+import fs15 from "fs";
 async function findReusableSymbols(query, scope) {
   const cleanQuery = query.trim().toLowerCase();
   const searchTokens = cleanQuery.replace(/[^a-zA-Z0-9_\s]/g, " ").split(/\s+/).filter((t) => t.length >= 2);
@@ -7134,7 +7498,7 @@ function detectRecommendedUtilDirectory() {
     "utils"
   ];
   for (const c of candidates) {
-    if (fs13.existsSync(path15.resolve(root, c))) {
+    if (fs15.existsSync(path17.resolve(root, c))) {
       return c;
     }
   }
@@ -7153,7 +7517,7 @@ var domainClusterEngine_exports = {};
 __export(domainClusterEngine_exports, {
   buildSubsystemClusters: () => buildSubsystemClusters
 });
-import path16 from "path";
+import path18 from "path";
 async function buildSubsystemClusters() {
   const db = await getDb();
   const fileStmt = db.prepare(`
@@ -7230,7 +7594,7 @@ async function buildSubsystemClusters() {
   for (const [cKey, files] of clusterFileMap.entries()) {
     for (const f of files) {
       fileToCluster.set(f, cKey);
-      fileToCluster.set(path16.normalize(f), cKey);
+      fileToCluster.set(path18.normalize(f), cKey);
     }
   }
   const clusterInteractions = /* @__PURE__ */ new Map();
@@ -7238,8 +7602,8 @@ async function buildSubsystemClusters() {
     const srcFile = extractFilePathFromNodeId(e.source);
     const tgtFile = extractFilePathFromNodeId(e.target);
     if (!srcFile || !tgtFile) continue;
-    const srcCluster = fileToCluster.get(srcFile) || fileToCluster.get(path16.normalize(srcFile));
-    const tgtCluster = fileToCluster.get(tgtFile) || fileToCluster.get(path16.normalize(tgtFile));
+    const srcCluster = fileToCluster.get(srcFile) || fileToCluster.get(path18.normalize(srcFile));
+    const tgtCluster = fileToCluster.get(tgtFile) || fileToCluster.get(path18.normalize(tgtFile));
     if (srcCluster && tgtCluster && srcCluster !== tgtCluster) {
       const pairKey = `${srcCluster}->${tgtCluster}`;
       const stats = clusterInteractions.get(pairKey) || { calls: 0, imports: 0 };
@@ -7261,13 +7625,13 @@ async function buildSubsystemClusters() {
     const clusterId = nodeId("feature_domain", cKey);
     const name = formatClusterName(cKey);
     const role = inferSubsystemRole(cKey, files);
-    const entrypoints = files.filter((f) => /index|main|server|app|engine|root/i.test(path16.basename(f))).slice(0, 3);
+    const entrypoints = files.filter((f) => /index|main|server|app|engine|root/i.test(path18.basename(f))).slice(0, 3);
     if (entrypoints.length === 0 && files.length > 0) {
       entrypoints.push(files[0]);
     }
     const allSyms = [];
     for (const f of files) {
-      const syms = fileSymbols.get(f) || fileSymbols.get(path16.normalize(f)) || [];
+      const syms = fileSymbols.get(f) || fileSymbols.get(path18.normalize(f)) || [];
       for (const s of syms) {
         if (!allSyms.includes(s)) allSyms.push(s);
       }
@@ -7446,7 +7810,7 @@ function inferSubsystemRole(key, files) {
   if (k.includes("util") || k.includes("common")) {
     return "Shared path validation, configuration loading, and platform detection helpers.";
   }
-  return `Core subsystem handling ${files.slice(0, 3).map((f) => path16.basename(f)).join(", ")}.`;
+  return `Core subsystem handling ${files.slice(0, 3).map((f) => path18.basename(f)).join(", ")}.`;
 }
 function inferTypedVerb(sourceKey, targetKey, _stats) {
   const src = sourceKey.toLowerCase();
@@ -7525,18 +7889,18 @@ __export(domainRules_exports, {
   readLayer: () => readLayer,
   writeLayer: () => writeLayer
 });
-import fs14 from "fs";
-import path17 from "path";
+import fs16 from "fs";
+import path19 from "path";
 function layerFilePath(layer) {
-  return path17.join(getProjectRoot(), ".kuma", LAYER_FILES[layer].filename);
+  return path19.join(getProjectRoot(), ".kuma", LAYER_FILES[layer].filename);
 }
 function ensureLayerFile(layer) {
   const fp = layerFilePath(layer);
-  if (!fs14.existsSync(fp)) {
+  if (!fs16.existsSync(fp)) {
     const template = layer === "arch_flow" ? ARCH_FLOW_TEMPLATE : GOTCHAS_TEMPLATE;
-    const dir = path17.dirname(fp);
-    if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
-    fs14.writeFileSync(fp, template, "utf-8");
+    const dir = path19.dirname(fp);
+    if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
+    fs16.writeFileSync(fp, template, "utf-8");
     console.error(`[DomainRules] Auto-created ${LAYER_FILES[layer].filename}`);
   }
   return fp;
@@ -7544,7 +7908,7 @@ function ensureLayerFile(layer) {
 function readLayer(layer) {
   try {
     const fp = ensureLayerFile(layer);
-    return fs14.readFileSync(fp, "utf-8");
+    return fs16.readFileSync(fp, "utf-8");
   } catch (err) {
     return `Error reading ${layer}: ${err}`;
   }
@@ -7552,7 +7916,7 @@ function readLayer(layer) {
 function writeLayer(layer, content) {
   try {
     const fp = ensureLayerFile(layer);
-    fs14.writeFileSync(fp, content, "utf-8");
+    fs16.writeFileSync(fp, content, "utf-8");
     const label = LAYER_FILES[layer].label;
     sessionMemory.recordToolCall("kuma_memory", { action: `write_${layer}` });
     return `\u2705 **${label}** updated successfully.`;
@@ -7563,9 +7927,9 @@ function writeLayer(layer, content) {
 function appendToLayer(layer, entry) {
   try {
     const fp = ensureLayerFile(layer);
-    const existing = fs14.readFileSync(fp, "utf-8");
+    const existing = fs16.readFileSync(fp, "utf-8");
     const newContent = existing.trimEnd() + "\n\n" + entry.trim() + "\n";
-    fs14.writeFileSync(fp, newContent, "utf-8");
+    fs16.writeFileSync(fp, newContent, "utf-8");
     return `\u2705 Entry added to **${LAYER_FILES[layer].label}**.`;
   } catch (err) {
     return `\u274C Failed to append: ${err}`;
@@ -7575,7 +7939,7 @@ function getActiveGotchas() {
   const results = [];
   try {
     const fp = ensureLayerFile("gotcha");
-    const content = fs14.readFileSync(fp, "utf-8");
+    const content = fs16.readFileSync(fp, "utf-8");
     const lines = content.split("\n");
     let currentSection = "";
     let currentFilePath = "";
@@ -7611,9 +7975,9 @@ function getActiveGotchas() {
 function checkFileGotchas(filePath) {
   const gotchas = getActiveGotchas();
   const warnings = [];
-  const base = path17.basename(filePath);
+  const base = path19.basename(filePath);
   for (const g of gotchas) {
-    const gBase = path17.basename(g.filePath);
+    const gBase = path19.basename(g.filePath);
     if (filePath.includes(g.filePath) || g.filePath.includes(filePath) || base && gBase && base === gBase) {
       const icon = g.severity === "critical" ? "\u{1F534}" : g.severity === "high" ? "\u{1F7E0}" : g.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
       warnings.push(`${icon} **Gotcha**: ${g.description} (${g.severity})`);
@@ -7713,8 +8077,8 @@ __export(kumaInject_exports, {
   parseHookInput: () => parseHookInput,
   trackFileEditLoop: () => trackFileEditLoop
 });
-import fs15 from "fs";
-import path18 from "path";
+import fs17 from "fs";
+import path20 from "path";
 function hashFileContent(filePath) {
   return hashFile(filePath);
 }
@@ -7725,10 +8089,10 @@ function isGotchaFresh(storedHash, currentHash) {
 }
 async function getFreshGotchasForFile(filePath, limit = 5, includeStale = false) {
   const root = getProjectRoot();
-  const base = path18.basename(filePath);
+  const base = path20.basename(filePath);
   try {
-    const dbFile = path18.join(root, ".kuma", "kuma.db");
-    if (fs15.existsSync(dbFile)) {
+    const dbFile = path20.join(root, ".kuma", "kuma.db");
+    if (fs17.existsSync(dbFile)) {
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
       const db = await getDb2();
       const stmt = db.prepare(`
@@ -7769,11 +8133,11 @@ async function getFreshGotchasForFile(filePath, limit = 5, includeStale = false)
   } catch {
   }
   try {
-    if (!fs15.existsSync(path18.join(root, ".kuma"))) return [];
+    if (!fs17.existsSync(path20.join(root, ".kuma"))) return [];
     const { getActiveGotchas: getActiveGotchas2 } = await Promise.resolve().then(() => (init_domainRules(), domainRules_exports));
     const allGotchas = getActiveGotchas2();
     const matched = allGotchas.filter(
-      (g) => g.filePath.includes(filePath) || filePath.includes(g.filePath) || base && path18.basename(g.filePath) === base
+      (g) => g.filePath.includes(filePath) || filePath.includes(g.filePath) || base && path20.basename(g.filePath) === base
     );
     if (matched.length > 0) {
       return matched.slice(0, limit).map((g) => ({
@@ -7792,8 +8156,8 @@ async function getFreshGotchasForFile(filePath, limit = 5, includeStale = false)
 async function getFileTrace(filePath, limit = 8) {
   try {
     const root = getProjectRoot();
-    const dbFile = path18.join(root, ".kuma", "kuma.db");
-    if (!fs15.existsSync(dbFile)) return [];
+    const dbFile = path20.join(root, ".kuma", "kuma.db");
+    if (!fs17.existsSync(dbFile)) return [];
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
     const db = await getDb2();
     const stmt = db.prepare(`
@@ -7803,7 +8167,7 @@ async function getFileTrace(filePath, limit = 8) {
       ORDER BY cl.created_at DESC
       LIMIT ?
     `);
-    stmt.bind([`%${path18.basename(filePath)}%`, limit]);
+    stmt.bind([`%${path20.basename(filePath)}%`, limit]);
     const rows = [];
     while (stmt.step()) rows.push(stmt.getAsObject());
     stmt.free();
@@ -7821,7 +8185,7 @@ async function getFileTrace(filePath, limit = 8) {
 function formatFileTrace(entries, filePath) {
   if (entries.length === 0) return "";
   const lines = [
-    `\u{1F570}\uFE0F **Why is ${path18.basename(filePath)} written this way?** \u2014 ${entries.length} change(s) recorded:`
+    `\u{1F570}\uFE0F **Why is ${path20.basename(filePath)} written this way?** \u2014 ${entries.length} change(s) recorded:`
   ];
   for (const e of entries) {
     const date = new Date((e.createdAt || 0) * 1e3).toLocaleDateString("en-US", {
@@ -7837,12 +8201,12 @@ function formatFileTrace(entries, filePath) {
 async function getDecisionsForFile(filePath, limit = 3) {
   const decisions = [];
   const root = getProjectRoot();
-  const base = path18.basename(filePath);
+  const base = path20.basename(filePath);
   const baseWithoutExt = base.replace(/\.[^.]+$/, "");
   try {
-    const decisionsMdPath = path18.join(root, ".kuma", "memories", "decisions.md");
-    if (fs15.existsSync(decisionsMdPath)) {
-      const content = fs15.readFileSync(decisionsMdPath, "utf-8");
+    const decisionsMdPath = path20.join(root, ".kuma", "memories", "decisions.md");
+    if (fs17.existsSync(decisionsMdPath)) {
+      const content = fs17.readFileSync(decisionsMdPath, "utf-8");
       const sections = content.split(/^##\s+/m);
       for (const section of sections) {
         if (!section.trim() || section.startsWith("# ")) continue;
@@ -7947,13 +8311,13 @@ async function getRelevantContext(filePath, goal) {
   if (traceStr) parts.push(traceStr);
   try {
     const root = getProjectRoot();
-    if (fs15.existsSync(path18.join(root, ".kuma", "kuma.db"))) {
+    if (fs17.existsSync(path20.join(root, ".kuma", "kuma.db"))) {
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
       const db = await getDb2();
       const stmt = db.prepare(
         `SELECT COUNT(*) FROM known_gotchas WHERE status = 'resolved' AND file_path LIKE ?`
       );
-      stmt.bind([`%${path18.basename(filePath)}%`]);
+      stmt.bind([`%${path20.basename(filePath)}%`]);
       const found = stmt.step();
       const count = found ? Number(stmt.getAsObject()["COUNT(*)"]) : 0;
       stmt.free();
@@ -7964,7 +8328,7 @@ async function getRelevantContext(filePath, goal) {
   } catch {
   }
   if (gotchas.length > 0) {
-    const scopeHint = path18.basename(path18.dirname(filePath)) || "current change";
+    const scopeHint = path20.basename(path20.dirname(filePath)) || "current change";
     parts.push(
       `\u2705 AFTER editing, verify: kuma_safety({ action: "verify", scope: "${scopeHint}" })`
     );
@@ -7980,11 +8344,11 @@ async function getRelevantContext(filePath, goal) {
 async function getFileSummary2(filePath) {
   try {
     const root = getProjectRoot();
-    const dbFile = path18.join(root, ".kuma", "kuma.db");
-    if (!fs15.existsSync(dbFile)) return null;
+    const dbFile = path20.join(root, ".kuma", "kuma.db");
+    if (!fs17.existsSync(dbFile)) return null;
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
     const db = await getDb2();
-    const base = path18.basename(filePath);
+    const base = path20.basename(filePath);
     const stmt = db.prepare(`
       SELECT
         (SELECT COUNT(*) FROM known_gotchas WHERE status = 'active' AND (file_path = ? OR file_path LIKE ?)) as active_gotchas,
@@ -8018,9 +8382,9 @@ function parseHookInput(raw) {
     const root = data && typeof data === "object" ? data : {};
     const ti = root.tool_input && typeof root.tool_input === "object" ? root.tool_input : {};
     const args = root.args && typeof root.args === "object" ? root.args : {};
-    const paths = /* @__PURE__ */ new Set();
+    const paths2 = /* @__PURE__ */ new Set();
     const add = (p) => {
-      if (typeof p === "string" && p.trim()) paths.add(p.trim());
+      if (typeof p === "string" && p.trim()) paths2.add(p.trim());
     };
     add(ti.file_path);
     add(ti.new_file_path);
@@ -8038,7 +8402,7 @@ function parseHookInput(raw) {
     add(args.file);
     const cmd = (typeof ti.command === "string" ? ti.command : void 0) ?? (typeof root.command === "string" ? root.command : void 0) ?? (typeof root.commandline === "string" ? root.commandline : void 0) ?? (typeof args.command === "string" ? args.command : void 0);
     const goal = (typeof ti.goal === "string" ? ti.goal : void 0) ?? (typeof root.goal === "string" ? root.goal : void 0);
-    const out = { filePaths: [...paths] };
+    const out = { filePaths: [...paths2] };
     if (goal) out.goal = goal;
     if (cmd) out.command = cmd;
     return out;
@@ -8076,9 +8440,9 @@ async function getCommandContext(command) {
 }
 function loadHookState(root) {
   try {
-    const fp = path18.join(root, HOOK_STATE_FILE);
-    if (fs15.existsSync(fp)) {
-      return JSON.parse(fs15.readFileSync(fp, "utf-8"));
+    const fp = path20.join(root, HOOK_STATE_FILE);
+    if (fs17.existsSync(fp)) {
+      return JSON.parse(fs17.readFileSync(fp, "utf-8"));
     }
   } catch {
   }
@@ -8086,10 +8450,10 @@ function loadHookState(root) {
 }
 function saveHookState(root, state) {
   try {
-    const fp = path18.join(root, HOOK_STATE_FILE);
-    const dir = path18.dirname(fp);
-    if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
-    fs15.writeFileSync(fp, JSON.stringify(state), "utf-8");
+    const fp = path20.join(root, HOOK_STATE_FILE);
+    const dir = path20.dirname(fp);
+    if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
+    fs17.writeFileSync(fp, JSON.stringify(state), "utf-8");
   } catch {
   }
 }
@@ -8123,7 +8487,7 @@ async function trackFileEditLoop(filePath) {
   saveHookState(root, state);
   if (recorded) {
     try {
-      if (!fs15.existsSync(path18.join(root, ".kuma", "kuma.db"))) return entry.count;
+      if (!fs17.existsSync(path20.join(root, ".kuma", "kuma.db"))) return entry.count;
       const { addGotcha: addGotcha2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
       await addGotcha2({
         filePath,
@@ -8177,8 +8541,8 @@ __export(kumaGotchas_exports, {
   syncGotchasToDb: () => syncGotchasToDb,
   tokenizeForSimilarity: () => tokenizeForSimilarity
 });
-import fs16 from "fs";
-import path19 from "path";
+import fs18 from "fs";
+import path21 from "path";
 async function ensureGotchasSchema() {
   const db = await getDb();
   db.exec(`
@@ -8600,8 +8964,8 @@ async function getActiveGotchasForCommand(command) {
 }
 async function recordInjection(params) {
   try {
-    const fp = path19.join(getProjectRoot(), ".kuma", "injections.jsonl");
-    if (!fs16.existsSync(path19.dirname(fp))) fs16.mkdirSync(path19.dirname(fp), { recursive: true });
+    const fp = path21.join(getProjectRoot(), ".kuma", "injections.jsonl");
+    if (!fs18.existsSync(path21.dirname(fp))) fs18.mkdirSync(path21.dirname(fp), { recursive: true });
     const line = JSON.stringify({
       filePath: params.filePath || null,
       command: params.command || null,
@@ -8610,16 +8974,16 @@ async function recordInjection(params) {
       // conservative estimate: avoided re-research / re-discovery
       at: Date.now()
     });
-    fs16.appendFileSync(fp, line + "\n", "utf-8");
+    fs18.appendFileSync(fp, line + "\n", "utf-8");
   } catch {
   }
 }
 function getInjectionStats(hours = 24) {
   try {
-    const fp = path19.join(getProjectRoot(), ".kuma", "injections.jsonl");
-    if (!fs16.existsSync(fp)) return { count: 0, savedMs: 0 };
+    const fp = path21.join(getProjectRoot(), ".kuma", "injections.jsonl");
+    if (!fs18.existsSync(fp)) return { count: 0, savedMs: 0 };
     const cutoff = Date.now() - hours * 60 * 60 * 1e3;
-    const lines = fs16.readFileSync(fp, "utf-8").split("\n");
+    const lines = fs18.readFileSync(fp, "utf-8").split("\n");
     let count = 0;
     let savedMs = 0;
     for (const line of lines) {
@@ -8677,9 +9041,9 @@ async function getGotchasByStatus(status, limit = 20) {
 }
 function syncGotchaStatusToMarkdown(targetPaths, newStatus, reason) {
   try {
-    const mdPath = path19.join(getProjectRoot(), ".kuma", "KNOWN_GOTCHAS.md");
-    if (!fs16.existsSync(mdPath)) return false;
-    const content = fs16.readFileSync(mdPath, "utf-8");
+    const mdPath = path21.join(getProjectRoot(), ".kuma", "KNOWN_GOTCHAS.md");
+    if (!fs18.existsSync(mdPath)) return false;
+    const content = fs18.readFileSync(mdPath, "utf-8");
     const lines = content.split("\n");
     const normalizedTargets = targetPaths.map((p) => p.trim().toLowerCase()).filter(Boolean);
     if (normalizedTargets.length === 0) return false;
@@ -8696,9 +9060,9 @@ function syncGotchaStatusToMarkdown(targetPaths, newStatus, reason) {
           modified = true;
         }
         const headingFile = headingMatch[1].trim().toLowerCase();
-        const headingBase = path19.basename(headingFile);
+        const headingBase = path21.basename(headingFile);
         inMatchingSection = normalizedTargets.some(
-          (t) => headingFile.includes(t) || t.includes(headingFile) || headingBase === t || headingBase === path19.basename(t)
+          (t) => headingFile.includes(t) || t.includes(headingFile) || headingBase === t || headingBase === path21.basename(t)
         );
         sectionHasStatus = false;
         outputLines.push(line);
@@ -8720,7 +9084,7 @@ function syncGotchaStatusToMarkdown(targetPaths, newStatus, reason) {
       modified = true;
     }
     if (modified) {
-      fs16.writeFileSync(mdPath, outputLines.join("\n"), "utf-8");
+      fs18.writeFileSync(mdPath, outputLines.join("\n"), "utf-8");
     }
     return modified;
   } catch {
@@ -8861,24 +9225,24 @@ var kumaMaintenance_exports = {};
 __export(kumaMaintenance_exports, {
   maybeRunAutoCleanup: () => maybeRunAutoCleanup
 });
-import fs17 from "fs";
-import path20 from "path";
+import fs19 from "fs";
+import path22 from "path";
 async function maybeRunAutoCleanup() {
   try {
     const root = getProjectRoot();
-    const stateFile = path20.join(root, GC_STATE_FILE);
+    const stateFile = path22.join(root, GC_STATE_FILE);
     const now = Date.now();
     let lastRun = 0;
-    if (fs17.existsSync(stateFile)) {
+    if (fs19.existsSync(stateFile)) {
       try {
-        lastRun = JSON.parse(fs17.readFileSync(stateFile, "utf-8")).lastRun || 0;
+        lastRun = JSON.parse(fs19.readFileSync(stateFile, "utf-8")).lastRun || 0;
       } catch {
         lastRun = 0;
       }
     }
     if (now - lastRun < GC_INTERVAL_MS) return "";
-    fs17.mkdirSync(path20.dirname(stateFile), { recursive: true });
-    fs17.writeFileSync(stateFile, JSON.stringify({ lastRun: now }), "utf-8");
+    fs19.mkdirSync(path22.dirname(stateFile), { recursive: true });
+    fs19.writeFileSync(stateFile, JSON.stringify({ lastRun: now }), "utf-8");
     const { syncGotchasToDb: syncGotchasToDb2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
     await syncGotchasToDb2();
     const { runGarbageCollection: runGarbageCollection2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
@@ -8914,22 +9278,22 @@ __export(kumaPathRules_exports, {
   loadPathRules: () => loadPathRules,
   matchRulePath: () => matchRulePath
 });
-import fs18 from "fs";
-import path21 from "path";
+import fs20 from "fs";
+import path23 from "path";
 function rulesDir() {
-  return path21.join(getProjectRoot(), RULES_DIR);
+  return path23.join(getProjectRoot(), RULES_DIR);
 }
 function ensureRulesDir() {
   try {
     const dir = rulesDir();
-    if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
+    if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
   } catch {
   }
 }
 function parseRuleFile(filePath) {
   try {
-    const raw = fs18.readFileSync(filePath, "utf-8");
-    const id = path21.basename(filePath, ".md");
+    const raw = fs20.readFileSync(filePath, "utf-8");
+    const id = path23.basename(filePath, ".md");
     const fm = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
     if (!fm) {
       return { id, description: id, paths: ["*"], content: raw.trim(), filePath };
@@ -8937,15 +9301,15 @@ function parseRuleFile(filePath) {
     const meta = fm[1];
     const body = fm[2].trim();
     const description = meta.match(/description:\s*(.+)/)?.[1]?.trim() || id;
-    const paths = [];
+    const paths2 = [];
     const pathSection = meta.match(/paths:\s*\r?\n([\s\S]*?)(?=\r?\n\S|$)/);
     if (pathSection) {
       for (const line of pathSection[1].split("\n")) {
         const m = line.match(/^\s*-\s*['"]?([^'"]+)['"]?\s*$/);
-        if (m) paths.push(m[1].trim());
+        if (m) paths2.push(m[1].trim());
       }
     }
-    return { id, description, paths: paths.length ? paths : ["*"], content: body, filePath };
+    return { id, description, paths: paths2.length ? paths2 : ["*"], content: body, filePath };
   } catch {
     return null;
   }
@@ -8954,7 +9318,7 @@ function loadPathRules() {
   ensureRulesDir();
   try {
     const dir = rulesDir();
-    return fs18.readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => parseRuleFile(path21.join(dir, f))).filter((r) => r !== null);
+    return fs20.readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => parseRuleFile(path23.join(dir, f))).filter((r) => r !== null);
   } catch {
     return [];
   }
@@ -9042,8 +9406,8 @@ __export(kumaFlowCache_exports, {
   getFreshDomainFlow: () => getFreshDomainFlow,
   getHopsForDomain: () => getHopsForDomain
 });
-import fs19 from "fs";
-import path22 from "path";
+import fs21 from "fs";
+import path24 from "path";
 async function getFlowFreshness(domain) {
   try {
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
@@ -9078,26 +9442,26 @@ async function getFlowFreshness(domain) {
 }
 function resolveImport(fromFile, spec) {
   const root = getProjectRoot();
-  const fromDir = path22.dirname(fromFile);
+  const fromDir = path24.dirname(fromFile);
   const candidates = [];
   if (spec.startsWith(".")) {
-    const abs = path22.resolve(fromDir, spec);
+    const abs = path24.resolve(fromDir, spec);
     candidates.push(abs);
   } else {
-    candidates.push(path22.join(root, spec));
+    candidates.push(path24.join(root, spec));
   }
   for (const c of candidates) {
     for (const ext of SOURCE_EXTENSIONS) {
       const withExt = `${c}${ext}`;
-      if (fs19.existsSync(withExt)) return path22.relative(root, withExt);
-      if (fs19.existsSync(c) && fs19.statSync(c).isDirectory()) {
-        const idx = path22.join(c, "index") + ext;
-        if (fs19.existsSync(idx)) return path22.relative(root, idx);
+      if (fs21.existsSync(withExt)) return path24.relative(root, withExt);
+      if (fs21.existsSync(c) && fs21.statSync(c).isDirectory()) {
+        const idx = path24.join(c, "index") + ext;
+        if (fs21.existsSync(idx)) return path24.relative(root, idx);
       }
     }
-    if (fs19.existsSync(c)) {
+    if (fs21.existsSync(c)) {
       try {
-        if (fs19.statSync(c).isFile()) return path22.relative(root, c);
+        if (fs21.statSync(c).isFile()) return path24.relative(root, c);
       } catch {
       }
     }
@@ -9106,13 +9470,13 @@ function resolveImport(fromFile, spec) {
 }
 function deriveHopsFromImports(entryFile, maxHops = 6) {
   const root = getProjectRoot();
-  const absEntry = path22.isAbsolute(entryFile) ? entryFile : path22.resolve(root, entryFile);
-  if (!fs19.existsSync(absEntry)) return [];
+  const absEntry = path24.isAbsolute(entryFile) ? entryFile : path24.resolve(root, entryFile);
+  if (!fs21.existsSync(absEntry)) return [];
   const hops = [];
   const seen = /* @__PURE__ */ new Set([entryFile]);
-  const fromName = path22.basename(absEntry);
+  const fromName = path24.basename(absEntry);
   try {
-    const lines = fs19.readFileSync(absEntry, "utf-8").split("\n");
+    const lines = fs21.readFileSync(absEntry, "utf-8").split("\n");
     for (const line of lines) {
       if (hops.length >= maxHops) break;
       const spec = matchImportPath(line);
@@ -9122,9 +9486,9 @@ function deriveHopsFromImports(entryFile, maxHops = 6) {
       seen.add(resolved);
       hops.push({
         from: fromName,
-        to: path22.basename(resolved),
+        to: path24.basename(resolved),
         relation: "imports",
-        description: `${fromName} imports ${path22.basename(resolved)}`
+        description: `${fromName} imports ${path24.basename(resolved)}`
       });
     }
   } catch {
@@ -9187,9 +9551,9 @@ async function getHopsForDomain(domain) {
   }
   try {
     const root = getProjectRoot();
-    const archPath = path22.join(root, ".kuma", "ARCHITECTURE_FLOW.md");
-    if (fs19.existsSync(archPath)) {
-      const content = fs19.readFileSync(archPath, "utf-8");
+    const archPath = path24.join(root, ".kuma", "ARCHITECTURE_FLOW.md");
+    if (fs21.existsSync(archPath)) {
+      const content = fs21.readFileSync(archPath, "utf-8");
       const lines = content.split("\n");
       for (const line of lines) {
         const domMatch = line.match(new RegExp(`domain:\\s*${escapeRegex(domain)}\\s*\\|\\s*hops:\\s*(.+)`, "i"));
@@ -9234,7 +9598,7 @@ Record one with kuma_memory({ action: 'arch_flow', content: 'domain: ${domain} |
             hops: derivedHops,
             filePaths: freshness.filePaths
           });
-          lines.push(`\u2705 Re-derived ${derivedHops.length} hop(s) from ${path22.basename(entry)} \u2014 cache refreshed.`);
+          lines.push(`\u2705 Re-derived ${derivedHops.length} hop(s) from ${path24.basename(entry)} \u2014 cache refreshed.`);
           hops.splice(0, hops.length, ...derivedHops);
         } else {
           lines.push("\u26A0\uFE0F No imports to follow \u2014 cache left as-is (record hops manually if needed).");
@@ -9287,10 +9651,10 @@ __export(packageBriefs_exports, {
   readBrief: () => readBrief,
   refreshPackageBriefs: () => refreshPackageBriefs
 });
-import fs20 from "fs";
-import path23 from "path";
+import fs22 from "fs";
+import path25 from "path";
 function briefsDir(root) {
-  return path23.join(root || getProjectRoot(), BRIEFS_DIR);
+  return path25.join(root || getProjectRoot(), BRIEFS_DIR);
 }
 function slug(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 60) || "root";
@@ -9354,13 +9718,13 @@ async function refreshPackageBriefs() {
   const dir = briefsDir(root);
   try {
     const ws = await getWorkspaceInfo(root);
-    if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
+    if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
     let count = 0;
     const pkgs = ws.isWorkspace ? ws.packages : [{ name: "root", path: ".", isRoot: true }];
     for (const p of pkgs.slice(0, 20)) {
       const pkg = p;
       const content = await buildPackageBrief(pkg.name, pkg.path, root);
-      fs20.writeFileSync(path23.join(dir, `${slug(pkg.name)}.md`), content, "utf-8");
+      fs22.writeFileSync(path25.join(dir, `${slug(pkg.name)}.md`), content, "utf-8");
       count++;
     }
     return { count, dir };
@@ -9370,9 +9734,9 @@ async function refreshPackageBriefs() {
 }
 function briefFreshness(pkgName) {
   try {
-    const fp = path23.join(briefsDir(), `${slug(pkgName)}.md`);
-    if (!fs20.existsSync(fp)) return { exists: false, fresh: false, age: "missing" };
-    const ageMs = Date.now() - fs20.statSync(fp).mtimeMs;
+    const fp = path25.join(briefsDir(), `${slug(pkgName)}.md`);
+    if (!fs22.existsSync(fp)) return { exists: false, fresh: false, age: "missing" };
+    const ageMs = Date.now() - fs22.statSync(fp).mtimeMs;
     return { exists: true, fresh: !isStale(Date.now() - ageMs, MAP_TTL_MS), age: formatAge(Date.now() - ageMs) };
   } catch {
     return { exists: false, fresh: false, age: "missing" };
@@ -9380,9 +9744,9 @@ function briefFreshness(pkgName) {
 }
 function readBrief(pkgName, maxChars = 1200) {
   try {
-    const fp = path23.join(briefsDir(), `${slug(pkgName)}.md`);
-    if (!fs20.existsSync(fp)) return null;
-    const content = fs20.readFileSync(fp, "utf-8");
+    const fp = path25.join(briefsDir(), `${slug(pkgName)}.md`);
+    if (!fs22.existsSync(fp)) return null;
+    const content = fs22.readFileSync(fp, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n\u2026(truncated)" : content;
   } catch {
     return null;
@@ -9411,8 +9775,8 @@ __export(kumaSearch_exports, {
   formatHybridResults: () => formatHybridResults,
   hybridSearch: () => hybridSearch
 });
-import fs22 from "fs";
-import path25 from "path";
+import fs24 from "fs";
+import path27 from "path";
 function expandQueryTerms(query) {
   const terms = query.toLowerCase().split(/[\s_-]+/).filter((t) => t.length > 2);
   const expanded = /* @__PURE__ */ new Map();
@@ -9475,13 +9839,13 @@ async function buildSearchVectors() {
   }
   try {
     const root = getProjectRoot();
-    const memDir = path25.join(root, ".kuma", "memories");
-    if (fs22.existsSync(memDir)) {
-      const files = fs22.readdirSync(memDir).filter((f) => f.endsWith(".md")).slice(0, SCALE_LIMITS.maxMemoryFiles);
+    const memDir = path27.join(root, ".kuma", "memories");
+    if (fs24.existsSync(memDir)) {
+      const files = fs24.readdirSync(memDir).filter((f) => f.endsWith(".md")).slice(0, SCALE_LIMITS.maxMemoryFiles);
       for (const file of files) {
         try {
-          const fullPath = path25.join(memDir, file);
-          const content = fs22.readFileSync(fullPath, "utf-8");
+          const fullPath = path27.join(memDir, file);
+          const content = fs24.readFileSync(fullPath, "utf-8");
           const text = content.toLowerCase();
           const rawTerms = extractTerms(text);
           const termCounts = /* @__PURE__ */ new Map();
@@ -9492,7 +9856,7 @@ async function buildSearchVectors() {
             terms: termCounts,
             source: file.replace(/\.md$/, ""),
             sourceType: "memory",
-            recency: recencyScore(Math.floor(fs22.statSync(fullPath).mtimeMs / 1e3))
+            recency: recencyScore(Math.floor(fs24.statSync(fullPath).mtimeMs / 1e3))
           });
         } catch {
         }
@@ -9809,14 +10173,14 @@ __export(architectureGuard_exports, {
   detectWorkspaceCircularDeps: () => detectWorkspaceCircularDeps,
   loadArchitectureRules: () => loadArchitectureRules
 });
-import fs26 from "fs";
-import path29 from "path";
-import fastGlob4 from "fast-glob";
+import fs28 from "fs";
+import path31 from "path";
+import fastGlob5 from "fast-glob";
 function loadArchitectureRules(root) {
-  const rulesPath = path29.join(root, ".kuma", "architecture.json");
-  if (fs26.existsSync(rulesPath)) {
+  const rulesPath = path31.join(root, ".kuma", "architecture.json");
+  if (fs28.existsSync(rulesPath)) {
     try {
-      const data = JSON.parse(fs26.readFileSync(rulesPath, "utf-8"));
+      const data = JSON.parse(fs28.readFileSync(rulesPath, "utf-8"));
       if (Array.isArray(data.rules)) {
         return data.rules;
       }
@@ -9869,7 +10233,7 @@ async function checkArchitectureBoundaries(filesToCheck, customRoot) {
   }
   let targetFiles = filesToCheck;
   if (!targetFiles || targetFiles.length === 0) {
-    targetFiles = await fastGlob4(["**/*.{ts,tsx,js,jsx,mjs,cjs}"], {
+    targetFiles = await fastGlob5(["**/*.{ts,tsx,js,jsx,mjs,cjs}"], {
       cwd: root,
       ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**", "**/.kuma/**"],
       onlyFiles: true
@@ -9878,11 +10242,11 @@ async function checkArchitectureBoundaries(filesToCheck, customRoot) {
   const customRules = loadArchitectureRules(root);
   const importRegex = /(?:import|export\s+.*from|require\s*\()\s*['"]([^'"]+)['"]/g;
   for (const file of targetFiles) {
-    const fullPath = path29.isAbsolute(file) ? file : path29.join(root, file);
-    if (!fs26.existsSync(fullPath)) continue;
+    const fullPath = path31.isAbsolute(file) ? file : path31.join(root, file);
+    if (!fs28.existsSync(fullPath)) continue;
     let content = "";
     try {
-      content = fs26.readFileSync(fullPath, "utf-8");
+      content = fs28.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -9892,7 +10256,7 @@ async function checkArchitectureBoundaries(filesToCheck, customRoot) {
       const importPath = match[1];
       if (wsInfo.isWorkspace && currentPkg && !currentPkg.isRoot) {
         if (importPath.startsWith("../") && (importPath.includes("/src/") || importPath.includes("/dist/"))) {
-          const resolvedTarget = path29.normalize(path29.resolve(path29.dirname(fullPath), importPath));
+          const resolvedTarget = path31.normalize(path31.resolve(path31.dirname(fullPath), importPath));
           const targetPkg = findPackageForFile(resolvedTarget, wsInfo);
           if (targetPkg && targetPkg.name !== currentPkg.name) {
             violations.push({
@@ -9941,26 +10305,26 @@ __export(docDrift_exports, {
   formatDocDrift: () => formatDocDrift,
   scanDocDrift: () => scanDocDrift
 });
-import fs27 from "fs";
-import path30 from "path";
-import { execSync as execSync8 } from "child_process";
+import fs29 from "fs";
+import path32 from "path";
+import { execSync as execSync9 } from "child_process";
 function collectDocFiles(root) {
   const cwd = root || getProjectRoot();
   const out = [];
   const pushIfMd = (dir, rel) => {
     try {
-      for (const f of fs27.readdirSync(dir)) {
+      for (const f of fs29.readdirSync(dir)) {
         if (out.length >= MAX_DOCS) return;
-        const full = path30.join(dir, f);
+        const full = path32.join(dir, f);
         try {
-          if (fs27.statSync(full).isFile() && /\.md$/i.test(f)) out.push(rel(f));
+          if (fs29.statSync(full).isFile() && /\.md$/i.test(f)) out.push(rel(f));
         } catch {
         }
       }
     } catch {
     }
   };
-  pushIfMd(path30.join(cwd, "docs"), (f) => path30.join("docs", f));
+  pushIfMd(path32.join(cwd, "docs"), (f) => path32.join("docs", f));
   pushIfMd(cwd, (f) => f);
   return out;
 }
@@ -10002,7 +10366,7 @@ function codeContainsBatch(root, needles) {
     const chunk = clean.slice(i, i + 50);
     try {
       const args = chunk.map((n) => `-e "${n}"`).join(" ");
-      const out = execSync8(
+      const out = execSync9(
         `grep -rn --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.py" --include="*.go" --include="*.rs" --include="*.json" --include="*.yml" --include="*.yaml" --include="*.toml" --include=".env*" -F ${args} . 2>/dev/null | grep -v node_modules | grep -v "/dist/" | grep -v "/.git/" | grep -v "/.kuma/" | head -100`,
         { cwd: root, encoding: "utf-8", timeout: 8e3, maxBuffer: 256 * 1024 }
       ).trim();
@@ -10022,7 +10386,7 @@ function scanDocDrift(root) {
   let claims = [];
   for (const rel of collectDocFiles(cwd)) {
     try {
-      const content = fs27.readFileSync(path30.join(cwd, rel), "utf-8");
+      const content = fs29.readFileSync(path32.join(cwd, rel), "utf-8");
       if (isExemptDoc(rel, content)) {
         skipped.push(rel);
         continue;
@@ -10193,27 +10557,27 @@ __export(kumaCheckpoint_exports, {
   pruneCheckpoints: () => pruneCheckpoints,
   rollbackToCheckpoint: () => rollbackToCheckpoint
 });
-import fs28 from "fs";
-import path31 from "path";
+import fs30 from "fs";
+import path33 from "path";
 async function createCheckpoint(label, description) {
   try {
     const root = getProjectRoot();
-    const cpDir = path31.join(root, CHECKPOINT_DIR, sanitizeLabel(label));
-    if (fs28.existsSync(cpDir)) {
+    const cpDir = path33.join(root, CHECKPOINT_DIR, sanitizeLabel(label));
+    if (fs30.existsSync(cpDir)) {
       return `\u26A0\uFE0F Checkpoint "${label}" already exists. Use a different label or remove it first.`;
     }
-    fs28.mkdirSync(cpDir, { recursive: true });
+    fs30.mkdirSync(cpDir, { recursive: true });
     let gitHead;
     let isGitClean = false;
     try {
-      const { execSync: execSync9 } = await import("child_process");
-      gitHead = execSync9("git rev-parse HEAD", {
+      const { execSync: execSync10 } = await import("child_process");
+      gitHead = execSync10("git rev-parse HEAD", {
         cwd: root,
         encoding: "utf-8",
         timeout: 3e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      const statusOut = execSync9("git status --porcelain", {
+      const statusOut = execSync10("git status --porcelain", {
         cwd: root,
         encoding: "utf-8",
         timeout: 3e3,
@@ -10224,8 +10588,8 @@ async function createCheckpoint(label, description) {
     }
     const candidatePaths = /* @__PURE__ */ new Set();
     try {
-      const { execSync: execSync9 } = await import("child_process");
-      const gitOut = execSync9("git status --porcelain", {
+      const { execSync: execSync10 } = await import("child_process");
+      const gitOut = execSync10("git status --porcelain", {
         cwd: root,
         encoding: "utf-8",
         timeout: 4e3,
@@ -10268,15 +10632,15 @@ async function createCheckpoint(label, description) {
     }
     const files = [];
     for (const fp of candidatePaths) {
-      const fullPath = path31.resolve(root, fp);
+      const fullPath = path33.resolve(root, fp);
       try {
-        if (fs28.existsSync(fullPath) && fs28.statSync(fullPath).isFile()) {
-          const content = fs28.readFileSync(fullPath, "utf-8");
+        if (fs30.existsSync(fullPath) && fs30.statSync(fullPath).isFile()) {
+          const content = fs30.readFileSync(fullPath, "utf-8");
           const hash = simpleHash2(content);
-          const snapFile = path31.join(cpDir, "files", `${fp}.kuma-snap`);
-          const fileDir = path31.dirname(snapFile);
-          if (!fs28.existsSync(fileDir)) fs28.mkdirSync(fileDir, { recursive: true });
-          fs28.writeFileSync(snapFile, content, "utf-8");
+          const snapFile = path33.join(cpDir, "files", `${fp}.kuma-snap`);
+          const fileDir = path33.dirname(snapFile);
+          if (!fs30.existsSync(fileDir)) fs30.mkdirSync(fileDir, { recursive: true });
+          fs30.writeFileSync(snapFile, content, "utf-8");
           files.push({ path: fp, hash });
         }
       } catch {
@@ -10284,7 +10648,7 @@ async function createCheckpoint(label, description) {
     }
     const db = await getDb();
     const dbData = db.export();
-    fs28.writeFileSync(path31.join(cpDir, "kuma.db"), Buffer.from(dbData));
+    fs30.writeFileSync(path33.join(cpDir, "kuma.db"), Buffer.from(dbData));
     const manifest = {
       label,
       timestamp: Date.now(),
@@ -10294,8 +10658,8 @@ async function createCheckpoint(label, description) {
       dbSnapshot: true,
       description
     };
-    fs28.writeFileSync(
-      path31.join(cpDir, "manifest.json"),
+    fs30.writeFileSync(
+      path33.join(cpDir, "manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
     );
@@ -10323,29 +10687,29 @@ async function createCheckpoint(label, description) {
 async function rollbackToCheckpoint(label) {
   try {
     const root = getProjectRoot();
-    const cpDir = path31.join(root, CHECKPOINT_DIR, sanitizeLabel(label));
-    const manifestPath = path31.join(cpDir, "manifest.json");
-    if (!fs28.existsSync(manifestPath)) {
+    const cpDir = path33.join(root, CHECKPOINT_DIR, sanitizeLabel(label));
+    const manifestPath = path33.join(cpDir, "manifest.json");
+    if (!fs30.existsSync(manifestPath)) {
       return `\u274C Checkpoint "${label}" not found. Available checkpoints:
 
 ${listCheckpoints()}`;
     }
     const manifest = JSON.parse(
-      fs28.readFileSync(manifestPath, "utf-8")
+      fs30.readFileSync(manifestPath, "utf-8")
     );
     let restored = 0;
     let failed = 0;
     for (const f of manifest.files) {
-      const snapPath = path31.join(cpDir, "files", `${f.path}.kuma-snap`);
-      const legacyPath = path31.join(cpDir, "files", f.path);
-      const sourcePath = fs28.existsSync(snapPath) ? snapPath : legacyPath;
-      if (fs28.existsSync(sourcePath)) {
+      const snapPath = path33.join(cpDir, "files", `${f.path}.kuma-snap`);
+      const legacyPath = path33.join(cpDir, "files", f.path);
+      const sourcePath = fs30.existsSync(snapPath) ? snapPath : legacyPath;
+      if (fs30.existsSync(sourcePath)) {
         try {
-          const content = fs28.readFileSync(sourcePath, "utf-8");
-          const targetPath = path31.resolve(root, f.path);
-          const targetDir = path31.dirname(targetPath);
-          if (!fs28.existsSync(targetDir)) fs28.mkdirSync(targetDir, { recursive: true });
-          fs28.writeFileSync(targetPath, content, "utf-8");
+          const content = fs30.readFileSync(sourcePath, "utf-8");
+          const targetPath = path33.resolve(root, f.path);
+          const targetDir = path33.dirname(targetPath);
+          if (!fs30.existsSync(targetDir)) fs30.mkdirSync(targetDir, { recursive: true });
+          fs30.writeFileSync(targetPath, content, "utf-8");
           restored++;
         } catch {
           failed++;
@@ -10354,8 +10718,8 @@ ${listCheckpoints()}`;
     }
     if (manifest.files.length === 0 && manifest.gitHead) {
       try {
-        const { execSync: execSync9 } = await import("child_process");
-        execSync9(`git checkout ${manifest.gitHead} -- .`, {
+        const { execSync: execSync10 } = await import("child_process");
+        execSync10(`git checkout ${manifest.gitHead} -- .`, {
           cwd: root,
           encoding: "utf-8",
           timeout: 8e3,
@@ -10366,12 +10730,12 @@ ${listCheckpoints()}`;
         failed++;
       }
     }
-    const dbSnapshotPath = path31.join(cpDir, "kuma.db");
-    if (fs28.existsSync(dbSnapshotPath)) {
-      const kumaDir = path31.join(root, ".kuma");
-      const dbPath = path31.join(kumaDir, "kuma.db");
-      const snapshotData = fs28.readFileSync(dbSnapshotPath);
-      fs28.writeFileSync(dbPath, snapshotData);
+    const dbSnapshotPath = path33.join(cpDir, "kuma.db");
+    if (fs30.existsSync(dbSnapshotPath)) {
+      const kumaDir = path33.join(root, ".kuma");
+      const dbPath = path33.join(kumaDir, "kuma.db");
+      const snapshotData = fs30.readFileSync(dbSnapshotPath);
+      fs30.writeFileSync(dbPath, snapshotData);
       resetDbInstance();
     }
     sessionMemory.recordToolCall("kuma_checkpoint_rollback", {
@@ -10396,18 +10760,18 @@ ${listCheckpoints()}`;
 function listCheckpoints() {
   try {
     const root = getProjectRoot();
-    const cpDir = path31.join(root, CHECKPOINT_DIR);
-    if (!fs28.existsSync(cpDir)) {
+    const cpDir = path33.join(root, CHECKPOINT_DIR);
+    if (!fs30.existsSync(cpDir)) {
       return "\u{1F4ED} No checkpoints found. Use kuma_safety({ action: 'checkpoint', label: 'pre-feature-x' }) to create one.";
     }
-    const entries = fs28.readdirSync(cpDir);
+    const entries = fs30.readdirSync(cpDir);
     const checkpoints = [];
     for (const entry of entries) {
-      const manifestPath = path31.join(cpDir, entry, "manifest.json");
-      if (fs28.existsSync(manifestPath)) {
+      const manifestPath = path33.join(cpDir, entry, "manifest.json");
+      if (fs30.existsSync(manifestPath)) {
         try {
           const manifest = JSON.parse(
-            fs28.readFileSync(manifestPath, "utf-8")
+            fs30.readFileSync(manifestPath, "utf-8")
           );
           checkpoints.push({ label: entry, manifest });
         } catch {
@@ -10439,12 +10803,12 @@ function listCheckpoints() {
 function pruneCheckpoints(keep = 5) {
   try {
     const root = getProjectRoot();
-    const cpDir = path31.join(root, CHECKPOINT_DIR);
-    if (!fs28.existsSync(cpDir)) return "\u{1F4ED} No checkpoints to prune.";
-    const entries = fs28.readdirSync(cpDir).map((e) => ({ name: e, time: fs28.statSync(path31.join(cpDir, e)).mtimeMs })).sort((a, b) => b.time - a.time);
+    const cpDir = path33.join(root, CHECKPOINT_DIR);
+    if (!fs30.existsSync(cpDir)) return "\u{1F4ED} No checkpoints to prune.";
+    const entries = fs30.readdirSync(cpDir).map((e) => ({ name: e, time: fs30.statSync(path33.join(cpDir, e)).mtimeMs })).sort((a, b) => b.time - a.time);
     let removed = 0;
     for (let i = keep; i < entries.length; i++) {
-      fs28.rmSync(path31.join(cpDir, entries[i].name), { recursive: true, force: true });
+      fs30.rmSync(path33.join(cpDir, entries[i].name), { recursive: true, force: true });
       removed++;
     }
     return removed > 0 ? `\u{1F9F9} Pruned **${removed} old checkpoint(s)**. Kept ${Math.min(keep, entries.length)} most recent.` : "\u2705 No checkpoints needed pruning.";
@@ -10469,9 +10833,9 @@ function isRiskyEditPath(filePath) {
 }
 function loadAutoCpDone(root) {
   try {
-    const fp = path31.join(root, AUTO_CP_STATE);
-    if (fs28.existsSync(fp)) {
-      const parsed = JSON.parse(fs28.readFileSync(fp, "utf-8"));
+    const fp = path33.join(root, AUTO_CP_STATE);
+    if (fs30.existsSync(fp)) {
+      const parsed = JSON.parse(fs30.readFileSync(fp, "utf-8"));
       return parsed?.autoCheckpoints ?? {};
     }
   } catch {
@@ -10480,10 +10844,10 @@ function loadAutoCpDone(root) {
 }
 function saveAutoCpDone(root, done) {
   try {
-    const fp = path31.join(root, AUTO_CP_STATE);
-    const parsed = fs28.existsSync(fp) ? JSON.parse(fs28.readFileSync(fp, "utf-8")) : {};
+    const fp = path33.join(root, AUTO_CP_STATE);
+    const parsed = fs30.existsSync(fp) ? JSON.parse(fs30.readFileSync(fp, "utf-8")) : {};
     parsed.autoCheckpoints = done;
-    fs28.writeFileSync(fp, JSON.stringify(parsed), "utf-8");
+    fs30.writeFileSync(fp, JSON.stringify(parsed), "utf-8");
   } catch {
   }
 }
@@ -10493,14 +10857,14 @@ function maybeAutoCheckpoint(filePath) {
     const root = getProjectRoot();
     const done = loadAutoCpDone(root);
     if (done[filePath]) return null;
-    const abs = path31.isAbsolute(filePath) ? filePath : path31.join(root, filePath);
-    if (!fs28.existsSync(abs) || !fs28.statSync(abs).isFile()) return null;
-    const label = `auto-pre-${sanitizeLabel(path31.basename(filePath))}`;
-    const cpDir = path31.join(root, CHECKPOINT_DIR, label);
-    if (!fs28.existsSync(cpDir)) fs28.mkdirSync(cpDir, { recursive: true });
-    fs28.copyFileSync(abs, path31.join(cpDir, path31.basename(abs)));
-    fs28.writeFileSync(
-      path31.join(cpDir, "manifest.json"),
+    const abs = path33.isAbsolute(filePath) ? filePath : path33.join(root, filePath);
+    if (!fs30.existsSync(abs) || !fs30.statSync(abs).isFile()) return null;
+    const label = `auto-pre-${sanitizeLabel(path33.basename(filePath))}`;
+    const cpDir = path33.join(root, CHECKPOINT_DIR, label);
+    if (!fs30.existsSync(cpDir)) fs30.mkdirSync(cpDir, { recursive: true });
+    fs30.copyFileSync(abs, path33.join(cpDir, path33.basename(abs)));
+    fs30.writeFileSync(
+      path33.join(cpDir, "manifest.json"),
       JSON.stringify({
         label,
         timestamp: Date.now(),
@@ -10540,8 +10904,8 @@ __export(init_exports, {
   generateInitMdContent: () => generateInitMdContent,
   runInit: () => runInit
 });
-import fs29 from "fs";
-import path32 from "path";
+import fs31 from "fs";
+import path34 from "path";
 function configFilePath(type) {
   switch (type) {
     case "claude":
@@ -11175,21 +11539,21 @@ function handleOpencodeSecondary(root, results) {
     "",
     "\u{1F4D6} Full rules: `.kuma/init.md`"
   ].join("\n");
-  const skillPath = path32.resolve(root, ".agents", "skills", "kuma", "SKILL.md");
+  const skillPath = path34.resolve(root, ".agents", "skills", "kuma", "SKILL.md");
   if (!results.some((r) => r.filePath === ".agents/skills/kuma/SKILL.md")) {
     try {
-      const dir = path32.dirname(skillPath);
-      if (fs29.existsSync(skillPath)) {
-        const existing = fs29.readFileSync(skillPath, "utf-8");
+      const dir = path34.dirname(skillPath);
+      if (fs31.existsSync(skillPath)) {
+        const existing = fs31.readFileSync(skillPath, "utf-8");
         if (existing.includes("kuma-mcp")) {
           results.push({ type: "opencode", filePath: ".agents/skills/kuma/SKILL.md", action: "skipped" });
         } else {
-          fs29.writeFileSync(skillPath, existing.trimEnd() + "\n\n---\n\n" + opencodeContent, "utf-8");
+          fs31.writeFileSync(skillPath, existing.trimEnd() + "\n\n---\n\n" + opencodeContent, "utf-8");
           results.push({ type: "opencode", filePath: ".agents/skills/kuma/SKILL.md", action: "appended" });
         }
       } else {
-        if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-        fs29.writeFileSync(skillPath, opencodeContent, "utf-8");
+        if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+        fs31.writeFileSync(skillPath, opencodeContent, "utf-8");
         results.push({ type: "opencode", filePath: ".agents/skills/kuma/SKILL.md", action: "created" });
       }
     } catch (err) {
@@ -11201,21 +11565,21 @@ function handleOpencodeSecondary(root, results) {
       });
     }
   }
-  const opencodeSkillPath = path32.resolve(root, ".opencode", "skills", "kuma", "SKILL.md");
+  const opencodeSkillPath = path34.resolve(root, ".opencode", "skills", "kuma", "SKILL.md");
   if (!results.some((r) => r.filePath === ".opencode/skills/kuma/SKILL.md")) {
     try {
-      const dir = path32.dirname(opencodeSkillPath);
-      if (fs29.existsSync(opencodeSkillPath)) {
-        const existing = fs29.readFileSync(opencodeSkillPath, "utf-8");
+      const dir = path34.dirname(opencodeSkillPath);
+      if (fs31.existsSync(opencodeSkillPath)) {
+        const existing = fs31.readFileSync(opencodeSkillPath, "utf-8");
         if (existing.includes("kuma-mcp")) {
           results.push({ type: "opencode", filePath: ".opencode/skills/kuma/SKILL.md", action: "skipped" });
         } else {
-          fs29.writeFileSync(opencodeSkillPath, existing.trimEnd() + "\n\n---\n\n" + opencodeContent, "utf-8");
+          fs31.writeFileSync(opencodeSkillPath, existing.trimEnd() + "\n\n---\n\n" + opencodeContent, "utf-8");
           results.push({ type: "opencode", filePath: ".opencode/skills/kuma/SKILL.md", action: "appended" });
         }
       } else {
-        if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-        fs29.writeFileSync(opencodeSkillPath, opencodeContent, "utf-8");
+        if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+        fs31.writeFileSync(opencodeSkillPath, opencodeContent, "utf-8");
         results.push({ type: "opencode", filePath: ".opencode/skills/kuma/SKILL.md", action: "created" });
       }
     } catch (err) {
@@ -11227,21 +11591,21 @@ function handleOpencodeSecondary(root, results) {
       });
     }
   }
-  const pluginPath = path32.resolve(root, ".opencode", "plugins", "kuma.js");
+  const pluginPath = path34.resolve(root, ".opencode", "plugins", "kuma.js");
   if (!results.some((r) => r.filePath === ".opencode/plugins/kuma.js")) {
     try {
-      const dir = path32.dirname(pluginPath);
-      if (fs29.existsSync(pluginPath)) {
-        const existing = fs29.readFileSync(pluginPath, "utf-8");
+      const dir = path34.dirname(pluginPath);
+      if (fs31.existsSync(pluginPath)) {
+        const existing = fs31.readFileSync(pluginPath, "utf-8");
         if (existing.includes("KumaPlugin") || existing.includes("kuma")) {
           results.push({ type: "opencode", filePath: ".opencode/plugins/kuma.js", action: "skipped" });
         } else {
-          fs29.writeFileSync(pluginPath, existing.trimEnd() + "\n\n" + opencodePluginTemplate(), "utf-8");
+          fs31.writeFileSync(pluginPath, existing.trimEnd() + "\n\n" + opencodePluginTemplate(), "utf-8");
           results.push({ type: "opencode", filePath: ".opencode/plugins/kuma.js", action: "appended" });
         }
       } else {
-        if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-        fs29.writeFileSync(pluginPath, opencodePluginTemplate(), "utf-8");
+        if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+        fs31.writeFileSync(pluginPath, opencodePluginTemplate(), "utf-8");
         results.push({ type: "opencode", filePath: ".opencode/plugins/kuma.js", action: "created" });
       }
     } catch (err) {
@@ -11255,21 +11619,21 @@ function handleOpencodeSecondary(root, results) {
   }
 }
 function handleCodexSecondary(root, results) {
-  const tomlPath = path32.resolve(root, ".codex/config.toml");
+  const tomlPath = path34.resolve(root, ".codex/config.toml");
   if (results.some((r) => r.filePath === ".codex/config.toml")) return;
   try {
-    const dir = path32.dirname(tomlPath);
-    if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-    if (fs29.existsSync(tomlPath)) {
-      const existingContent = fs29.readFileSync(tomlPath, "utf-8");
+    const dir = path34.dirname(tomlPath);
+    if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+    if (fs31.existsSync(tomlPath)) {
+      const existingContent = fs31.readFileSync(tomlPath, "utf-8");
       if (existingContent.includes("kuma")) {
         results.push({ type: "codex", filePath: ".codex/config.toml", action: "skipped" });
         return;
       }
-      fs29.writeFileSync(tomlPath, existingContent.trimEnd() + "\n\n" + codexConfigTomlTemplate(), "utf-8");
+      fs31.writeFileSync(tomlPath, existingContent.trimEnd() + "\n\n" + codexConfigTomlTemplate(), "utf-8");
       results.push({ type: "codex", filePath: ".codex/config.toml", action: "appended" });
     } else {
-      fs29.writeFileSync(tomlPath, codexConfigTomlTemplate(), "utf-8");
+      fs31.writeFileSync(tomlPath, codexConfigTomlTemplate(), "utf-8");
       results.push({ type: "codex", filePath: ".codex/config.toml", action: "created" });
     }
   } catch (err) {
@@ -11282,11 +11646,11 @@ function handleCodexSecondary(root, results) {
   }
 }
 function handleQwenSecondary(root, results) {
-  const settingsPath = path32.resolve(root, "settings.json");
+  const settingsPath = path34.resolve(root, "settings.json");
   if (results.some((r) => r.filePath === "settings.json")) return;
   try {
-    if (fs29.existsSync(settingsPath)) {
-      const existingContent = fs29.readFileSync(settingsPath, "utf-8");
+    if (fs31.existsSync(settingsPath)) {
+      const existingContent = fs31.readFileSync(settingsPath, "utf-8");
       if (existingContent.includes("kuma")) {
         if (!existingContent.includes("_Generated by Kuma MCP_")) {
           try {
@@ -11294,7 +11658,7 @@ function handleQwenSecondary(root, results) {
             parsed.mcpServers = parsed.mcpServers || {};
             if (!parsed.mcpServers.kuma) {
               parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-              fs29.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+              fs31.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
               results.push({ type: "qwen", filePath: "settings.json", action: "appended" });
               return;
             }
@@ -11309,13 +11673,13 @@ function handleQwenSecondary(root, results) {
         parsed.mcpServers = parsed.mcpServers || {};
         if (!parsed.mcpServers.kuma) {
           parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-          fs29.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+          fs31.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
           results.push({ type: "qwen", filePath: "settings.json", action: "appended" });
         }
       } catch {
       }
     } else {
-      fs29.writeFileSync(settingsPath, qwenSettingsTemplate(), "utf-8");
+      fs31.writeFileSync(settingsPath, qwenSettingsTemplate(), "utf-8");
       results.push({ type: "qwen", filePath: "settings.json", action: "created" });
     }
   } catch (err) {
@@ -11417,12 +11781,12 @@ function getCombinedAgentsMd(selectedTypes) {
   return lines.join("\n");
 }
 function handleAntigravityMcpConfig(root, results) {
-  const mcpPath = path32.resolve(root, ".agents/mcp_config.json");
+  const mcpPath = path34.resolve(root, ".agents/mcp_config.json");
   if (results.some((r) => r.filePath === ".agents/mcp_config.json")) return;
   try {
-    const mcpDir = path32.dirname(mcpPath);
-    if (fs29.existsSync(mcpPath)) {
-      const existingContent = fs29.readFileSync(mcpPath, "utf-8");
+    const mcpDir = path34.dirname(mcpPath);
+    if (fs31.existsSync(mcpPath)) {
+      const existingContent = fs31.readFileSync(mcpPath, "utf-8");
       if (existingContent.includes("kuma")) {
         results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "skipped" });
         return;
@@ -11431,14 +11795,14 @@ function handleAntigravityMcpConfig(root, results) {
         const parsed = JSON.parse(existingContent);
         parsed.mcpServers = parsed.mcpServers || {};
         parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-        fs29.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+        fs31.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
         results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "appended" });
       } catch {
         results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "error", error: "Invalid JSON in existing mcp_config.json" });
       }
     } else {
-      if (!fs29.existsSync(mcpDir)) fs29.mkdirSync(mcpDir, { recursive: true });
-      fs29.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
+      if (!fs31.existsSync(mcpDir)) fs31.mkdirSync(mcpDir, { recursive: true });
+      fs31.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
       results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "created" });
     }
   } catch (err) {
@@ -11451,21 +11815,21 @@ function handleAntigravityMcpConfig(root, results) {
   }
 }
 function handleAntigravityRules(root, results) {
-  const rulePath = path32.resolve(root, ".agents", "rules", "kuma.md");
+  const rulePath = path34.resolve(root, ".agents", "rules", "kuma.md");
   if (results.some((r) => r.filePath === ".agents/rules/kuma.md")) return;
   try {
-    const dir = path32.dirname(rulePath);
-    if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-    if (fs29.existsSync(rulePath)) {
-      const existing = fs29.readFileSync(rulePath, "utf-8");
+    const dir = path34.dirname(rulePath);
+    if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+    if (fs31.existsSync(rulePath)) {
+      const existing = fs31.readFileSync(rulePath, "utf-8");
       if (existing.includes("Kuma MCP") || existing.includes("kuma-mcp")) {
         results.push({ type: "antigravity", filePath: ".agents/rules/kuma.md", action: "skipped" });
         return;
       }
-      fs29.writeFileSync(rulePath, existing.trimEnd() + "\n\n---\n\n" + antigravityRuleTemplate(), "utf-8");
+      fs31.writeFileSync(rulePath, existing.trimEnd() + "\n\n---\n\n" + antigravityRuleTemplate(), "utf-8");
       results.push({ type: "antigravity", filePath: ".agents/rules/kuma.md", action: "appended" });
     } else {
-      fs29.writeFileSync(rulePath, antigravityRuleTemplate(), "utf-8");
+      fs31.writeFileSync(rulePath, antigravityRuleTemplate(), "utf-8");
       results.push({ type: "antigravity", filePath: ".agents/rules/kuma.md", action: "created" });
     }
   } catch (err) {
@@ -11478,19 +11842,19 @@ function handleAntigravityRules(root, results) {
   }
 }
 function handleGeminiMd(root, results) {
-  const geminiPath = path32.resolve(root, "GEMINI.md");
+  const geminiPath = path34.resolve(root, "GEMINI.md");
   if (results.some((r) => r.filePath === "GEMINI.md")) return;
   try {
-    if (fs29.existsSync(geminiPath)) {
-      const existing = fs29.readFileSync(geminiPath, "utf-8");
+    if (fs31.existsSync(geminiPath)) {
+      const existing = fs31.readFileSync(geminiPath, "utf-8");
       if (existing.includes("Kuma MCP") || existing.includes("kuma_context")) {
         results.push({ type: "antigravity", filePath: "GEMINI.md", action: "skipped" });
         return;
       }
-      fs29.writeFileSync(geminiPath, existing.trimEnd() + "\n\n---\n\n" + geminiTemplate(), "utf-8");
+      fs31.writeFileSync(geminiPath, existing.trimEnd() + "\n\n---\n\n" + geminiTemplate(), "utf-8");
       results.push({ type: "antigravity", filePath: "GEMINI.md", action: "appended" });
     } else {
-      fs29.writeFileSync(geminiPath, geminiTemplate(), "utf-8");
+      fs31.writeFileSync(geminiPath, geminiTemplate(), "utf-8");
       results.push({ type: "antigravity", filePath: "GEMINI.md", action: "created" });
     }
   } catch (err) {
@@ -11508,19 +11872,19 @@ function handleAntigravitySecondary(root, results) {
   handleGeminiMd(root, results);
 }
 function handleWindsurfSecondary(root, results) {
-  const rulesPath = path32.resolve(root, ".windsurfrules");
+  const rulesPath = path34.resolve(root, ".windsurfrules");
   if (results.some((r) => r.filePath === ".windsurfrules")) return;
   try {
-    if (fs29.existsSync(rulesPath)) {
-      const existing = fs29.readFileSync(rulesPath, "utf-8");
+    if (fs31.existsSync(rulesPath)) {
+      const existing = fs31.readFileSync(rulesPath, "utf-8");
       if (existing.includes("Kuma MCP") || existing.includes("kuma_context")) {
         results.push({ type: "windsurf", filePath: ".windsurfrules", action: "skipped" });
         return;
       }
-      fs29.writeFileSync(rulesPath, existing.trimEnd() + "\n\n---\n\n" + windsurfrulesTemplate(), "utf-8");
+      fs31.writeFileSync(rulesPath, existing.trimEnd() + "\n\n---\n\n" + windsurfrulesTemplate(), "utf-8");
       results.push({ type: "windsurf", filePath: ".windsurfrules", action: "appended" });
     } else {
-      fs29.writeFileSync(rulesPath, windsurfrulesTemplate(), "utf-8");
+      fs31.writeFileSync(rulesPath, windsurfrulesTemplate(), "utf-8");
       results.push({ type: "windsurf", filePath: ".windsurfrules", action: "created" });
     }
   } catch (err) {
@@ -11533,21 +11897,21 @@ function handleWindsurfSecondary(root, results) {
   }
 }
 function handleClineSecondary(root, results) {
-  const rooPath = path32.resolve(root, ".roo", "rules", "kuma.md");
+  const rooPath = path34.resolve(root, ".roo", "rules", "kuma.md");
   if (!results.some((r) => r.filePath === ".roo/rules/kuma.md")) {
     try {
-      const dir = path32.dirname(rooPath);
-      if (fs29.existsSync(rooPath)) {
-        const existing = fs29.readFileSync(rooPath, "utf-8");
+      const dir = path34.dirname(rooPath);
+      if (fs31.existsSync(rooPath)) {
+        const existing = fs31.readFileSync(rooPath, "utf-8");
         if (existing.includes("kuma-mcp") || existing.includes("Kuma MCP")) {
           results.push({ type: "cline", filePath: ".roo/rules/kuma.md", action: "skipped" });
         } else {
-          fs29.writeFileSync(rooPath, existing.trimEnd() + "\n\n---\n\n" + rooRulesTemplate(), "utf-8");
+          fs31.writeFileSync(rooPath, existing.trimEnd() + "\n\n---\n\n" + rooRulesTemplate(), "utf-8");
           results.push({ type: "cline", filePath: ".roo/rules/kuma.md", action: "appended" });
         }
       } else {
-        if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-        fs29.writeFileSync(rooPath, rooRulesTemplate(), "utf-8");
+        if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+        fs31.writeFileSync(rooPath, rooRulesTemplate(), "utf-8");
         results.push({ type: "cline", filePath: ".roo/rules/kuma.md", action: "created" });
       }
     } catch (err) {
@@ -11559,21 +11923,21 @@ function handleClineSecondary(root, results) {
       });
     }
   }
-  const traePath = path32.resolve(root, ".trae", "rules", "kuma.md");
+  const traePath = path34.resolve(root, ".trae", "rules", "kuma.md");
   if (!results.some((r) => r.filePath === ".trae/rules/kuma.md")) {
     try {
-      const dir = path32.dirname(traePath);
-      if (fs29.existsSync(traePath)) {
-        const existing = fs29.readFileSync(traePath, "utf-8");
+      const dir = path34.dirname(traePath);
+      if (fs31.existsSync(traePath)) {
+        const existing = fs31.readFileSync(traePath, "utf-8");
         if (existing.includes("Kuma MCP")) {
           results.push({ type: "cline", filePath: ".trae/rules/kuma.md", action: "skipped" });
         } else {
-          fs29.writeFileSync(traePath, existing.trimEnd() + "\n\n---\n\n" + traeRulesTemplate(), "utf-8");
+          fs31.writeFileSync(traePath, existing.trimEnd() + "\n\n---\n\n" + traeRulesTemplate(), "utf-8");
           results.push({ type: "cline", filePath: ".trae/rules/kuma.md", action: "appended" });
         }
       } else {
-        if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-        fs29.writeFileSync(traePath, traeRulesTemplate(), "utf-8");
+        if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+        fs31.writeFileSync(traePath, traeRulesTemplate(), "utf-8");
         results.push({ type: "cline", filePath: ".trae/rules/kuma.md", action: "created" });
       }
     } catch (err) {
@@ -11585,21 +11949,21 @@ function handleClineSecondary(root, results) {
       });
     }
   }
-  const qoderPath = path32.resolve(root, ".qoder", "rules", "kuma.md");
+  const qoderPath = path34.resolve(root, ".qoder", "rules", "kuma.md");
   if (!results.some((r) => r.filePath === ".qoder/rules/kuma.md")) {
     try {
-      const dir = path32.dirname(qoderPath);
-      if (fs29.existsSync(qoderPath)) {
-        const existing = fs29.readFileSync(qoderPath, "utf-8");
+      const dir = path34.dirname(qoderPath);
+      if (fs31.existsSync(qoderPath)) {
+        const existing = fs31.readFileSync(qoderPath, "utf-8");
         if (existing.includes("Kuma MCP")) {
           results.push({ type: "cline", filePath: ".qoder/rules/kuma.md", action: "skipped" });
         } else {
-          fs29.writeFileSync(qoderPath, existing.trimEnd() + "\n\n---\n\n" + qoderRulesTemplate(), "utf-8");
+          fs31.writeFileSync(qoderPath, existing.trimEnd() + "\n\n---\n\n" + qoderRulesTemplate(), "utf-8");
           results.push({ type: "cline", filePath: ".qoder/rules/kuma.md", action: "appended" });
         }
       } else {
-        if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-        fs29.writeFileSync(qoderPath, qoderRulesTemplate(), "utf-8");
+        if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+        fs31.writeFileSync(qoderPath, qoderRulesTemplate(), "utf-8");
         results.push({ type: "cline", filePath: ".qoder/rules/kuma.md", action: "created" });
       }
     } catch (err) {
@@ -11613,18 +11977,18 @@ function handleClineSecondary(root, results) {
   }
 }
 function handleAiderSecondary(root, results) {
-  const ymlPath = path32.resolve(root, ".aider.conf.yml");
+  const ymlPath = path34.resolve(root, ".aider.conf.yml");
   if (results.some((r) => r.filePath === ".aider.conf.yml")) return;
   try {
     const conventionsRef = "read: CONVENTIONS.md";
-    if (fs29.existsSync(ymlPath)) {
-      const existingContent = fs29.readFileSync(ymlPath, "utf-8");
+    if (fs31.existsSync(ymlPath)) {
+      const existingContent = fs31.readFileSync(ymlPath, "utf-8");
       if (existingContent.includes("CONVENTIONS.md") || existingContent.includes("kuma")) {
         results.push({ type: "aider", filePath: ".aider.conf.yml", action: "skipped" });
         return;
       }
       const newContent = existingContent.trimEnd() + "\n\n# Kuma MCP conventions\n" + conventionsRef + "\n";
-      fs29.writeFileSync(ymlPath, newContent, "utf-8");
+      fs31.writeFileSync(ymlPath, newContent, "utf-8");
       results.push({ type: "aider", filePath: ".aider.conf.yml", action: "appended" });
     } else {
       const content = [
@@ -11634,7 +11998,7 @@ function handleAiderSecondary(root, results) {
         conventionsRef,
         ""
       ].join("\n");
-      fs29.writeFileSync(ymlPath, content, "utf-8");
+      fs31.writeFileSync(ymlPath, content, "utf-8");
       results.push({ type: "aider", filePath: ".aider.conf.yml", action: "created" });
     }
   } catch (err) {
@@ -11647,10 +12011,10 @@ function handleAiderSecondary(root, results) {
   }
 }
 function handleCopilotSecondary(root, results) {
-  const skillPath = path32.resolve(root, ".github/skills/kuma/SKILL.md");
+  const skillPath = path34.resolve(root, ".github/skills/kuma/SKILL.md");
   if (results.some((r) => r.filePath === ".github/skills/kuma/SKILL.md")) return;
   try {
-    const dir = path32.dirname(skillPath);
+    const dir = path34.dirname(skillPath);
     const content = [
       "---",
       "name: kuma-mcp",
@@ -11661,17 +12025,17 @@ function handleCopilotSecondary(root, results) {
       "",
       "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
     ].join("\n");
-    if (fs29.existsSync(skillPath)) {
-      const existingContent = fs29.readFileSync(skillPath, "utf-8");
+    if (fs31.existsSync(skillPath)) {
+      const existingContent = fs31.readFileSync(skillPath, "utf-8");
       if (existingContent.includes("kuma")) {
         results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "skipped" });
         return;
       }
-      fs29.writeFileSync(skillPath, existingContent.trimEnd() + "\n\n" + content, "utf-8");
+      fs31.writeFileSync(skillPath, existingContent.trimEnd() + "\n\n" + content, "utf-8");
       results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "appended" });
     } else {
-      if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-      fs29.writeFileSync(skillPath, content, "utf-8");
+      if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+      fs31.writeFileSync(skillPath, content, "utf-8");
       results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "created" });
     }
   } catch (err) {
@@ -11684,21 +12048,21 @@ function handleCopilotSecondary(root, results) {
   }
 }
 function handleOpenclawSecondary(root, results) {
-  const mcpPath = path32.resolve(root, ".agents/mcp_config.json");
+  const mcpPath = path34.resolve(root, ".agents/mcp_config.json");
   if (results.some((r) => r.filePath === ".agents/mcp_config.json")) return;
   try {
-    const dir = path32.dirname(mcpPath);
-    if (fs29.existsSync(mcpPath)) {
-      const existingContent = fs29.readFileSync(mcpPath, "utf-8");
+    const dir = path34.dirname(mcpPath);
+    if (fs31.existsSync(mcpPath)) {
+      const existingContent = fs31.readFileSync(mcpPath, "utf-8");
       if (existingContent.includes("kuma")) return;
       const parsed = JSON.parse(existingContent);
       parsed.mcpServers = parsed.mcpServers || {};
       parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-      fs29.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+      fs31.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
       results.push({ type: "openclaw", filePath: ".agents/mcp_config.json", action: "appended" });
     } else {
-      if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-      fs29.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
+      if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+      fs31.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
       results.push({ type: "openclaw", filePath: ".agents/mcp_config.json", action: "created" });
     }
   } catch (err) {
@@ -11711,20 +12075,20 @@ function handleOpenclawSecondary(root, results) {
   }
 }
 function handleInitMdGeneration(root, results) {
-  const initMdPath = path32.resolve(root, ".kuma/init.md");
+  const initMdPath = path34.resolve(root, ".kuma/init.md");
   try {
-    const kumaDir = path32.dirname(initMdPath);
-    if (!fs29.existsSync(kumaDir)) fs29.mkdirSync(kumaDir, { recursive: true });
-    if (fs29.existsSync(initMdPath)) {
-      const existing = fs29.readFileSync(initMdPath, "utf-8");
+    const kumaDir = path34.dirname(initMdPath);
+    if (!fs31.existsSync(kumaDir)) fs31.mkdirSync(kumaDir, { recursive: true });
+    if (fs31.existsSync(initMdPath)) {
+      const existing = fs31.readFileSync(initMdPath, "utf-8");
       if (existing.includes("_Generated by Kuma MCP_")) {
         results.push({ type: "claude", filePath: ".kuma/init.md", action: "skipped" });
         return;
       }
-      fs29.writeFileSync(initMdPath, existing.trimEnd() + "\n\n" + generateInitMdContent(), "utf-8");
+      fs31.writeFileSync(initMdPath, existing.trimEnd() + "\n\n" + generateInitMdContent(), "utf-8");
       results.push({ type: "claude", filePath: ".kuma/init.md", action: "appended" });
     } else {
-      fs29.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
+      fs31.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
       results.push({ type: "claude", filePath: ".kuma/init.md", action: "created" });
     }
   } catch (err) {
@@ -11737,20 +12101,20 @@ function handleInitMdGeneration(root, results) {
   }
 }
 function handleCodewhaleSecondary(root, results) {
-  const mcpPath = path32.resolve(root, ".codewhale/mcp.json");
+  const mcpPath = path34.resolve(root, ".codewhale/mcp.json");
   if (results.some((r) => r.filePath === ".codewhale/mcp.json")) return;
   try {
-    const dir = path32.dirname(mcpPath);
-    if (fs29.existsSync(mcpPath)) {
-      const existingContent = fs29.readFileSync(mcpPath, "utf-8");
+    const dir = path34.dirname(mcpPath);
+    if (fs31.existsSync(mcpPath)) {
+      const existingContent = fs31.readFileSync(mcpPath, "utf-8");
       if (existingContent.includes("kuma")) return;
       const parsed = JSON.parse(existingContent);
       parsed.mcpServers = parsed.mcpServers || {};
       parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-      fs29.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+      fs31.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
       results.push({ type: "codewhale", filePath: ".codewhale/mcp.json", action: "appended" });
     } else {
-      if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
+      if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
       const config = {
         mcpServers: {
           kuma: {
@@ -11760,7 +12124,7 @@ function handleCodewhaleSecondary(root, results) {
           }
         }
       };
-      fs29.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      fs31.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
       results.push({ type: "codewhale", filePath: ".codewhale/mcp.json", action: "created" });
     }
   } catch (err) {
@@ -11773,7 +12137,7 @@ function handleCodewhaleSecondary(root, results) {
   }
 }
 function handleClaudeSecondary(root, results) {
-  const settingsPath = path32.resolve(root, ".claude", "settings.json");
+  const settingsPath = path34.resolve(root, ".claude", "settings.json");
   const hookBlock = {
     hooks: {
       PreToolUse: [
@@ -11804,8 +12168,8 @@ function handleClaudeSecondary(root, results) {
     }
   };
   try {
-    if (fs29.existsSync(settingsPath)) {
-      const existing = JSON.parse(fs29.readFileSync(settingsPath, "utf-8"));
+    if (fs31.existsSync(settingsPath)) {
+      const existing = JSON.parse(fs31.readFileSync(settingsPath, "utf-8"));
       const existingHooks = existing.hooks || {};
       const mergedPre = [...existingHooks.PreToolUse || []];
       for (const entry of hookBlock.hooks.PreToolUse) {
@@ -11829,12 +12193,12 @@ function handleClaudeSecondary(root, results) {
         ...existing,
         hooks: { ...existingHooks, PreToolUse: mergedPre, SessionStart: mergedStart, PreCompact: mergedCompact }
       };
-      fs29.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      fs31.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       results.push({ type: "claude", filePath: ".claude/settings.json", action: "appended" });
     } else {
-      const dir = path32.dirname(settingsPath);
-      if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-      fs29.writeFileSync(settingsPath, JSON.stringify(hookBlock, null, 2) + "\n", "utf-8");
+      const dir = path34.dirname(settingsPath);
+      if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+      fs31.writeFileSync(settingsPath, JSON.stringify(hookBlock, null, 2) + "\n", "utf-8");
       results.push({ type: "claude", filePath: ".claude/settings.json", action: "created" });
     }
   } catch (err) {
@@ -11845,10 +12209,10 @@ function handleClaudeSecondary(root, results) {
       error: err instanceof Error ? err.message : String(err)
     });
   }
-  const skillPath = path32.resolve(root, ".claude", "skills", "kuma", "SKILL.md");
+  const skillPath = path34.resolve(root, ".claude", "skills", "kuma", "SKILL.md");
   if (!results.some((r) => r.filePath === ".claude/skills/kuma/SKILL.md")) {
     try {
-      const dir = path32.dirname(skillPath);
+      const dir = path34.dirname(skillPath);
       const content = [
         "---",
         "name: kuma-mcp",
@@ -11860,17 +12224,17 @@ function handleClaudeSecondary(root, results) {
         "\u{1F4D6} Read `.kuma/init.md` for detailed rules.",
         "\u{1F4C2} Readable state: `.kuma/KNOWN_GOTCHAS.md` (gotchas) \xB7 `.kuma/memories/decisions.md` (decisions)"
       ].join("\n");
-      if (fs29.existsSync(skillPath)) {
-        const existing = fs29.readFileSync(skillPath, "utf-8");
+      if (fs31.existsSync(skillPath)) {
+        const existing = fs31.readFileSync(skillPath, "utf-8");
         if (existing.includes("kuma-mcp")) {
           results.push({ type: "claude", filePath: ".claude/skills/kuma/SKILL.md", action: "skipped" });
         } else {
-          fs29.writeFileSync(skillPath, existing.trimEnd() + "\n\n---\n\n" + content, "utf-8");
+          fs31.writeFileSync(skillPath, existing.trimEnd() + "\n\n---\n\n" + content, "utf-8");
           results.push({ type: "claude", filePath: ".claude/skills/kuma/SKILL.md", action: "appended" });
         }
       } else {
-        if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-        fs29.writeFileSync(skillPath, content, "utf-8");
+        if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+        fs31.writeFileSync(skillPath, content, "utf-8");
         results.push({ type: "claude", filePath: ".claude/skills/kuma/SKILL.md", action: "created" });
       }
     } catch (err) {
@@ -11884,27 +12248,27 @@ function handleClaudeSecondary(root, results) {
   }
 }
 function writeHooksFile(root, relPath, type, results, build) {
-  const fullPath = path32.resolve(root, relPath);
+  const fullPath = path34.resolve(root, relPath);
   try {
     let existing = {};
     let existed = false;
-    if (fs29.existsSync(fullPath)) {
+    if (fs31.existsSync(fullPath)) {
       existed = true;
       try {
-        existing = JSON.parse(fs29.readFileSync(fullPath, "utf-8"));
+        existing = JSON.parse(fs31.readFileSync(fullPath, "utf-8"));
       } catch {
         existing = {};
       }
     } else {
-      const dir = path32.dirname(fullPath);
-      if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
+      const dir = path34.dirname(fullPath);
+      if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
     }
     const { doc, changed } = build(existing);
     if (!changed) {
       results.push({ type, filePath: relPath, action: "skipped" });
       return;
     }
-    fs29.writeFileSync(fullPath, JSON.stringify(doc, null, 2) + "\n", "utf-8");
+    fs31.writeFileSync(fullPath, JSON.stringify(doc, null, 2) + "\n", "utf-8");
     results.push({ type, filePath: relPath, action: existed ? "appended" : "created" });
   } catch (err) {
     results.push({ type, filePath: relPath, action: "error", error: err instanceof Error ? err.message : String(err) });
@@ -11985,18 +12349,18 @@ function handleCodexHooks(root, results) {
   });
 }
 function handleCursorGotchaRules(root, results) {
-  const rulesDir2 = path32.resolve(root, ".cursor", "rules", "kuma-gotchas");
+  const rulesDir2 = path34.resolve(root, ".cursor", "rules", "kuma-gotchas");
   try {
     let gotchas = [];
     try {
       gotchas = getActiveGotchas().filter((g) => g.severity === "high" || g.severity === "critical");
     } catch {
     }
-    if (fs29.existsSync(rulesDir2)) {
-      for (const f of fs29.readdirSync(rulesDir2)) {
+    if (fs31.existsSync(rulesDir2)) {
+      for (const f of fs31.readdirSync(rulesDir2)) {
         if (f.endsWith(".mdc")) {
           try {
-            fs29.rmSync(path32.join(rulesDir2, f), { force: true });
+            fs31.rmSync(path34.join(rulesDir2, f), { force: true });
           } catch {
           }
         }
@@ -12006,7 +12370,7 @@ function handleCursorGotchaRules(root, results) {
       results.push({ type: "cursor", filePath: ".cursor/rules/kuma-gotchas/", action: "skipped" });
       return;
     }
-    fs29.mkdirSync(rulesDir2, { recursive: true });
+    fs31.mkdirSync(rulesDir2, { recursive: true });
     const seen = /* @__PURE__ */ new Set();
     let created = 0;
     for (const g of gotchas) {
@@ -12027,7 +12391,7 @@ function handleCursorGotchaRules(root, results) {
         "`kuma_context({ action: 'history', target: '<file>' })`",
         ""
       ].join("\n");
-      fs29.writeFileSync(path32.join(rulesDir2, `${slug2}.mdc`), md, "utf-8");
+      fs31.writeFileSync(path34.join(rulesDir2, `${slug2}.mdc`), md, "utf-8");
       created++;
     }
     results.push({
@@ -12054,28 +12418,28 @@ function runInit(options) {
   let agentsMdHandled = false;
   for (const type of selected) {
     const relativePath = configFilePath(type);
-    const fullPath = path32.resolve(root, relativePath);
+    const fullPath = path34.resolve(root, relativePath);
     const getTemplate = TEMPLATES[type];
     try {
       if (AGENTS_MD_TYPES.includes(type) && !agentsMdHandled) {
         agentsMdHandled = true;
         const combinedContent = getCombinedAgentsMd(new Set(agentsMdSelected));
-        if (fs29.existsSync(fullPath)) {
+        if (fs31.existsSync(fullPath)) {
           if (options.skipExisting) {
             results.push({ type, filePath: relativePath, action: "skipped" });
           } else {
-            const existingContent = fs29.readFileSync(fullPath, "utf-8");
+            const existingContent = fs31.readFileSync(fullPath, "utf-8");
             if (existingContent.includes("_Generated by Kuma MCP_")) {
               results.push({ type, filePath: relativePath, action: "skipped" });
             } else {
-              fs29.writeFileSync(fullPath, existingContent.trimEnd() + "\n\n" + combinedContent, "utf-8");
+              fs31.writeFileSync(fullPath, existingContent.trimEnd() + "\n\n" + combinedContent, "utf-8");
               results.push({ type, filePath: relativePath, action: "appended" });
             }
           }
         } else {
-          const dir = path32.dirname(fullPath);
-          if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
-          fs29.writeFileSync(fullPath, combinedContent, "utf-8");
+          const dir = path34.dirname(fullPath);
+          if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
+          fs31.writeFileSync(fullPath, combinedContent, "utf-8");
           results.push({ type, filePath: relativePath, action: "created" });
         }
         if (selectedSet.has("opencode")) handleOpencodeSecondary(root, results);
@@ -12087,12 +12451,12 @@ function runInit(options) {
         continue;
       } else {
         const template = getTemplate();
-        if (fs29.existsSync(fullPath)) {
+        if (fs31.existsSync(fullPath)) {
           if (options.skipExisting) {
             results.push({ type, filePath: relativePath, action: "skipped" });
             continue;
           }
-          const existingContent = fs29.readFileSync(fullPath, "utf-8");
+          const existingContent = fs31.readFileSync(fullPath, "utf-8");
           if (existingContent.includes("_Generated by Kuma MCP_")) {
             if (type === "antigravity") {
               handleAntigravitySecondary(root, results);
@@ -12109,14 +12473,14 @@ function runInit(options) {
             continue;
           }
           const newContent = existingContent.trimEnd() + APPEND_SEPARATOR + template;
-          fs29.writeFileSync(fullPath, newContent, "utf-8");
+          fs31.writeFileSync(fullPath, newContent, "utf-8");
           results.push({ type, filePath: relativePath, action: "appended" });
         } else {
-          const dir = path32.dirname(fullPath);
-          if (!fs29.existsSync(dir)) {
-            fs29.mkdirSync(dir, { recursive: true });
+          const dir = path34.dirname(fullPath);
+          if (!fs31.existsSync(dir)) {
+            fs31.mkdirSync(dir, { recursive: true });
           }
-          fs29.writeFileSync(fullPath, template, "utf-8");
+          fs31.writeFileSync(fullPath, template, "utf-8");
           results.push({ type, filePath: relativePath, action: "created" });
         }
         if (type === "antigravity") {
@@ -12288,8 +12652,8 @@ var compactionContext_exports = {};
 __export(compactionContext_exports, {
   getCompactionContext: () => getCompactionContext
 });
-import fs30 from "fs";
-import path33 from "path";
+import fs32 from "fs";
+import path35 from "path";
 async function getCompactionContext() {
   const parts = [];
   try {
@@ -12302,8 +12666,8 @@ async function getCompactionContext() {
   } catch {
   }
   try {
-    const dbFile = path33.join(getProjectRoot(), ".kuma", "kuma.db");
-    if (fs30.existsSync(dbFile)) {
+    const dbFile = path35.join(getProjectRoot(), ".kuma", "kuma.db");
+    if (fs32.existsSync(dbFile)) {
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
       const db = await getDb2();
       const stmt = db.prepare(
@@ -12329,9 +12693,9 @@ async function getCompactionContext() {
   } catch {
   }
   try {
-    const cpDir = path33.join(getProjectRoot(), ".kuma", "checkpoints");
-    if (fs30.existsSync(cpDir)) {
-      const cps = fs30.readdirSync(cpDir).slice(0, 3);
+    const cpDir = path35.join(getProjectRoot(), ".kuma", "checkpoints");
+    if (fs32.existsSync(cpDir)) {
+      const cps = fs32.readdirSync(cpDir).slice(0, 3);
       if (cps.length > 0) parts.push(`Checkpoints: ${cps.join(", ")}`);
     }
   } catch {
@@ -12349,6 +12713,196 @@ var init_compactionContext = __esm({
   }
 });
 
+// src/engine/kumaDaemon.ts
+var kumaDaemon_exports = {};
+__export(kumaDaemon_exports, {
+  DEFAULT_INTERVAL_MS: () => DEFAULT_INTERVAL_MS,
+  daemonRunChild: () => daemonRunChild,
+  daemonStart: () => daemonStart,
+  daemonStatus: () => daemonStatus,
+  daemonStop: () => daemonStop,
+  daemonTick: () => daemonTick
+});
+import fs33 from "fs";
+import path36 from "path";
+import { spawn } from "child_process";
+function paths(root) {
+  const r = root || getProjectRoot();
+  return {
+    pid: path36.join(r, PID_FILE),
+    status: path36.join(r, STATUS_FILE),
+    log: path36.join(r, LOG_FILE)
+  };
+}
+function readPid(root) {
+  try {
+    const fp = paths(root).pid;
+    if (!fs33.existsSync(fp)) return null;
+    const pid = Number(fs33.readFileSync(fp, "utf-8").trim());
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function daemonTick(root) {
+  const r = root || getProjectRoot();
+  const p = paths(r);
+  const notes = [];
+  try {
+    const { ensureBackbone: ensureBackbone2, formatBackbone: formatBackbone2 } = await Promise.resolve().then(() => (init_mapBackbone(), mapBackbone_exports));
+    const bb = await ensureBackbone2();
+    if (bb) notes.push(formatBackbone2(bb));
+  } catch {
+  }
+  try {
+    const { syncModifiedFiles: syncModifiedFiles2 } = await Promise.resolve().then(() => (init_kumaCodeScanner(), kumaCodeScanner_exports));
+    const scan = await syncModifiedFiles2(50);
+    notes.push(`map: ${scan.filesScanned}f/${scan.nodeCount}n/${scan.edgeCount}e`);
+  } catch (err) {
+    notes.push(`map: skipped (${err})`);
+  }
+  try {
+    const { refreshPackageBriefs: refreshPackageBriefs2 } = await Promise.resolve().then(() => (init_packageBriefs(), packageBriefs_exports));
+    const { count } = await refreshPackageBriefs2();
+    notes.push(`briefs: ${count}`);
+  } catch {
+    notes.push("briefs: skipped");
+  }
+  try {
+    const { detectDrift: detectDrift2 } = await Promise.resolve().then(() => (init_kumaDriftDetector(), kumaDriftDetector_exports));
+    const records = await detectDrift2();
+    const stale = records.filter((x) => x.severity === "stale" || x.severity === "missing").length;
+    notes.push(`drift: ${stale}/${records.length} stale`);
+  } catch {
+    notes.push("drift: skipped");
+  }
+  try {
+    const { clearDirty: clearDirty2 } = await Promise.resolve().then(() => (init_cacheFreshness(), cacheFreshness_exports));
+    clearDirty2();
+  } catch {
+  }
+  const status = {
+    lastRunAt: Date.now(),
+    lastResult: notes.join(" \xB7 ")
+  };
+  try {
+    let prev = {};
+    if (fs33.existsSync(p.status)) prev = JSON.parse(fs33.readFileSync(p.status, "utf-8"));
+    fs33.writeFileSync(p.status, JSON.stringify({ ...prev, ...status }, null, 2), "utf-8");
+  } catch {
+  }
+  return notes.join(" \xB7 ");
+}
+async function runLoop(intervalMs) {
+  const r = getProjectRoot();
+  const p = paths(r);
+  const log = (msg) => {
+    try {
+      fs33.appendFileSync(p.log, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+`, "utf-8");
+    } catch {
+    }
+  };
+  log(`daemon started (interval ${intervalMs}ms)`);
+  for (; ; ) {
+    try {
+      const res = await daemonTick(r);
+      log(`tick: ${res}`);
+    } catch (err) {
+      log(`tick failed: ${err}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}
+async function daemonStart(intervalMs = DEFAULT_INTERVAL_MS, root) {
+  const r = root || getProjectRoot();
+  const p = paths(r);
+  const existing = readPid(r);
+  if (existing && isAlive(existing)) {
+    return `\u{1F43B} Daemon already running (pid ${existing}). Use \`kuma daemon stop\` first.`;
+  }
+  const entry = process.argv[1];
+  const child = spawn(process.execPath, [entry, "daemon", "run", String(intervalMs)], {
+    cwd: r,
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  try {
+    fs33.writeFileSync(p.pid, String(child.pid), "utf-8");
+    fs33.writeFileSync(
+      p.status,
+      JSON.stringify({ running: true, pid: child.pid, startedAt: Date.now(), lastRunAt: null, lastResult: null, intervalMs }, null, 2),
+      "utf-8"
+    );
+  } catch {
+  }
+  return `\u{1F43B} Daemon started (pid ${child.pid}, every ${Math.round(intervalMs / 6e4)}m). Status: .kuma/daemon-status.json`;
+}
+async function daemonStop(root) {
+  const r = root || getProjectRoot();
+  const p = paths(r);
+  const pid = readPid(r);
+  if (!pid) return "\u{1F43B} Daemon not running (no pid file).";
+  if (!isAlive(pid)) {
+    try {
+      fs33.rmSync(p.pid, { force: true });
+    } catch {
+    }
+    return "\u{1F43B} Daemon pid file was stale \u2014 cleaned up (process already gone).";
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    try {
+      fs33.rmSync(p.pid, { force: true });
+    } catch {
+    }
+    return `\u{1F43B} Daemon stopped (was pid ${pid}).`;
+  } catch (err) {
+    return `\u{1F43B} Could not stop daemon pid ${pid}: ${err}`;
+  }
+}
+async function daemonStatus(root) {
+  const r = root || getProjectRoot();
+  const p = paths(r);
+  const pid = readPid(r);
+  let status = { running: false, pid: null, startedAt: null, lastRunAt: null, lastResult: null, intervalMs: DEFAULT_INTERVAL_MS };
+  try {
+    if (fs33.existsSync(p.status)) status = { ...status, ...JSON.parse(fs33.readFileSync(p.status, "utf-8")) };
+  } catch {
+  }
+  const alive = pid !== null && isAlive(pid);
+  status.running = alive;
+  status.pid = alive ? pid : null;
+  if (!alive) {
+    return `\u{1F43B} Daemon: stopped.${status.lastRunAt ? ` Last tick ${new Date(status.lastRunAt).toISOString()}: ${status.lastResult || "n/a"}` : " Never ran."} Start with \`kuma daemon start\`.`;
+  }
+  return `\u{1F43B} Daemon: running (pid ${pid}).${status.lastRunAt ? ` Last tick ${new Date(status.lastRunAt).toISOString()}: ${status.lastResult || "n/a"}` : " Warming up\u2026"}`;
+}
+async function daemonRunChild(intervalMs) {
+  const ms = Number.isFinite(intervalMs) && intervalMs >= 3e4 ? intervalMs : DEFAULT_INTERVAL_MS;
+  await runLoop(ms);
+}
+var PID_FILE, STATUS_FILE, LOG_FILE, DEFAULT_INTERVAL_MS;
+var init_kumaDaemon = __esm({
+  "src/engine/kumaDaemon.ts"() {
+    "use strict";
+    init_pathValidator();
+    PID_FILE = ".kuma/daemon.pid";
+    STATUS_FILE = ".kuma/daemon-status.json";
+    LOG_FILE = ".kuma/daemon.log";
+    DEFAULT_INTERVAL_MS = 5 * 60 * 1e3;
+  }
+});
+
 // src/utils/agentDetector.ts
 var agentDetector_exports = {};
 __export(agentDetector_exports, {
@@ -12357,19 +12911,19 @@ __export(agentDetector_exports, {
   getSkillPath: () => getSkillPath,
   skillExists: () => skillExists
 });
-import fs31 from "fs";
-import path34 from "path";
+import fs34 from "fs";
+import path37 from "path";
 function checkFile(root, filePath) {
   try {
-    return fs31.existsSync(path34.join(root, filePath));
+    return fs34.existsSync(path37.join(root, filePath));
   } catch {
     return false;
   }
 }
 function checkDir(root, dirPath) {
   try {
-    const fullPath = path34.join(root, dirPath);
-    return fs31.existsSync(fullPath) && fs31.statSync(fullPath).isDirectory();
+    const fullPath = path37.join(root, dirPath);
+    return fs34.existsSync(fullPath) && fs34.statSync(fullPath).isDirectory();
   } catch {
     return false;
   }
@@ -12437,7 +12991,7 @@ function getAgentLabel(type) {
 function skillExists(type, projectRoot) {
   const root = projectRoot ?? getProjectRoot();
   const skillPath = getSkillPath(type);
-  return fs31.existsSync(path34.join(root, skillPath));
+  return fs34.existsSync(path37.join(root, skillPath));
 }
 var AGENT_DETECTORS;
 var init_agentDetector = __esm({
@@ -13033,8 +13587,8 @@ init_kumaGraph();
 init_kumaMemory();
 init_kumaDriftDetector();
 init_pathValidator();
-import fs21 from "fs";
-import path24 from "path";
+import fs23 from "fs";
+import path26 from "path";
 var CONTEXT_ALIASES = {
   "research": "research",
   "search": "research",
@@ -13153,6 +13707,15 @@ async function handleCluster(_params) {
 async function handleInit(_params) {
   sessionMemory.setGoal(_params.goal || "Exploring project");
   sessionMemory.recordToolCall("kuma_context_init", {});
+  let backboneNote = "";
+  try {
+    const { ensureBackbone: ensureBackbone2, formatBackbone: formatBackbone2 } = await Promise.resolve().then(() => (init_mapBackbone(), mapBackbone_exports));
+    const bb = await ensureBackbone2();
+    if (bb) backboneNote = `
+${formatBackbone2(bb)}
+`;
+  } catch {
+  }
   const branch = sessionMemory.getCurrentBranch();
   const branchTag = branch ? ` [git: \`${branch}\`]` : "";
   const lines = [
@@ -13162,6 +13725,7 @@ async function handleInit(_params) {
     `\u{1F4C1} Project: ${getProjectRoot().split("/").pop() || "unknown"}${branchTag}`,
     ""
   ];
+  if (backboneNote) lines.push(backboneNote);
   const branchTransition = sessionMemory.getBranchTransition();
   if (branchTransition?.switched) {
     lines.push(`\u{1F500} **Branch switched**: from \`${branchTransition.from}\` to \`${branchTransition.to}\`. Session context updated.`);
@@ -13361,6 +13925,14 @@ async function handleResearch(params, dirtySynced = 0) {
   } else lines.push("  \u23F3 No content hash available \u2014 will research fresh");
   lines.push("");
   lines.push("**Step 3/5: Graph Query + Code Scan**");
+  try {
+    if (params.scope && (params.scope.includes("/") || params.scope.includes("."))) {
+      const { ensureMapped: ensureMapped2 } = await Promise.resolve().then(() => (init_mapBackbone(), mapBackbone_exports));
+      const { filled } = await ensureMapped2([params.scope]);
+      if (filled > 0) lines.push(`  \u{1F5FA}\uFE0F Precision tier filled on demand: ${filled} file(s) indexed (no user action needed)`);
+    }
+  } catch {
+  }
   try {
     const graphResult = await searchGraph(scope, 15);
     const graphLines = graphResult.split("\n");
@@ -13451,10 +14023,10 @@ async function handleHistory(params) {
       lines.push(traceFormatted);
     } else {
       try {
-        const { execSync: execSync9 } = await import("child_process");
+        const { execSync: execSync10 } = await import("child_process");
         const { getProjectRoot: getProjectRoot2 } = await Promise.resolve().then(() => (init_pathValidator(), pathValidator_exports));
         const root = getProjectRoot2();
-        const gitHistory = execSync9(
+        const gitHistory = execSync10(
           `git log -n 5 --pretty=format:"  \u2022 %h (%ad) %s" --date=short -- "${target}"`,
           { cwd: root, encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }
         ).trim();
@@ -13486,7 +14058,7 @@ ${gitHistory}`);
     try {
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
       const db = await getDb2();
-      const base = path24.basename(target);
+      const base = path26.basename(target);
       const stmt = db.prepare(`
         SELECT description, last_verified_at FROM known_gotchas
         WHERE status = 'resolved' AND (file_path LIKE ? OR file_path LIKE ?)
@@ -13499,9 +14071,9 @@ ${gitHistory}`);
       if (resolved.length === 0) {
         try {
           const { getProjectRoot: getProjectRoot2 } = await Promise.resolve().then(() => (init_pathValidator(), pathValidator_exports));
-          const mdPath = path24.join(getProjectRoot2(), ".kuma", "KNOWN_GOTCHAS.md");
-          if (fs21.existsSync(mdPath)) {
-            const mdContent = fs21.readFileSync(mdPath, "utf-8");
+          const mdPath = path26.join(getProjectRoot2(), ".kuma", "KNOWN_GOTCHAS.md");
+          if (fs23.existsSync(mdPath)) {
+            const mdContent = fs23.readFileSync(mdPath, "utf-8");
             const sections = mdContent.split(/^###\s+/m);
             for (const sec of sections) {
               const secLower = sec.toLowerCase();
@@ -13573,8 +14145,8 @@ init_kumaDb();
 init_kumaMemory();
 init_pathValidator();
 init_pathValidator();
-import fs23 from "fs";
-import path26 from "path";
+import fs25 from "fs";
+import path28 from "path";
 var MEMORY_ALIASES = {
   "decision": "decision",
   "adr": "decision",
@@ -13685,9 +14257,9 @@ async function handleResearchSave(params) {
   } catch {
   }
   try {
-    const researchDir = path26.join(getProjectRoot(), ".kuma", "research");
-    if (!fs23.existsSync(researchDir)) fs23.mkdirSync(researchDir, { recursive: true });
-    fs23.writeFileSync(path26.join(researchDir, `${scope}.json`), JSON.stringify(JSON.parse(record), null, 2), "utf-8");
+    const researchDir = path28.join(getProjectRoot(), ".kuma", "research");
+    if (!fs25.existsSync(researchDir)) fs25.mkdirSync(researchDir, { recursive: true });
+    fs25.writeFileSync(path28.join(researchDir, `${scope}.json`), JSON.stringify(JSON.parse(record), null, 2), "utf-8");
   } catch {
   }
   sessionMemory.recordMemoryAction("research_save");
@@ -13883,9 +14455,9 @@ init_sessionMemory();
 init_pathValidator();
 init_sessionMemory();
 init_kumaShared();
-import fs24 from "fs";
-import path27 from "path";
-import { execSync as execSync6 } from "child_process";
+import fs26 from "fs";
+import path29 from "path";
+import { execSync as execSync7 } from "child_process";
 var SCRIPT_PATCH_PATTERNS = [
   "writeFileSync",
   "writeFile",
@@ -13911,20 +14483,20 @@ function findPatchScripts(projectRoot) {
   const warnings = [];
   const recentFiles = scanRecentFiles(projectRoot);
   for (const file of recentFiles) {
-    const ext = path27.extname(file).toLowerCase();
+    const ext = path29.extname(file).toLowerCase();
     if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
-    const relativePath = path27.relative(projectRoot, file);
+    const relativePath = path29.relative(projectRoot, file);
     if (relativePath.startsWith("src") || relativePath.startsWith("test") || relativePath.startsWith("node_modules") || relativePath.startsWith(".") || relativePath.startsWith(".kuma/scratch")) {
       continue;
     }
     try {
-      const content = fs24.readFileSync(file, "utf-8").toLowerCase();
+      const content = fs26.readFileSync(file, "utf-8").toLowerCase();
       const matchedPattern = SCRIPT_PATCH_PATTERNS.find((p) => content.includes(p.toLowerCase()));
       if (matchedPattern) {
         warnings.push({
           severity: "high",
           pattern: "script-patching",
-          message: `Created script file that modifies other files: ${path27.basename(file)}`,
+          message: `Created script file that modifies other files: ${path29.basename(file)}`,
           suggestion: "Use your native edit tools instead \u2014 targeted edits with auto-backup and rollback",
           evidence: `File: ${relativePath} contains '${matchedPattern}'`,
           filePath: relativePath
@@ -13958,15 +14530,15 @@ function detectBashGrepUsage() {
 function scanRecentFiles(projectRoot) {
   const recent = [];
   try {
-    const entries = fs24.readdirSync(projectRoot, { withFileTypes: true });
+    const entries = fs26.readdirSync(projectRoot, { withFileTypes: true });
     const now = Date.now();
     const recentThreshold = 30 * 60 * 1e3;
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       try {
-        const stat = fs24.statSync(path27.join(projectRoot, entry.name));
+        const stat = fs26.statSync(path29.join(projectRoot, entry.name));
         if (now - stat.mtimeMs < recentThreshold || now - stat.ctimeMs < recentThreshold) {
-          recent.push(path27.join(projectRoot, entry.name));
+          recent.push(path29.join(projectRoot, entry.name));
         }
       } catch {
         continue;
@@ -13979,7 +14551,7 @@ function scanRecentFiles(projectRoot) {
 function detectGitPatchScripts(projectRoot) {
   const warnings = [];
   try {
-    const statusStdout = execSync6("git status --porcelain", {
+    const statusStdout = execSync7("git status --porcelain", {
       cwd: projectRoot,
       encoding: "utf-8",
       timeout: 3e3
@@ -13990,14 +14562,14 @@ function detectGitPatchScripts(projectRoot) {
         const prefix = line.substring(0, 2);
         if (prefix !== "??" && prefix !== "A ") continue;
         const file = line.substring(3).trim();
-        const ext = path27.extname(file).toLowerCase();
+        const ext = path29.extname(file).toLowerCase();
         if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
         const isRootLevel = !file.includes("/");
         const isScriptsDir = file.startsWith("scripts/") || file.startsWith("patches/");
         if (!isRootLevel && !isScriptsDir) continue;
-        const fullPath = path27.join(projectRoot, file);
-        if (fs24.existsSync(fullPath)) {
-          const content = fs24.readFileSync(fullPath, "utf-8").toLowerCase();
+        const fullPath = path29.join(projectRoot, file);
+        if (fs26.existsSync(fullPath)) {
+          const content = fs26.readFileSync(fullPath, "utf-8").toLowerCase();
           const matchedPattern = SCRIPT_PATCH_PATTERNS.find((p) => content.includes(p.toLowerCase()));
           if (matchedPattern) {
             warnings.push({
@@ -14012,7 +14584,7 @@ function detectGitPatchScripts(projectRoot) {
         }
       }
     }
-    const deletedStdout = execSync6("git diff --name-only --diff-filter=D HEAD", {
+    const deletedStdout = execSync7("git diff --name-only --diff-filter=D HEAD", {
       cwd: projectRoot,
       encoding: "utf-8",
       timeout: 3e3
@@ -14020,7 +14592,7 @@ function detectGitPatchScripts(projectRoot) {
     if (deletedStdout) {
       const deletedFiles = deletedStdout.split("\n").filter(Boolean);
       for (const file of deletedFiles) {
-        const ext = path27.extname(file).toLowerCase();
+        const ext = path29.extname(file).toLowerCase();
         if (SCRIPT_EXTENSIONS.includes(ext)) {
           warnings.push({
             severity: "high",
@@ -14082,21 +14654,21 @@ function detectAllAntiPatterns() {
 // src/engine/contextSnapshot.ts
 init_sessionMemory();
 init_pathValidator();
-import fs25 from "fs";
-import path28 from "path";
-import { execSync as execSync7 } from "child_process";
+import fs27 from "fs";
+import path30 from "path";
+import { execSync as execSync8 } from "child_process";
 var SNAPSHOT_DIR = "context-snapshots";
 function snapshotDir() {
-  return path28.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
+  return path30.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
 }
 function ensureSnapshotDir() {
   const dir = snapshotDir();
-  if (!fs25.existsSync(dir)) {
-    fs25.mkdirSync(dir, { recursive: true });
+  if (!fs27.existsSync(dir)) {
+    fs27.mkdirSync(dir, { recursive: true });
   }
 }
 function snapshotFilePath(timestamp) {
-  return path28.join(snapshotDir(), `${timestamp}.json`);
+  return path30.join(snapshotDir(), `${timestamp}.json`);
 }
 function saveSnapshot(goal) {
   try {
@@ -14117,7 +14689,7 @@ function saveSnapshot(goal) {
     hasConventions: !!summary.hasConventions
   };
   try {
-    fs25.writeFileSync(snapshotFilePath(Date.now()), JSON.stringify(snapshot, null, 2), "utf-8");
+    fs27.writeFileSync(snapshotFilePath(Date.now()), JSON.stringify(snapshot, null, 2), "utf-8");
   } catch {
   }
   sessionMemory.recordToolCall("kuma_context", { action: "save", goal: snapshot.goal });
@@ -14156,7 +14728,7 @@ function formatSnapshot(snapshot) {
 function getGitDiffStat2() {
   try {
     const root = getProjectRoot();
-    const stdout = execSync7("git diff --stat", {
+    const stdout = execSync8("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
       timeout: 3e3
@@ -14817,6 +15389,7 @@ Usage:
   npx @plumpslabs/kuma hook pre-compact    PreCompact hook \u2014 survival set (goal + critical gotchas + dirty)
   npx @plumpslabs/kuma hook post-commit    Git post-commit \u2014 periodic incremental map sync (no rebuild)
   npx @plumpslabs/kuma hook install-git    Install the git post-commit hook (idempotent)
+  npx @plumpslabs/kuma daemon start|stop|status  Background sensors (map + briefs + drift) every 5m
 
 Available config files:
   --claude     CLAUDE.md                    (Claude Code)
@@ -14909,14 +15482,14 @@ async function main() {
     console.error("");
     let killedCount = 0;
     try {
-      const path35 = await import("path");
-      const fs32 = await import("fs");
-      const lockDir = path35.resolve(process.cwd(), ".kuma/verifier.lock");
-      if (fs32.existsSync(lockDir)) {
-        const pidFile = path35.join(lockDir, "pid");
-        if (fs32.existsSync(pidFile)) {
+      const path38 = await import("path");
+      const fs35 = await import("fs");
+      const lockDir = path38.resolve(process.cwd(), ".kuma/verifier.lock");
+      if (fs35.existsSync(lockDir)) {
+        const pidFile = path38.join(lockDir, "pid");
+        if (fs35.existsSync(pidFile)) {
           try {
-            const pid = parseInt(fs32.readFileSync(pidFile, "utf-8"), 10);
+            const pid = parseInt(fs35.readFileSync(pidFile, "utf-8"), 10);
             if (pid && pid !== process.pid) {
               try {
                 process.kill(-pid, "SIGKILL");
@@ -14932,7 +15505,7 @@ async function main() {
           } catch {
           }
         }
-        fs32.rmSync(lockDir, { recursive: true, force: true });
+        fs35.rmSync(lockDir, { recursive: true, force: true });
       }
       if (killedCount === 0) {
         console.error("\u2705 No running verifications found to kill.");
@@ -14940,25 +15513,25 @@ async function main() {
     } catch {
     }
     try {
-      const { execSync: execSync9 } = await import("child_process");
+      const { execSync: execSync10 } = await import("child_process");
       try {
-        execSync9("pkill -f 'jest' 2>/dev/null || true");
+        execSync10("pkill -f 'jest' 2>/dev/null || true");
       } catch {
       }
       try {
-        execSync9("pkill -f 'jest-worker' 2>/dev/null || true");
+        execSync10("pkill -f 'jest-worker' 2>/dev/null || true");
       } catch {
       }
       try {
-        execSync9("pkill -f 'pnpm test' 2>/dev/null || true");
+        execSync10("pkill -f 'pnpm test' 2>/dev/null || true");
       } catch {
       }
       try {
-        execSync9("pkill -f 'npm test' 2>/dev/null || true");
+        execSync10("pkill -f 'npm test' 2>/dev/null || true");
       } catch {
       }
       try {
-        execSync9("pkill -f 'yarn test' 2>/dev/null || true");
+        execSync10("pkill -f 'yarn test' 2>/dev/null || true");
       } catch {
       }
       console.error("\u2705 Killed orphaned test processes");
@@ -14987,7 +15560,7 @@ async function main() {
   if (args[0] === "studio") {
     const { fileURLToPath } = await import("url");
     const { dirname, join } = await import("path");
-    const { spawn } = await import("child_process");
+    const { spawn: spawn2 } = await import("child_process");
     const { existsSync } = await import("fs");
     const distDir = dirname(fileURLToPath(import.meta.url));
     const studioPath = join(distDir, "..", "packages", "ide", "studio", "dist", "index.js");
@@ -14998,7 +15571,7 @@ async function main() {
       process.exit(1);
     }
     const studioArgs = args.slice(1);
-    const child = spawn("node", [studioPath, ...studioArgs], {
+    const child = spawn2("node", [studioPath, ...studioArgs], {
       stdio: "inherit",
       cwd: process.cwd()
     });
@@ -15131,14 +15704,14 @@ ${context}` : "";
           process.stdout.write("\u{1F43B} [Kuma] git post-commit hook already installed.");
         } else {
           fsMod.appendFileSync(hookPath, `
-# Kuma periodic mapping (industry auto-map)
+# Kuma periodic mapping
 ${line}
 `, "utf-8");
           process.stdout.write("\u{1F43B} [Kuma] appended to existing git post-commit hook.");
         }
       } else {
         fsMod.writeFileSync(hookPath, `#!/bin/sh
-# Kuma periodic mapping (industry auto-map)
+# Kuma periodic mapping
 ${line}
 `, { mode: 493 });
         process.stdout.write("\u{1F43B} [Kuma] git post-commit hook installed.");
@@ -15148,6 +15721,26 @@ ${line}
     }
     process.exit(0);
   }
+  if (args[0] === "daemon") {
+    const sub = args[1] || "status";
+    try {
+      const { daemonStart: daemonStart2, daemonStop: daemonStop2, daemonStatus: daemonStatus2, daemonRunChild: daemonRunChild2, DEFAULT_INTERVAL_MS: DEFAULT_INTERVAL_MS2 } = await Promise.resolve().then(() => (init_kumaDaemon(), kumaDaemon_exports));
+      if (sub === "start") {
+        const ms = Number(args[2]) > 0 ? Number(args[2]) : DEFAULT_INTERVAL_MS2;
+        process.stdout.write(await daemonStart2(ms));
+      } else if (sub === "stop") {
+        process.stdout.write(await daemonStop2());
+      } else if (sub === "run") {
+        await daemonRunChild2(Number(args[2]));
+        return;
+      } else {
+        process.stdout.write(await daemonStatus2());
+      }
+    } catch (err) {
+      process.stdout.write(`\u{1F43B} Daemon error: ${err}`);
+    }
+    process.exit(0);
+  }
   if (args[0] === "--hook") {
     process.exit(0);
   }
@@ -15158,8 +15751,14 @@ ${line}
       const proj = root.split("/").pop() || "unknown";
       const lines = [`\u{1F43B} [Kuma session brief] ${proj}`];
       try {
-        const { execSync: execSync9 } = await import("child_process");
-        const branch = execSync9("git rev-parse --abbrev-ref HEAD", {
+        const { ensureBackbone: ensureBackbone2, formatBackbone: formatBackbone2 } = await Promise.resolve().then(() => (init_mapBackbone(), mapBackbone_exports));
+        const bb = await ensureBackbone2();
+        if (bb) lines.push(formatBackbone2(bb));
+      } catch {
+      }
+      try {
+        const { execSync: execSync10 } = await import("child_process");
+        const branch = execSync10("git rev-parse --abbrev-ref HEAD", {
           cwd: root,
           encoding: "utf-8",
           timeout: 2e3,
@@ -15277,23 +15876,23 @@ ${line}
     });
     const output = formatInitResults(results);
     console.log(output);
-    const fs32 = await import("fs");
-    const path35 = await import("path");
-    const matchaSkills = path35.resolve(process.cwd(), "skills/matcha/SKILL.md");
-    const matchaAgents = path35.resolve(
+    const fs35 = await import("fs");
+    const path38 = await import("path");
+    const matchaSkills = path38.resolve(process.cwd(), "skills/matcha/SKILL.md");
+    const matchaAgents = path38.resolve(
       process.cwd(),
       ".agents/skills/matcha/SKILL.md"
     );
-    const matchaRootSkills = path35.resolve(
+    const matchaRootSkills = path38.resolve(
       process.cwd(),
       "skills/matcha/SKILL.md"
     );
-    const matchaAgentsMd = path35.resolve(process.cwd(), "AGENTS.md");
-    const matchaWindsurfRules = path35.resolve(
+    const matchaAgentsMd = path38.resolve(process.cwd(), "AGENTS.md");
+    const matchaWindsurfRules = path38.resolve(
       process.cwd(),
       ".windsurf"
     );
-    if (fs32.existsSync(matchaSkills) || fs32.existsSync(matchaAgents) || fs32.existsSync(matchaRootSkills) || fs32.existsSync(matchaAgentsMd) || fs32.existsSync(matchaWindsurfRules)) {
+    if (fs35.existsSync(matchaSkills) || fs35.existsSync(matchaAgents) || fs35.existsSync(matchaRootSkills) || fs35.existsSync(matchaAgentsMd) || fs35.existsSync(matchaWindsurfRules)) {
       console.error(
         "\n\u{1F375} Hey, I see matcha is installed \u2014 they pair well together!"
       );
@@ -15307,13 +15906,13 @@ ${line}
   (async () => {
     try {
       const { generateInitMdContent: generateInitMdContent2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-      const fs32 = await import("fs");
-      const path35 = await import("path");
-      const initMdPath = path35.resolve(process.cwd(), ".kuma/init.md");
-      if (!fs32.existsSync(initMdPath)) {
-        const kumaDir = path35.dirname(initMdPath);
-        if (!fs32.existsSync(kumaDir)) fs32.mkdirSync(kumaDir, { recursive: true });
-        fs32.writeFileSync(initMdPath, generateInitMdContent2(), "utf-8");
+      const fs35 = await import("fs");
+      const path38 = await import("path");
+      const initMdPath = path38.resolve(process.cwd(), ".kuma/init.md");
+      if (!fs35.existsSync(initMdPath)) {
+        const kumaDir = path38.dirname(initMdPath);
+        if (!fs35.existsSync(kumaDir)) fs35.mkdirSync(kumaDir, { recursive: true });
+        fs35.writeFileSync(initMdPath, generateInitMdContent2(), "utf-8");
         console.error(`[${SERVER_NAME}] Auto-generated .kuma/init.md`);
       }
     } catch (err) {
@@ -15324,8 +15923,8 @@ ${line}
     try {
       const { detectAgent: detectAgent2, getSkillPath: getSkillPath2, getAgentLabel: getAgentLabel2 } = await Promise.resolve().then(() => (init_agentDetector(), agentDetector_exports));
       const { generateSkill: generateSkill2, getSecondaryFiles: getSecondaryFiles2 } = await Promise.resolve().then(() => (init_skillGenerator(), skillGenerator_exports));
-      const fs32 = await import("fs");
-      const path35 = await import("path");
+      const fs35 = await import("fs");
+      const path38 = await import("path");
       const detection = detectAgent2();
       if (!detection.primary) {
         console.error(`[${SERVER_NAME}] No AI agent detected \u2014 skipping auto-skill creation`);
@@ -15333,22 +15932,22 @@ ${line}
       }
       const agentType = detection.primary;
       const skillPath = getSkillPath2(agentType);
-      const fullPath = path35.resolve(process.cwd(), skillPath);
-      if (fs32.existsSync(fullPath)) {
+      const fullPath = path38.resolve(process.cwd(), skillPath);
+      if (fs35.existsSync(fullPath)) {
         console.error(`[${SERVER_NAME}] Skill exists for ${getAgentLabel2(agentType)} \u2014 skipping`);
         return;
       }
-      const dir = path35.dirname(fullPath);
-      if (!fs32.existsSync(dir)) fs32.mkdirSync(dir, { recursive: true });
-      fs32.writeFileSync(fullPath, generateSkill2(agentType), "utf-8");
+      const dir = path38.dirname(fullPath);
+      if (!fs35.existsSync(dir)) fs35.mkdirSync(dir, { recursive: true });
+      fs35.writeFileSync(fullPath, generateSkill2(agentType), "utf-8");
       console.error(`[${SERVER_NAME}] Auto-created ${skillPath} for ${getAgentLabel2(agentType)}`);
       const secondaryFiles = getSecondaryFiles2(agentType);
       for (const sf of secondaryFiles) {
-        const sfPath = path35.resolve(process.cwd(), sf.path);
-        const sfDir = path35.dirname(sfPath);
-        if (!fs32.existsSync(sfPath)) {
-          if (!fs32.existsSync(sfDir)) fs32.mkdirSync(sfDir, { recursive: true });
-          fs32.writeFileSync(sfPath, sf.content, "utf-8");
+        const sfPath = path38.resolve(process.cwd(), sf.path);
+        const sfDir = path38.dirname(sfPath);
+        if (!fs35.existsSync(sfPath)) {
+          if (!fs35.existsSync(sfDir)) fs35.mkdirSync(sfDir, { recursive: true });
+          fs35.writeFileSync(sfPath, sf.content, "utf-8");
           console.error(`[${SERVER_NAME}] Auto-created ${sf.path}`);
         }
       }