@plumpslabs/kuma 2.4.15 → 2.4.16

package/dist/index.js

@@ -4589,14 +4589,216 @@ 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 fs9 from "fs";
-import path11 from "path";
+import fs10 from "fs";
+import path12 from "path";
 import { execSync as execSync4 } from "child_process";
 async function graphReach(symbol, limit) {
   const rows = [];
@@ -4663,16 +4865,16 @@ function ripgrepReach(symbol, root, limit) {
     }
     for (const c of [...callers].slice(0, BERBEDA)) {
       const [fp] = c.split(":");
-      const dir = path11.dirname(fp);
-      const stem = path11.basename(fp, path11.extname(fp)).split(/[-_.]/)[0];
+      const dir = path12.dirname(fp);
+      const stem = path12.basename(fp, path12.extname(fp)).split(/[-_.]/)[0];
       try {
-        const dirFull = path11.join(root, dir);
-        if (!fs9.existsSync(dirFull)) continue;
-        for (const f of fs9.readdirSync(dirFull)) {
+        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 = path11.join(dir, f);
+            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})` });
             }
@@ -4822,17 +5024,17 @@ __export(impactAnalysis_exports, {
   classifyDiffShape: () => classifyDiffShape,
   getIndexerStatus: () => getIndexerStatus
 });
-import fs10 from "fs";
-import path12 from "path";
+import fs11 from "fs";
+import path13 from "path";
 import { execSync as execSync5 } from "child_process";
-import fastGlob3 from "fast-glob";
+import fastGlob4 from "fast-glob";
 function extOf(target) {
-  const base = path12.basename(target);
+  const base = path13.basename(target);
   const dot = base.lastIndexOf(".");
   return dot > 0 ? base.slice(dot).toLowerCase() : "";
 }
 function isExampleOrDocName(target) {
-  const base = path12.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) {
@@ -4865,7 +5067,7 @@ function classifyDiffShape(target, root) {
   return { shape: "runtime-code", detail: "runtime code change" };
 }
 async function findImportingFiles(targetFile, root) {
-  const normTarget = normalizeScope(path12.normalize(targetFile)) || path12.normalize(targetFile);
+  const normTarget = normalizeScope(path13.normalize(targetFile)) || path13.normalize(targetFile);
   try {
     const db = await getDb();
     const targetFileId = `file::${normTarget}`;
@@ -4904,10 +5106,10 @@ async function findImportingFiles(targetFile, root) {
     }
   } catch {
   }
-  const baseName = path12.basename(normTarget, path12.extname(normTarget));
-  const relTarget = path12.isAbsolute(normTarget) ? path12.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,
@@ -4922,10 +5124,10 @@ async function findImportingFiles(targetFile, root) {
       "i"
     );
     for (const f of files) {
-      if (path12.normalize(f) === path12.normalize(relTarget)) continue;
-      const fullPath = path12.join(root, f);
+      if (path13.normalize(f) === path13.normalize(relTarget)) continue;
+      const fullPath = path13.join(root, f);
       try {
-        const content = fs10.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) {
@@ -4941,7 +5143,7 @@ async function findImportingFiles(targetFile, root) {
   }
 }
 async function findRelatedTests(targetFile, root, owningPackage, additionalDependents = [], exactOnly = false) {
-  const normTarget = normalizeScope(path12.normalize(targetFile)) || path12.normalize(targetFile);
+  const normTarget = normalizeScope(path13.normalize(targetFile)) || path13.normalize(targetFile);
   try {
     const db = await getDb();
     const targetFileId = `file::${normTarget}`;
@@ -4965,13 +5167,13 @@ async function findRelatedTests(targetFile, root, owningPackage, additionalDepen
     }
   } catch {
   }
-  const baseName = path12.basename(normTarget, path12.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 = path12.basename(dep, path12.extname(dep));
+      const depBase = path13.basename(dep, path13.extname(dep));
       if (depBase) stems.add(depBase);
     }
   }
@@ -4987,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
@@ -5006,13 +5208,13 @@ async function findRelatedTests(targetFile, root, owningPackage, additionalDepen
           `**/__tests__/**/*${stem}*.*`
         );
       }
-      const pkgTests = await fastGlob3(pkgPatterns, {
-        cwd: path12.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 = path12.join(owningPackage.path, pt);
+        const fullRel = path13.join(owningPackage.path, pt);
         if (!testFiles.includes(fullRel)) {
           testFiles.push(fullRel);
         }
@@ -5063,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 = {}) {
@@ -5100,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") {
@@ -6339,27 +6559,27 @@ async function codebaseSearchFallback(query, limit = 20) {
         if (results.length >= limit || depth > MAX_WALK_DEPTH) return;
         let entries = [];
         try {
-          entries = fs34.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 = path37.join(dir, entry);
+          const full = path38.join(dir, entry);
           try {
-            const stat = fs34.statSync(full);
+            const stat = fs35.statSync(full);
             if (stat.isDirectory()) {
               walk2(full, depth + 1);
             } else if (entry.toLowerCase().includes(query.toLowerCase())) {
-              results.push(path37.relative(root, full));
+              results.push(path38.relative(root, full));
             }
           } catch {
           }
         }
       };
       var walk = walk2;
-      const fs34 = await import("fs");
-      const path37 = await import("path");
+      const fs35 = await import("fs");
+      const path38 = await import("path");
       const root = process.cwd();
       const results = [];
       const MAX_WALK_DEPTH = 8;
@@ -6641,8 +6861,8 @@ __export(kumaShared_exports, {
   isTestTool: () => isTestTool
 });
 import { execSync as execSync6 } from "child_process";
-import fs11 from "fs";
-import path13 from "path";
+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");
@@ -6748,10 +6968,10 @@ function hasVerificationEvidence(toolCalls) {
 }
 function hasVerificationInHookLog(hours = 24) {
   try {
-    const fp = path13.join(getProjectRoot(), ".kuma", "injections.jsonl");
-    if (!fs11.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 = fs11.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 {
@@ -6893,19 +7113,19 @@ __export(kumaMemory_exports, {
   scoreMemoryRelevance: () => scoreMemoryRelevance,
   shouldRecordDecision: () => shouldRecordDecision
 });
-import fs12 from "fs";
-import path14 from "path";
+import fs13 from "fs";
+import path15 from "path";
 function scoreMemoryRelevance(context, limit = 5) {
   const results = [];
-  const kumaDir = path14.join(getProjectRoot(), MEMORY_DIR);
-  if (!fs12.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 = fs12.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 = fs12.readFileSync(path14.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) {
@@ -7087,8 +7307,8 @@ __export(cacheFreshness_exports, {
   isStale: () => isStale,
   markDirty: () => markDirty
 });
-import fs13 from "fs";
-import path15 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;
@@ -7101,13 +7321,13 @@ function formatAge(savedAtMs, nowMs = Date.now()) {
   return `${Math.floor(s / 86400)}d`;
 }
 function dirtyPath() {
-  return path15.join(getProjectRoot(), DIRTY_FILE);
+  return path16.join(getProjectRoot(), DIRTY_FILE);
 }
 function loadDirty() {
   try {
     const fp = dirtyPath();
-    if (fs13.existsSync(fp)) {
-      const parsed = JSON.parse(fs13.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 {
@@ -7117,14 +7337,14 @@ function loadDirty() {
 function markDirty(filePath) {
   try {
     const fp = dirtyPath();
-    const dir = path15.dirname(fp);
-    if (!fs13.existsSync(dir)) fs13.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];
-    fs13.writeFileSync(fp, JSON.stringify(bounded), "utf-8");
+    fs14.writeFileSync(fp, JSON.stringify(bounded), "utf-8");
   } catch {
   }
 }
@@ -7134,7 +7354,7 @@ function getDirtyFiles() {
 function clearDirty() {
   try {
     const fp = dirtyPath();
-    if (fs13.existsSync(fp)) fs13.rmSync(fp, { force: true });
+    if (fs14.existsSync(fp)) fs14.rmSync(fp, { force: true });
   } catch {
   }
 }
@@ -7154,8 +7374,8 @@ var codeReuseEngine_exports = {};
 __export(codeReuseEngine_exports, {
   findReusableSymbols: () => findReusableSymbols
 });
-import path16 from "path";
-import fs14 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);
@@ -7278,7 +7498,7 @@ function detectRecommendedUtilDirectory() {
     "utils"
   ];
   for (const c of candidates) {
-    if (fs14.existsSync(path16.resolve(root, c))) {
+    if (fs15.existsSync(path17.resolve(root, c))) {
       return c;
     }
   }
@@ -7297,7 +7517,7 @@ var domainClusterEngine_exports = {};
 __export(domainClusterEngine_exports, {
   buildSubsystemClusters: () => buildSubsystemClusters
 });
-import path17 from "path";
+import path18 from "path";
 async function buildSubsystemClusters() {
   const db = await getDb();
   const fileStmt = db.prepare(`
@@ -7374,7 +7594,7 @@ async function buildSubsystemClusters() {
   for (const [cKey, files] of clusterFileMap.entries()) {
     for (const f of files) {
       fileToCluster.set(f, cKey);
-      fileToCluster.set(path17.normalize(f), cKey);
+      fileToCluster.set(path18.normalize(f), cKey);
     }
   }
   const clusterInteractions = /* @__PURE__ */ new Map();
@@ -7382,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(path17.normalize(srcFile));
-    const tgtCluster = fileToCluster.get(tgtFile) || fileToCluster.get(path17.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 };
@@ -7405,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(path17.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(path17.normalize(f)) || [];
+      const syms = fileSymbols.get(f) || fileSymbols.get(path18.normalize(f)) || [];
       for (const s of syms) {
         if (!allSyms.includes(s)) allSyms.push(s);
       }
@@ -7590,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) => path17.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();
@@ -7669,18 +7889,18 @@ __export(domainRules_exports, {
   readLayer: () => readLayer,
   writeLayer: () => writeLayer
 });
-import fs15 from "fs";
-import path18 from "path";
+import fs16 from "fs";
+import path19 from "path";
 function layerFilePath(layer) {
-  return path18.join(getProjectRoot(), ".kuma", LAYER_FILES[layer].filename);
+  return path19.join(getProjectRoot(), ".kuma", LAYER_FILES[layer].filename);
 }
 function ensureLayerFile(layer) {
   const fp = layerFilePath(layer);
-  if (!fs15.existsSync(fp)) {
+  if (!fs16.existsSync(fp)) {
     const template = layer === "arch_flow" ? ARCH_FLOW_TEMPLATE : GOTCHAS_TEMPLATE;
-    const dir = path18.dirname(fp);
-    if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
-    fs15.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;
@@ -7688,7 +7908,7 @@ function ensureLayerFile(layer) {
 function readLayer(layer) {
   try {
     const fp = ensureLayerFile(layer);
-    return fs15.readFileSync(fp, "utf-8");
+    return fs16.readFileSync(fp, "utf-8");
   } catch (err) {
     return `Error reading ${layer}: ${err}`;
   }
@@ -7696,7 +7916,7 @@ function readLayer(layer) {
 function writeLayer(layer, content) {
   try {
     const fp = ensureLayerFile(layer);
-    fs15.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.`;
@@ -7707,9 +7927,9 @@ function writeLayer(layer, content) {
 function appendToLayer(layer, entry) {
   try {
     const fp = ensureLayerFile(layer);
-    const existing = fs15.readFileSync(fp, "utf-8");
+    const existing = fs16.readFileSync(fp, "utf-8");
     const newContent = existing.trimEnd() + "\n\n" + entry.trim() + "\n";
-    fs15.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}`;
@@ -7719,7 +7939,7 @@ function getActiveGotchas() {
   const results = [];
   try {
     const fp = ensureLayerFile("gotcha");
-    const content = fs15.readFileSync(fp, "utf-8");
+    const content = fs16.readFileSync(fp, "utf-8");
     const lines = content.split("\n");
     let currentSection = "";
     let currentFilePath = "";
@@ -7755,9 +7975,9 @@ function getActiveGotchas() {
 function checkFileGotchas(filePath) {
   const gotchas = getActiveGotchas();
   const warnings = [];
-  const base = path18.basename(filePath);
+  const base = path19.basename(filePath);
   for (const g of gotchas) {
-    const gBase = path18.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})`);
@@ -7857,8 +8077,8 @@ __export(kumaInject_exports, {
   parseHookInput: () => parseHookInput,
   trackFileEditLoop: () => trackFileEditLoop
 });
-import fs16 from "fs";
-import path19 from "path";
+import fs17 from "fs";
+import path20 from "path";
 function hashFileContent(filePath) {
   return hashFile(filePath);
 }
@@ -7869,10 +8089,10 @@ function isGotchaFresh(storedHash, currentHash) {
 }
 async function getFreshGotchasForFile(filePath, limit = 5, includeStale = false) {
   const root = getProjectRoot();
-  const base = path19.basename(filePath);
+  const base = path20.basename(filePath);
   try {
-    const dbFile = path19.join(root, ".kuma", "kuma.db");
-    if (fs16.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(`
@@ -7913,11 +8133,11 @@ async function getFreshGotchasForFile(filePath, limit = 5, includeStale = false)
   } catch {
   }
   try {
-    if (!fs16.existsSync(path19.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 && path19.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) => ({
@@ -7936,8 +8156,8 @@ async function getFreshGotchasForFile(filePath, limit = 5, includeStale = false)
 async function getFileTrace(filePath, limit = 8) {
   try {
     const root = getProjectRoot();
-    const dbFile = path19.join(root, ".kuma", "kuma.db");
-    if (!fs16.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(`
@@ -7947,7 +8167,7 @@ async function getFileTrace(filePath, limit = 8) {
       ORDER BY cl.created_at DESC
       LIMIT ?
     `);
-    stmt.bind([`%${path19.basename(filePath)}%`, limit]);
+    stmt.bind([`%${path20.basename(filePath)}%`, limit]);
     const rows = [];
     while (stmt.step()) rows.push(stmt.getAsObject());
     stmt.free();
@@ -7965,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 ${path19.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", {
@@ -7981,12 +8201,12 @@ function formatFileTrace(entries, filePath) {
 async function getDecisionsForFile(filePath, limit = 3) {
   const decisions = [];
   const root = getProjectRoot();
-  const base = path19.basename(filePath);
+  const base = path20.basename(filePath);
   const baseWithoutExt = base.replace(/\.[^.]+$/, "");
   try {
-    const decisionsMdPath = path19.join(root, ".kuma", "memories", "decisions.md");
-    if (fs16.existsSync(decisionsMdPath)) {
-      const content = fs16.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;
@@ -8091,13 +8311,13 @@ async function getRelevantContext(filePath, goal) {
   if (traceStr) parts.push(traceStr);
   try {
     const root = getProjectRoot();
-    if (fs16.existsSync(path19.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([`%${path19.basename(filePath)}%`]);
+      stmt.bind([`%${path20.basename(filePath)}%`]);
       const found = stmt.step();
       const count = found ? Number(stmt.getAsObject()["COUNT(*)"]) : 0;
       stmt.free();
@@ -8108,7 +8328,7 @@ async function getRelevantContext(filePath, goal) {
   } catch {
   }
   if (gotchas.length > 0) {
-    const scopeHint = path19.basename(path19.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}" })`
     );
@@ -8124,11 +8344,11 @@ async function getRelevantContext(filePath, goal) {
 async function getFileSummary2(filePath) {
   try {
     const root = getProjectRoot();
-    const dbFile = path19.join(root, ".kuma", "kuma.db");
-    if (!fs16.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 = path19.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,
@@ -8220,9 +8440,9 @@ async function getCommandContext(command) {
 }
 function loadHookState(root) {
   try {
-    const fp = path19.join(root, HOOK_STATE_FILE);
-    if (fs16.existsSync(fp)) {
-      return JSON.parse(fs16.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 {
   }
@@ -8230,10 +8450,10 @@ function loadHookState(root) {
 }
 function saveHookState(root, state) {
   try {
-    const fp = path19.join(root, HOOK_STATE_FILE);
-    const dir = path19.dirname(fp);
-    if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-    fs16.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 {
   }
 }
@@ -8267,7 +8487,7 @@ async function trackFileEditLoop(filePath) {
   saveHookState(root, state);
   if (recorded) {
     try {
-      if (!fs16.existsSync(path19.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,
@@ -8321,8 +8541,8 @@ __export(kumaGotchas_exports, {
   syncGotchasToDb: () => syncGotchasToDb,
   tokenizeForSimilarity: () => tokenizeForSimilarity
 });
-import fs17 from "fs";
-import path20 from "path";
+import fs18 from "fs";
+import path21 from "path";
 async function ensureGotchasSchema() {
   const db = await getDb();
   db.exec(`
@@ -8744,8 +8964,8 @@ async function getActiveGotchasForCommand(command) {
 }
 async function recordInjection(params) {
   try {
-    const fp = path20.join(getProjectRoot(), ".kuma", "injections.jsonl");
-    if (!fs17.existsSync(path20.dirname(fp))) fs17.mkdirSync(path20.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,
@@ -8754,16 +8974,16 @@ async function recordInjection(params) {
       // conservative estimate: avoided re-research / re-discovery
       at: Date.now()
     });
-    fs17.appendFileSync(fp, line + "\n", "utf-8");
+    fs18.appendFileSync(fp, line + "\n", "utf-8");
   } catch {
   }
 }
 function getInjectionStats(hours = 24) {
   try {
-    const fp = path20.join(getProjectRoot(), ".kuma", "injections.jsonl");
-    if (!fs17.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 = fs17.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) {
@@ -8821,9 +9041,9 @@ async function getGotchasByStatus(status, limit = 20) {
 }
 function syncGotchaStatusToMarkdown(targetPaths, newStatus, reason) {
   try {
-    const mdPath = path20.join(getProjectRoot(), ".kuma", "KNOWN_GOTCHAS.md");
-    if (!fs17.existsSync(mdPath)) return false;
-    const content = fs17.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;
@@ -8840,9 +9060,9 @@ function syncGotchaStatusToMarkdown(targetPaths, newStatus, reason) {
           modified = true;
         }
         const headingFile = headingMatch[1].trim().toLowerCase();
-        const headingBase = path20.basename(headingFile);
+        const headingBase = path21.basename(headingFile);
         inMatchingSection = normalizedTargets.some(
-          (t) => headingFile.includes(t) || t.includes(headingFile) || headingBase === t || headingBase === path20.basename(t)
+          (t) => headingFile.includes(t) || t.includes(headingFile) || headingBase === t || headingBase === path21.basename(t)
         );
         sectionHasStatus = false;
         outputLines.push(line);
@@ -8864,7 +9084,7 @@ function syncGotchaStatusToMarkdown(targetPaths, newStatus, reason) {
       modified = true;
     }
     if (modified) {
-      fs17.writeFileSync(mdPath, outputLines.join("\n"), "utf-8");
+      fs18.writeFileSync(mdPath, outputLines.join("\n"), "utf-8");
     }
     return modified;
   } catch {
@@ -9005,24 +9225,24 @@ var kumaMaintenance_exports = {};
 __export(kumaMaintenance_exports, {
   maybeRunAutoCleanup: () => maybeRunAutoCleanup
 });
-import fs18 from "fs";
-import path21 from "path";
+import fs19 from "fs";
+import path22 from "path";
 async function maybeRunAutoCleanup() {
   try {
     const root = getProjectRoot();
-    const stateFile = path21.join(root, GC_STATE_FILE);
+    const stateFile = path22.join(root, GC_STATE_FILE);
     const now = Date.now();
     let lastRun = 0;
-    if (fs18.existsSync(stateFile)) {
+    if (fs19.existsSync(stateFile)) {
       try {
-        lastRun = JSON.parse(fs18.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 "";
-    fs18.mkdirSync(path21.dirname(stateFile), { recursive: true });
-    fs18.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));
@@ -9058,22 +9278,22 @@ __export(kumaPathRules_exports, {
   loadPathRules: () => loadPathRules,
   matchRulePath: () => matchRulePath
 });
-import fs19 from "fs";
-import path22 from "path";
+import fs20 from "fs";
+import path23 from "path";
 function rulesDir() {
-  return path22.join(getProjectRoot(), RULES_DIR);
+  return path23.join(getProjectRoot(), RULES_DIR);
 }
 function ensureRulesDir() {
   try {
     const dir = rulesDir();
-    if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+    if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
   } catch {
   }
 }
 function parseRuleFile(filePath) {
   try {
-    const raw = fs19.readFileSync(filePath, "utf-8");
-    const id = path22.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 };
@@ -9098,7 +9318,7 @@ function loadPathRules() {
   ensureRulesDir();
   try {
     const dir = rulesDir();
-    return fs19.readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => parseRuleFile(path22.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 [];
   }
@@ -9186,8 +9406,8 @@ __export(kumaFlowCache_exports, {
   getFreshDomainFlow: () => getFreshDomainFlow,
   getHopsForDomain: () => getHopsForDomain
 });
-import fs20 from "fs";
-import path23 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));
@@ -9222,26 +9442,26 @@ async function getFlowFreshness(domain) {
 }
 function resolveImport(fromFile, spec) {
   const root = getProjectRoot();
-  const fromDir = path23.dirname(fromFile);
+  const fromDir = path24.dirname(fromFile);
   const candidates = [];
   if (spec.startsWith(".")) {
-    const abs = path23.resolve(fromDir, spec);
+    const abs = path24.resolve(fromDir, spec);
     candidates.push(abs);
   } else {
-    candidates.push(path23.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 (fs20.existsSync(withExt)) return path23.relative(root, withExt);
-      if (fs20.existsSync(c) && fs20.statSync(c).isDirectory()) {
-        const idx = path23.join(c, "index") + ext;
-        if (fs20.existsSync(idx)) return path23.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 (fs20.existsSync(c)) {
+    if (fs21.existsSync(c)) {
       try {
-        if (fs20.statSync(c).isFile()) return path23.relative(root, c);
+        if (fs21.statSync(c).isFile()) return path24.relative(root, c);
       } catch {
       }
     }
@@ -9250,13 +9470,13 @@ function resolveImport(fromFile, spec) {
 }
 function deriveHopsFromImports(entryFile, maxHops = 6) {
   const root = getProjectRoot();
-  const absEntry = path23.isAbsolute(entryFile) ? entryFile : path23.resolve(root, entryFile);
-  if (!fs20.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 = path23.basename(absEntry);
+  const fromName = path24.basename(absEntry);
   try {
-    const lines = fs20.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);
@@ -9266,9 +9486,9 @@ function deriveHopsFromImports(entryFile, maxHops = 6) {
       seen.add(resolved);
       hops.push({
         from: fromName,
-        to: path23.basename(resolved),
+        to: path24.basename(resolved),
         relation: "imports",
-        description: `${fromName} imports ${path23.basename(resolved)}`
+        description: `${fromName} imports ${path24.basename(resolved)}`
       });
     }
   } catch {
@@ -9331,9 +9551,9 @@ async function getHopsForDomain(domain) {
   }
   try {
     const root = getProjectRoot();
-    const archPath = path23.join(root, ".kuma", "ARCHITECTURE_FLOW.md");
-    if (fs20.existsSync(archPath)) {
-      const content = fs20.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"));
@@ -9378,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 ${path23.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).");
@@ -9431,10 +9651,10 @@ __export(packageBriefs_exports, {
   readBrief: () => readBrief,
   refreshPackageBriefs: () => refreshPackageBriefs
 });
-import fs21 from "fs";
-import path24 from "path";
+import fs22 from "fs";
+import path25 from "path";
 function briefsDir(root) {
-  return path24.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";
@@ -9498,13 +9718,13 @@ async function refreshPackageBriefs() {
   const dir = briefsDir(root);
   try {
     const ws = await getWorkspaceInfo(root);
-    if (!fs21.existsSync(dir)) fs21.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);
-      fs21.writeFileSync(path24.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 };
@@ -9514,9 +9734,9 @@ async function refreshPackageBriefs() {
 }
 function briefFreshness(pkgName) {
   try {
-    const fp = path24.join(briefsDir(), `${slug(pkgName)}.md`);
-    if (!fs21.existsSync(fp)) return { exists: false, fresh: false, age: "missing" };
-    const ageMs = Date.now() - fs21.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" };
@@ -9524,9 +9744,9 @@ function briefFreshness(pkgName) {
 }
 function readBrief(pkgName, maxChars = 1200) {
   try {
-    const fp = path24.join(briefsDir(), `${slug(pkgName)}.md`);
-    if (!fs21.existsSync(fp)) return null;
-    const content = fs21.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;
@@ -9555,8 +9775,8 @@ __export(kumaSearch_exports, {
   formatHybridResults: () => formatHybridResults,
   hybridSearch: () => hybridSearch
 });
-import fs23 from "fs";
-import path26 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();
@@ -9619,13 +9839,13 @@ async function buildSearchVectors() {
   }
   try {
     const root = getProjectRoot();
-    const memDir = path26.join(root, ".kuma", "memories");
-    if (fs23.existsSync(memDir)) {
-      const files = fs23.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 = path26.join(memDir, file);
-          const content = fs23.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();
@@ -9636,7 +9856,7 @@ async function buildSearchVectors() {
             terms: termCounts,
             source: file.replace(/\.md$/, ""),
             sourceType: "memory",
-            recency: recencyScore(Math.floor(fs23.statSync(fullPath).mtimeMs / 1e3))
+            recency: recencyScore(Math.floor(fs24.statSync(fullPath).mtimeMs / 1e3))
           });
         } catch {
         }
@@ -9953,14 +10173,14 @@ __export(architectureGuard_exports, {
   detectWorkspaceCircularDeps: () => detectWorkspaceCircularDeps,
   loadArchitectureRules: () => loadArchitectureRules
 });
-import fs27 from "fs";
-import path30 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 = path30.join(root, ".kuma", "architecture.json");
-  if (fs27.existsSync(rulesPath)) {
+  const rulesPath = path31.join(root, ".kuma", "architecture.json");
+  if (fs28.existsSync(rulesPath)) {
     try {
-      const data = JSON.parse(fs27.readFileSync(rulesPath, "utf-8"));
+      const data = JSON.parse(fs28.readFileSync(rulesPath, "utf-8"));
       if (Array.isArray(data.rules)) {
         return data.rules;
       }
@@ -10013,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
@@ -10022,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 = path30.isAbsolute(file) ? file : path30.join(root, file);
-    if (!fs27.existsSync(fullPath)) continue;
+    const fullPath = path31.isAbsolute(file) ? file : path31.join(root, file);
+    if (!fs28.existsSync(fullPath)) continue;
     let content = "";
     try {
-      content = fs27.readFileSync(fullPath, "utf-8");
+      content = fs28.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -10036,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 = path30.normalize(path30.resolve(path30.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({
@@ -10085,26 +10305,26 @@ __export(docDrift_exports, {
   formatDocDrift: () => formatDocDrift,
   scanDocDrift: () => scanDocDrift
 });
-import fs28 from "fs";
-import path31 from "path";
+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 fs28.readdirSync(dir)) {
+      for (const f of fs29.readdirSync(dir)) {
         if (out.length >= MAX_DOCS) return;
-        const full = path31.join(dir, f);
+        const full = path32.join(dir, f);
         try {
-          if (fs28.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(path31.join(cwd, "docs"), (f) => path31.join("docs", f));
+  pushIfMd(path32.join(cwd, "docs"), (f) => path32.join("docs", f));
   pushIfMd(cwd, (f) => f);
   return out;
 }
@@ -10166,7 +10386,7 @@ function scanDocDrift(root) {
   let claims = [];
   for (const rel of collectDocFiles(cwd)) {
     try {
-      const content = fs28.readFileSync(path31.join(cwd, rel), "utf-8");
+      const content = fs29.readFileSync(path32.join(cwd, rel), "utf-8");
       if (isExemptDoc(rel, content)) {
         skipped.push(rel);
         continue;
@@ -10337,16 +10557,16 @@ __export(kumaCheckpoint_exports, {
   pruneCheckpoints: () => pruneCheckpoints,
   rollbackToCheckpoint: () => rollbackToCheckpoint
 });
-import fs29 from "fs";
-import path32 from "path";
+import fs30 from "fs";
+import path33 from "path";
 async function createCheckpoint(label, description) {
   try {
     const root = getProjectRoot();
-    const cpDir = path32.join(root, CHECKPOINT_DIR, sanitizeLabel(label));
-    if (fs29.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.`;
     }
-    fs29.mkdirSync(cpDir, { recursive: true });
+    fs30.mkdirSync(cpDir, { recursive: true });
     let gitHead;
     let isGitClean = false;
     try {
@@ -10412,15 +10632,15 @@ async function createCheckpoint(label, description) {
     }
     const files = [];
     for (const fp of candidatePaths) {
-      const fullPath = path32.resolve(root, fp);
+      const fullPath = path33.resolve(root, fp);
       try {
-        if (fs29.existsSync(fullPath) && fs29.statSync(fullPath).isFile()) {
-          const content = fs29.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 = path32.join(cpDir, "files", `${fp}.kuma-snap`);
-          const fileDir = path32.dirname(snapFile);
-          if (!fs29.existsSync(fileDir)) fs29.mkdirSync(fileDir, { recursive: true });
-          fs29.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 {
@@ -10428,7 +10648,7 @@ async function createCheckpoint(label, description) {
     }
     const db = await getDb();
     const dbData = db.export();
-    fs29.writeFileSync(path32.join(cpDir, "kuma.db"), Buffer.from(dbData));
+    fs30.writeFileSync(path33.join(cpDir, "kuma.db"), Buffer.from(dbData));
     const manifest = {
       label,
       timestamp: Date.now(),
@@ -10438,8 +10658,8 @@ async function createCheckpoint(label, description) {
       dbSnapshot: true,
       description
     };
-    fs29.writeFileSync(
-      path32.join(cpDir, "manifest.json"),
+    fs30.writeFileSync(
+      path33.join(cpDir, "manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
     );
@@ -10467,29 +10687,29 @@ async function createCheckpoint(label, description) {
 async function rollbackToCheckpoint(label) {
   try {
     const root = getProjectRoot();
-    const cpDir = path32.join(root, CHECKPOINT_DIR, sanitizeLabel(label));
-    const manifestPath = path32.join(cpDir, "manifest.json");
-    if (!fs29.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(
-      fs29.readFileSync(manifestPath, "utf-8")
+      fs30.readFileSync(manifestPath, "utf-8")
     );
     let restored = 0;
     let failed = 0;
     for (const f of manifest.files) {
-      const snapPath = path32.join(cpDir, "files", `${f.path}.kuma-snap`);
-      const legacyPath = path32.join(cpDir, "files", f.path);
-      const sourcePath = fs29.existsSync(snapPath) ? snapPath : legacyPath;
-      if (fs29.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 = fs29.readFileSync(sourcePath, "utf-8");
-          const targetPath = path32.resolve(root, f.path);
-          const targetDir = path32.dirname(targetPath);
-          if (!fs29.existsSync(targetDir)) fs29.mkdirSync(targetDir, { recursive: true });
-          fs29.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++;
@@ -10510,12 +10730,12 @@ ${listCheckpoints()}`;
         failed++;
       }
     }
-    const dbSnapshotPath = path32.join(cpDir, "kuma.db");
-    if (fs29.existsSync(dbSnapshotPath)) {
-      const kumaDir = path32.join(root, ".kuma");
-      const dbPath = path32.join(kumaDir, "kuma.db");
-      const snapshotData = fs29.readFileSync(dbSnapshotPath);
-      fs29.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", {
@@ -10540,18 +10760,18 @@ ${listCheckpoints()}`;
 function listCheckpoints() {
   try {
     const root = getProjectRoot();
-    const cpDir = path32.join(root, CHECKPOINT_DIR);
-    if (!fs29.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 = fs29.readdirSync(cpDir);
+    const entries = fs30.readdirSync(cpDir);
     const checkpoints = [];
     for (const entry of entries) {
-      const manifestPath = path32.join(cpDir, entry, "manifest.json");
-      if (fs29.existsSync(manifestPath)) {
+      const manifestPath = path33.join(cpDir, entry, "manifest.json");
+      if (fs30.existsSync(manifestPath)) {
         try {
           const manifest = JSON.parse(
-            fs29.readFileSync(manifestPath, "utf-8")
+            fs30.readFileSync(manifestPath, "utf-8")
           );
           checkpoints.push({ label: entry, manifest });
         } catch {
@@ -10583,12 +10803,12 @@ function listCheckpoints() {
 function pruneCheckpoints(keep = 5) {
   try {
     const root = getProjectRoot();
-    const cpDir = path32.join(root, CHECKPOINT_DIR);
-    if (!fs29.existsSync(cpDir)) return "\u{1F4ED} No checkpoints to prune.";
-    const entries = fs29.readdirSync(cpDir).map((e) => ({ name: e, time: fs29.statSync(path32.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++) {
-      fs29.rmSync(path32.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.";
@@ -10613,9 +10833,9 @@ function isRiskyEditPath(filePath) {
 }
 function loadAutoCpDone(root) {
   try {
-    const fp = path32.join(root, AUTO_CP_STATE);
-    if (fs29.existsSync(fp)) {
-      const parsed = JSON.parse(fs29.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 {
@@ -10624,10 +10844,10 @@ function loadAutoCpDone(root) {
 }
 function saveAutoCpDone(root, done) {
   try {
-    const fp = path32.join(root, AUTO_CP_STATE);
-    const parsed = fs29.existsSync(fp) ? JSON.parse(fs29.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;
-    fs29.writeFileSync(fp, JSON.stringify(parsed), "utf-8");
+    fs30.writeFileSync(fp, JSON.stringify(parsed), "utf-8");
   } catch {
   }
 }
@@ -10637,14 +10857,14 @@ function maybeAutoCheckpoint(filePath) {
     const root = getProjectRoot();
     const done = loadAutoCpDone(root);
     if (done[filePath]) return null;
-    const abs = path32.isAbsolute(filePath) ? filePath : path32.join(root, filePath);
-    if (!fs29.existsSync(abs) || !fs29.statSync(abs).isFile()) return null;
-    const label = `auto-pre-${sanitizeLabel(path32.basename(filePath))}`;
-    const cpDir = path32.join(root, CHECKPOINT_DIR, label);
-    if (!fs29.existsSync(cpDir)) fs29.mkdirSync(cpDir, { recursive: true });
-    fs29.copyFileSync(abs, path32.join(cpDir, path32.basename(abs)));
-    fs29.writeFileSync(
-      path32.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(),
@@ -10684,8 +10904,8 @@ __export(init_exports, {
   generateInitMdContent: () => generateInitMdContent,
   runInit: () => runInit
 });
-import fs30 from "fs";
-import path33 from "path";
+import fs31 from "fs";
+import path34 from "path";
 function configFilePath(type) {
   switch (type) {
     case "claude":
@@ -11319,21 +11539,21 @@ function handleOpencodeSecondary(root, results) {
     "",
     "\u{1F4D6} Full rules: `.kuma/init.md`"
   ].join("\n");
-  const skillPath = path33.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 = path33.dirname(skillPath);
-      if (fs30.existsSync(skillPath)) {
-        const existing = fs30.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 {
-          fs30.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 (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-        fs30.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) {
@@ -11345,21 +11565,21 @@ function handleOpencodeSecondary(root, results) {
       });
     }
   }
-  const opencodeSkillPath = path33.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 = path33.dirname(opencodeSkillPath);
-      if (fs30.existsSync(opencodeSkillPath)) {
-        const existing = fs30.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 {
-          fs30.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 (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-        fs30.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) {
@@ -11371,21 +11591,21 @@ function handleOpencodeSecondary(root, results) {
       });
     }
   }
-  const pluginPath = path33.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 = path33.dirname(pluginPath);
-      if (fs30.existsSync(pluginPath)) {
-        const existing = fs30.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 {
-          fs30.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 (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-        fs30.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) {
@@ -11399,21 +11619,21 @@ function handleOpencodeSecondary(root, results) {
   }
 }
 function handleCodexSecondary(root, results) {
-  const tomlPath = path33.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 = path33.dirname(tomlPath);
-    if (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-    if (fs30.existsSync(tomlPath)) {
-      const existingContent = fs30.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;
       }
-      fs30.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 {
-      fs30.writeFileSync(tomlPath, codexConfigTomlTemplate(), "utf-8");
+      fs31.writeFileSync(tomlPath, codexConfigTomlTemplate(), "utf-8");
       results.push({ type: "codex", filePath: ".codex/config.toml", action: "created" });
     }
   } catch (err) {
@@ -11426,11 +11646,11 @@ function handleCodexSecondary(root, results) {
   }
 }
 function handleQwenSecondary(root, results) {
-  const settingsPath = path33.resolve(root, "settings.json");
+  const settingsPath = path34.resolve(root, "settings.json");
   if (results.some((r) => r.filePath === "settings.json")) return;
   try {
-    if (fs30.existsSync(settingsPath)) {
-      const existingContent = fs30.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 {
@@ -11438,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: {} };
-              fs30.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;
             }
@@ -11453,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: {} };
-          fs30.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 {
-      fs30.writeFileSync(settingsPath, qwenSettingsTemplate(), "utf-8");
+      fs31.writeFileSync(settingsPath, qwenSettingsTemplate(), "utf-8");
       results.push({ type: "qwen", filePath: "settings.json", action: "created" });
     }
   } catch (err) {
@@ -11561,12 +11781,12 @@ function getCombinedAgentsMd(selectedTypes) {
   return lines.join("\n");
 }
 function handleAntigravityMcpConfig(root, results) {
-  const mcpPath = path33.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 = path33.dirname(mcpPath);
-    if (fs30.existsSync(mcpPath)) {
-      const existingContent = fs30.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;
@@ -11575,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: {} };
-        fs30.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 (!fs30.existsSync(mcpDir)) fs30.mkdirSync(mcpDir, { recursive: true });
-      fs30.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) {
@@ -11595,21 +11815,21 @@ function handleAntigravityMcpConfig(root, results) {
   }
 }
 function handleAntigravityRules(root, results) {
-  const rulePath = path33.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 = path33.dirname(rulePath);
-    if (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-    if (fs30.existsSync(rulePath)) {
-      const existing = fs30.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;
       }
-      fs30.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 {
-      fs30.writeFileSync(rulePath, antigravityRuleTemplate(), "utf-8");
+      fs31.writeFileSync(rulePath, antigravityRuleTemplate(), "utf-8");
       results.push({ type: "antigravity", filePath: ".agents/rules/kuma.md", action: "created" });
     }
   } catch (err) {
@@ -11622,19 +11842,19 @@ function handleAntigravityRules(root, results) {
   }
 }
 function handleGeminiMd(root, results) {
-  const geminiPath = path33.resolve(root, "GEMINI.md");
+  const geminiPath = path34.resolve(root, "GEMINI.md");
   if (results.some((r) => r.filePath === "GEMINI.md")) return;
   try {
-    if (fs30.existsSync(geminiPath)) {
-      const existing = fs30.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;
       }
-      fs30.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 {
-      fs30.writeFileSync(geminiPath, geminiTemplate(), "utf-8");
+      fs31.writeFileSync(geminiPath, geminiTemplate(), "utf-8");
       results.push({ type: "antigravity", filePath: "GEMINI.md", action: "created" });
     }
   } catch (err) {
@@ -11652,19 +11872,19 @@ function handleAntigravitySecondary(root, results) {
   handleGeminiMd(root, results);
 }
 function handleWindsurfSecondary(root, results) {
-  const rulesPath = path33.resolve(root, ".windsurfrules");
+  const rulesPath = path34.resolve(root, ".windsurfrules");
   if (results.some((r) => r.filePath === ".windsurfrules")) return;
   try {
-    if (fs30.existsSync(rulesPath)) {
-      const existing = fs30.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;
       }
-      fs30.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 {
-      fs30.writeFileSync(rulesPath, windsurfrulesTemplate(), "utf-8");
+      fs31.writeFileSync(rulesPath, windsurfrulesTemplate(), "utf-8");
       results.push({ type: "windsurf", filePath: ".windsurfrules", action: "created" });
     }
   } catch (err) {
@@ -11677,21 +11897,21 @@ function handleWindsurfSecondary(root, results) {
   }
 }
 function handleClineSecondary(root, results) {
-  const rooPath = path33.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 = path33.dirname(rooPath);
-      if (fs30.existsSync(rooPath)) {
-        const existing = fs30.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 {
-          fs30.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 (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-        fs30.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) {
@@ -11703,21 +11923,21 @@ function handleClineSecondary(root, results) {
       });
     }
   }
-  const traePath = path33.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 = path33.dirname(traePath);
-      if (fs30.existsSync(traePath)) {
-        const existing = fs30.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 {
-          fs30.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 (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-        fs30.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) {
@@ -11729,21 +11949,21 @@ function handleClineSecondary(root, results) {
       });
     }
   }
-  const qoderPath = path33.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 = path33.dirname(qoderPath);
-      if (fs30.existsSync(qoderPath)) {
-        const existing = fs30.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 {
-          fs30.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 (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-        fs30.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) {
@@ -11757,18 +11977,18 @@ function handleClineSecondary(root, results) {
   }
 }
 function handleAiderSecondary(root, results) {
-  const ymlPath = path33.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 (fs30.existsSync(ymlPath)) {
-      const existingContent = fs30.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";
-      fs30.writeFileSync(ymlPath, newContent, "utf-8");
+      fs31.writeFileSync(ymlPath, newContent, "utf-8");
       results.push({ type: "aider", filePath: ".aider.conf.yml", action: "appended" });
     } else {
       const content = [
@@ -11778,7 +11998,7 @@ function handleAiderSecondary(root, results) {
         conventionsRef,
         ""
       ].join("\n");
-      fs30.writeFileSync(ymlPath, content, "utf-8");
+      fs31.writeFileSync(ymlPath, content, "utf-8");
       results.push({ type: "aider", filePath: ".aider.conf.yml", action: "created" });
     }
   } catch (err) {
@@ -11791,10 +12011,10 @@ function handleAiderSecondary(root, results) {
   }
 }
 function handleCopilotSecondary(root, results) {
-  const skillPath = path33.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 = path33.dirname(skillPath);
+    const dir = path34.dirname(skillPath);
     const content = [
       "---",
       "name: kuma-mcp",
@@ -11805,17 +12025,17 @@ function handleCopilotSecondary(root, results) {
       "",
       "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
     ].join("\n");
-    if (fs30.existsSync(skillPath)) {
-      const existingContent = fs30.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;
       }
-      fs30.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 (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-      fs30.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) {
@@ -11828,21 +12048,21 @@ function handleCopilotSecondary(root, results) {
   }
 }
 function handleOpenclawSecondary(root, results) {
-  const mcpPath = path33.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 = path33.dirname(mcpPath);
-    if (fs30.existsSync(mcpPath)) {
-      const existingContent = fs30.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: {} };
-      fs30.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 (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-      fs30.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) {
@@ -11855,20 +12075,20 @@ function handleOpenclawSecondary(root, results) {
   }
 }
 function handleInitMdGeneration(root, results) {
-  const initMdPath = path33.resolve(root, ".kuma/init.md");
+  const initMdPath = path34.resolve(root, ".kuma/init.md");
   try {
-    const kumaDir = path33.dirname(initMdPath);
-    if (!fs30.existsSync(kumaDir)) fs30.mkdirSync(kumaDir, { recursive: true });
-    if (fs30.existsSync(initMdPath)) {
-      const existing = fs30.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;
       }
-      fs30.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 {
-      fs30.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
+      fs31.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
       results.push({ type: "claude", filePath: ".kuma/init.md", action: "created" });
     }
   } catch (err) {
@@ -11881,20 +12101,20 @@ function handleInitMdGeneration(root, results) {
   }
 }
 function handleCodewhaleSecondary(root, results) {
-  const mcpPath = path33.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 = path33.dirname(mcpPath);
-    if (fs30.existsSync(mcpPath)) {
-      const existingContent = fs30.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: {} };
-      fs30.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 (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
+      if (!fs31.existsSync(dir)) fs31.mkdirSync(dir, { recursive: true });
       const config = {
         mcpServers: {
           kuma: {
@@ -11904,7 +12124,7 @@ function handleCodewhaleSecondary(root, results) {
           }
         }
       };
-      fs30.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) {
@@ -11917,7 +12137,7 @@ function handleCodewhaleSecondary(root, results) {
   }
 }
 function handleClaudeSecondary(root, results) {
-  const settingsPath = path33.resolve(root, ".claude", "settings.json");
+  const settingsPath = path34.resolve(root, ".claude", "settings.json");
   const hookBlock = {
     hooks: {
       PreToolUse: [
@@ -11948,8 +12168,8 @@ function handleClaudeSecondary(root, results) {
     }
   };
   try {
-    if (fs30.existsSync(settingsPath)) {
-      const existing = JSON.parse(fs30.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) {
@@ -11973,12 +12193,12 @@ function handleClaudeSecondary(root, results) {
         ...existing,
         hooks: { ...existingHooks, PreToolUse: mergedPre, SessionStart: mergedStart, PreCompact: mergedCompact }
       };
-      fs30.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 = path33.dirname(settingsPath);
-      if (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-      fs30.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) {
@@ -11989,10 +12209,10 @@ function handleClaudeSecondary(root, results) {
       error: err instanceof Error ? err.message : String(err)
     });
   }
-  const skillPath = path33.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 = path33.dirname(skillPath);
+      const dir = path34.dirname(skillPath);
       const content = [
         "---",
         "name: kuma-mcp",
@@ -12004,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 (fs30.existsSync(skillPath)) {
-        const existing = fs30.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 {
-          fs30.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 (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-        fs30.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) {
@@ -12028,27 +12248,27 @@ function handleClaudeSecondary(root, results) {
   }
 }
 function writeHooksFile(root, relPath, type, results, build) {
-  const fullPath = path33.resolve(root, relPath);
+  const fullPath = path34.resolve(root, relPath);
   try {
     let existing = {};
     let existed = false;
-    if (fs30.existsSync(fullPath)) {
+    if (fs31.existsSync(fullPath)) {
       existed = true;
       try {
-        existing = JSON.parse(fs30.readFileSync(fullPath, "utf-8"));
+        existing = JSON.parse(fs31.readFileSync(fullPath, "utf-8"));
       } catch {
         existing = {};
       }
     } else {
-      const dir = path33.dirname(fullPath);
-      if (!fs30.existsSync(dir)) fs30.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;
     }
-    fs30.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) });
@@ -12129,18 +12349,18 @@ function handleCodexHooks(root, results) {
   });
 }
 function handleCursorGotchaRules(root, results) {
-  const rulesDir2 = path33.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 (fs30.existsSync(rulesDir2)) {
-      for (const f of fs30.readdirSync(rulesDir2)) {
+    if (fs31.existsSync(rulesDir2)) {
+      for (const f of fs31.readdirSync(rulesDir2)) {
         if (f.endsWith(".mdc")) {
           try {
-            fs30.rmSync(path33.join(rulesDir2, f), { force: true });
+            fs31.rmSync(path34.join(rulesDir2, f), { force: true });
           } catch {
           }
         }
@@ -12150,7 +12370,7 @@ function handleCursorGotchaRules(root, results) {
       results.push({ type: "cursor", filePath: ".cursor/rules/kuma-gotchas/", action: "skipped" });
       return;
     }
-    fs30.mkdirSync(rulesDir2, { recursive: true });
+    fs31.mkdirSync(rulesDir2, { recursive: true });
     const seen = /* @__PURE__ */ new Set();
     let created = 0;
     for (const g of gotchas) {
@@ -12171,7 +12391,7 @@ function handleCursorGotchaRules(root, results) {
         "`kuma_context({ action: 'history', target: '<file>' })`",
         ""
       ].join("\n");
-      fs30.writeFileSync(path33.join(rulesDir2, `${slug2}.mdc`), md, "utf-8");
+      fs31.writeFileSync(path34.join(rulesDir2, `${slug2}.mdc`), md, "utf-8");
       created++;
     }
     results.push({
@@ -12198,28 +12418,28 @@ function runInit(options) {
   let agentsMdHandled = false;
   for (const type of selected) {
     const relativePath = configFilePath(type);
-    const fullPath = path33.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 (fs30.existsSync(fullPath)) {
+        if (fs31.existsSync(fullPath)) {
           if (options.skipExisting) {
             results.push({ type, filePath: relativePath, action: "skipped" });
           } else {
-            const existingContent = fs30.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 {
-              fs30.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 = path33.dirname(fullPath);
-          if (!fs30.existsSync(dir)) fs30.mkdirSync(dir, { recursive: true });
-          fs30.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);
@@ -12231,12 +12451,12 @@ function runInit(options) {
         continue;
       } else {
         const template = getTemplate();
-        if (fs30.existsSync(fullPath)) {
+        if (fs31.existsSync(fullPath)) {
           if (options.skipExisting) {
             results.push({ type, filePath: relativePath, action: "skipped" });
             continue;
           }
-          const existingContent = fs30.readFileSync(fullPath, "utf-8");
+          const existingContent = fs31.readFileSync(fullPath, "utf-8");
           if (existingContent.includes("_Generated by Kuma MCP_")) {
             if (type === "antigravity") {
               handleAntigravitySecondary(root, results);
@@ -12253,14 +12473,14 @@ function runInit(options) {
             continue;
           }
           const newContent = existingContent.trimEnd() + APPEND_SEPARATOR + template;
-          fs30.writeFileSync(fullPath, newContent, "utf-8");
+          fs31.writeFileSync(fullPath, newContent, "utf-8");
           results.push({ type, filePath: relativePath, action: "appended" });
         } else {
-          const dir = path33.dirname(fullPath);
-          if (!fs30.existsSync(dir)) {
-            fs30.mkdirSync(dir, { recursive: true });
+          const dir = path34.dirname(fullPath);
+          if (!fs31.existsSync(dir)) {
+            fs31.mkdirSync(dir, { recursive: true });
           }
-          fs30.writeFileSync(fullPath, template, "utf-8");
+          fs31.writeFileSync(fullPath, template, "utf-8");
           results.push({ type, filePath: relativePath, action: "created" });
         }
         if (type === "antigravity") {
@@ -12432,8 +12652,8 @@ var compactionContext_exports = {};
 __export(compactionContext_exports, {
   getCompactionContext: () => getCompactionContext
 });
-import fs31 from "fs";
-import path34 from "path";
+import fs32 from "fs";
+import path35 from "path";
 async function getCompactionContext() {
   const parts = [];
   try {
@@ -12446,8 +12666,8 @@ async function getCompactionContext() {
   } catch {
   }
   try {
-    const dbFile = path34.join(getProjectRoot(), ".kuma", "kuma.db");
-    if (fs31.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(
@@ -12473,9 +12693,9 @@ async function getCompactionContext() {
   } catch {
   }
   try {
-    const cpDir = path34.join(getProjectRoot(), ".kuma", "checkpoints");
-    if (fs31.existsSync(cpDir)) {
-      const cps = fs31.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 {
@@ -12503,22 +12723,22 @@ __export(kumaDaemon_exports, {
   daemonStop: () => daemonStop,
   daemonTick: () => daemonTick
 });
-import fs32 from "fs";
-import path35 from "path";
+import fs33 from "fs";
+import path36 from "path";
 import { spawn } from "child_process";
 function paths(root) {
   const r = root || getProjectRoot();
   return {
-    pid: path35.join(r, PID_FILE),
-    status: path35.join(r, STATUS_FILE),
-    log: path35.join(r, LOG_FILE)
+    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 (!fs32.existsSync(fp)) return null;
-    const pid = Number(fs32.readFileSync(fp, "utf-8").trim());
+    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;
@@ -12536,6 +12756,12 @@ 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);
@@ -12569,8 +12795,8 @@ async function daemonTick(root) {
   };
   try {
     let prev = {};
-    if (fs32.existsSync(p.status)) prev = JSON.parse(fs32.readFileSync(p.status, "utf-8"));
-    fs32.writeFileSync(p.status, JSON.stringify({ ...prev, ...status }, null, 2), "utf-8");
+    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 ");
@@ -12580,7 +12806,7 @@ async function runLoop(intervalMs) {
   const p = paths(r);
   const log = (msg) => {
     try {
-      fs32.appendFileSync(p.log, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+      fs33.appendFileSync(p.log, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `, "utf-8");
     } catch {
     }
@@ -12611,8 +12837,8 @@ async function daemonStart(intervalMs = DEFAULT_INTERVAL_MS, root) {
   });
   child.unref();
   try {
-    fs32.writeFileSync(p.pid, String(child.pid), "utf-8");
-    fs32.writeFileSync(
+    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"
@@ -12628,7 +12854,7 @@ async function daemonStop(root) {
   if (!pid) return "\u{1F43B} Daemon not running (no pid file).";
   if (!isAlive(pid)) {
     try {
-      fs32.rmSync(p.pid, { force: true });
+      fs33.rmSync(p.pid, { force: true });
     } catch {
     }
     return "\u{1F43B} Daemon pid file was stale \u2014 cleaned up (process already gone).";
@@ -12636,7 +12862,7 @@ async function daemonStop(root) {
   try {
     process.kill(pid, "SIGTERM");
     try {
-      fs32.rmSync(p.pid, { force: true });
+      fs33.rmSync(p.pid, { force: true });
     } catch {
     }
     return `\u{1F43B} Daemon stopped (was pid ${pid}).`;
@@ -12650,7 +12876,7 @@ async function daemonStatus(root) {
   const pid = readPid(r);
   let status = { running: false, pid: null, startedAt: null, lastRunAt: null, lastResult: null, intervalMs: DEFAULT_INTERVAL_MS };
   try {
-    if (fs32.existsSync(p.status)) status = { ...status, ...JSON.parse(fs32.readFileSync(p.status, "utf-8")) };
+    if (fs33.existsSync(p.status)) status = { ...status, ...JSON.parse(fs33.readFileSync(p.status, "utf-8")) };
   } catch {
   }
   const alive = pid !== null && isAlive(pid);
@@ -12685,19 +12911,19 @@ __export(agentDetector_exports, {
   getSkillPath: () => getSkillPath,
   skillExists: () => skillExists
 });
-import fs33 from "fs";
-import path36 from "path";
+import fs34 from "fs";
+import path37 from "path";
 function checkFile(root, filePath) {
   try {
-    return fs33.existsSync(path36.join(root, filePath));
+    return fs34.existsSync(path37.join(root, filePath));
   } catch {
     return false;
   }
 }
 function checkDir(root, dirPath) {
   try {
-    const fullPath = path36.join(root, dirPath);
-    return fs33.existsSync(fullPath) && fs33.statSync(fullPath).isDirectory();
+    const fullPath = path37.join(root, dirPath);
+    return fs34.existsSync(fullPath) && fs34.statSync(fullPath).isDirectory();
   } catch {
     return false;
   }
@@ -12765,7 +12991,7 @@ function getAgentLabel(type) {
 function skillExists(type, projectRoot) {
   const root = projectRoot ?? getProjectRoot();
   const skillPath = getSkillPath(type);
-  return fs33.existsSync(path36.join(root, skillPath));
+  return fs34.existsSync(path37.join(root, skillPath));
 }
 var AGENT_DETECTORS;
 var init_agentDetector = __esm({
@@ -13361,8 +13587,8 @@ init_kumaGraph();
 init_kumaMemory();
 init_kumaDriftDetector();
 init_pathValidator();
-import fs22 from "fs";
-import path25 from "path";
+import fs23 from "fs";
+import path26 from "path";
 var CONTEXT_ALIASES = {
   "research": "research",
   "search": "research",
@@ -13481,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 = [
@@ -13490,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.`);
@@ -13689,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");
@@ -13814,7 +14058,7 @@ ${gitHistory}`);
     try {
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
       const db = await getDb2();
-      const base = path25.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 ?)
@@ -13827,9 +14071,9 @@ ${gitHistory}`);
       if (resolved.length === 0) {
         try {
           const { getProjectRoot: getProjectRoot2 } = await Promise.resolve().then(() => (init_pathValidator(), pathValidator_exports));
-          const mdPath = path25.join(getProjectRoot2(), ".kuma", "KNOWN_GOTCHAS.md");
-          if (fs22.existsSync(mdPath)) {
-            const mdContent = fs22.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();
@@ -13901,8 +14145,8 @@ init_kumaDb();
 init_kumaMemory();
 init_pathValidator();
 init_pathValidator();
-import fs24 from "fs";
-import path27 from "path";
+import fs25 from "fs";
+import path28 from "path";
 var MEMORY_ALIASES = {
   "decision": "decision",
   "adr": "decision",
@@ -14013,9 +14257,9 @@ async function handleResearchSave(params) {
   } catch {
   }
   try {
-    const researchDir = path27.join(getProjectRoot(), ".kuma", "research");
-    if (!fs24.existsSync(researchDir)) fs24.mkdirSync(researchDir, { recursive: true });
-    fs24.writeFileSync(path27.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");
@@ -14211,8 +14455,8 @@ init_sessionMemory();
 init_pathValidator();
 init_sessionMemory();
 init_kumaShared();
-import fs25 from "fs";
-import path28 from "path";
+import fs26 from "fs";
+import path29 from "path";
 import { execSync as execSync7 } from "child_process";
 var SCRIPT_PATCH_PATTERNS = [
   "writeFileSync",
@@ -14239,20 +14483,20 @@ function findPatchScripts(projectRoot) {
   const warnings = [];
   const recentFiles = scanRecentFiles(projectRoot);
   for (const file of recentFiles) {
-    const ext = path28.extname(file).toLowerCase();
+    const ext = path29.extname(file).toLowerCase();
     if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
-    const relativePath = path28.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 = fs25.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: ${path28.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
@@ -14286,15 +14530,15 @@ function detectBashGrepUsage() {
 function scanRecentFiles(projectRoot) {
   const recent = [];
   try {
-    const entries = fs25.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 = fs25.statSync(path28.join(projectRoot, entry.name));
+        const stat = fs26.statSync(path29.join(projectRoot, entry.name));
         if (now - stat.mtimeMs < recentThreshold || now - stat.ctimeMs < recentThreshold) {
-          recent.push(path28.join(projectRoot, entry.name));
+          recent.push(path29.join(projectRoot, entry.name));
         }
       } catch {
         continue;
@@ -14318,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 = path28.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 = path28.join(projectRoot, file);
-        if (fs25.existsSync(fullPath)) {
-          const content = fs25.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({
@@ -14348,7 +14592,7 @@ function detectGitPatchScripts(projectRoot) {
     if (deletedStdout) {
       const deletedFiles = deletedStdout.split("\n").filter(Boolean);
       for (const file of deletedFiles) {
-        const ext = path28.extname(file).toLowerCase();
+        const ext = path29.extname(file).toLowerCase();
         if (SCRIPT_EXTENSIONS.includes(ext)) {
           warnings.push({
             severity: "high",
@@ -14410,21 +14654,21 @@ function detectAllAntiPatterns() {
 // src/engine/contextSnapshot.ts
 init_sessionMemory();
 init_pathValidator();
-import fs26 from "fs";
-import path29 from "path";
+import fs27 from "fs";
+import path30 from "path";
 import { execSync as execSync8 } from "child_process";
 var SNAPSHOT_DIR = "context-snapshots";
 function snapshotDir() {
-  return path29.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
+  return path30.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
 }
 function ensureSnapshotDir() {
   const dir = snapshotDir();
-  if (!fs26.existsSync(dir)) {
-    fs26.mkdirSync(dir, { recursive: true });
+  if (!fs27.existsSync(dir)) {
+    fs27.mkdirSync(dir, { recursive: true });
   }
 }
 function snapshotFilePath(timestamp) {
-  return path29.join(snapshotDir(), `${timestamp}.json`);
+  return path30.join(snapshotDir(), `${timestamp}.json`);
 }
 function saveSnapshot(goal) {
   try {
@@ -14445,7 +14689,7 @@ function saveSnapshot(goal) {
     hasConventions: !!summary.hasConventions
   };
   try {
-    fs26.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 });
@@ -15238,14 +15482,14 @@ async function main() {
     console.error("");
     let killedCount = 0;
     try {
-      const path37 = await import("path");
-      const fs34 = await import("fs");
-      const lockDir = path37.resolve(process.cwd(), ".kuma/verifier.lock");
-      if (fs34.existsSync(lockDir)) {
-        const pidFile = path37.join(lockDir, "pid");
-        if (fs34.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(fs34.readFileSync(pidFile, "utf-8"), 10);
+            const pid = parseInt(fs35.readFileSync(pidFile, "utf-8"), 10);
             if (pid && pid !== process.pid) {
               try {
                 process.kill(-pid, "SIGKILL");
@@ -15261,7 +15505,7 @@ async function main() {
           } catch {
           }
         }
-        fs34.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.");
@@ -15506,6 +15750,12 @@ ${line}
       const root = getProjectRoot2();
       const proj = root.split("/").pop() || "unknown";
       const lines = [`\u{1F43B} [Kuma session brief] ${proj}`];
+      try {
+        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", {
@@ -15626,23 +15876,23 @@ ${line}
     });
     const output = formatInitResults(results);
     console.log(output);
-    const fs34 = await import("fs");
-    const path37 = await import("path");
-    const matchaSkills = path37.resolve(process.cwd(), "skills/matcha/SKILL.md");
-    const matchaAgents = path37.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 = path37.resolve(
+    const matchaRootSkills = path38.resolve(
       process.cwd(),
       "skills/matcha/SKILL.md"
     );
-    const matchaAgentsMd = path37.resolve(process.cwd(), "AGENTS.md");
-    const matchaWindsurfRules = path37.resolve(
+    const matchaAgentsMd = path38.resolve(process.cwd(), "AGENTS.md");
+    const matchaWindsurfRules = path38.resolve(
       process.cwd(),
       ".windsurf"
     );
-    if (fs34.existsSync(matchaSkills) || fs34.existsSync(matchaAgents) || fs34.existsSync(matchaRootSkills) || fs34.existsSync(matchaAgentsMd) || fs34.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!"
       );
@@ -15656,13 +15906,13 @@ ${line}
   (async () => {
     try {
       const { generateInitMdContent: generateInitMdContent2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-      const fs34 = await import("fs");
-      const path37 = await import("path");
-      const initMdPath = path37.resolve(process.cwd(), ".kuma/init.md");
-      if (!fs34.existsSync(initMdPath)) {
-        const kumaDir = path37.dirname(initMdPath);
-        if (!fs34.existsSync(kumaDir)) fs34.mkdirSync(kumaDir, { recursive: true });
-        fs34.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) {
@@ -15673,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 fs34 = await import("fs");
-      const path37 = 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`);
@@ -15682,22 +15932,22 @@ ${line}
       }
       const agentType = detection.primary;
       const skillPath = getSkillPath2(agentType);
-      const fullPath = path37.resolve(process.cwd(), skillPath);
-      if (fs34.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 = path37.dirname(fullPath);
-      if (!fs34.existsSync(dir)) fs34.mkdirSync(dir, { recursive: true });
-      fs34.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 = path37.resolve(process.cwd(), sf.path);
-        const sfDir = path37.dirname(sfPath);
-        if (!fs34.existsSync(sfPath)) {
-          if (!fs34.existsSync(sfDir)) fs34.mkdirSync(sfDir, { recursive: true });
-          fs34.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}`);
         }
       }