@plumpslabs/kuma 2.3.5 → 2.3.7

package/dist/{chunk-PH4JKL6T.js → chunk-BI7KD3SG.js}

@@ -320,7 +320,7 @@ No unresolved issues.`;
    */
   async autoTrackToDb(toolName, params, timestamp) {
     try {
-      const { getDb, saveDb } = await import("./kumaDb-FQ3YKJ6K.js");
+      const { getDb, saveDb } = await import("./kumaDb-DJUDLYBJ.js");
       const db = await getDb();
       db.run(
         `INSERT INTO tool_calls (tool_name, params, success, duration_ms, created_at) VALUES (?, ?, 1, 0, ?)`,
@@ -466,14 +466,14 @@ No unresolved issues.`;
     const memoriesDir = this.memoriesDir();
     if (fs.existsSync(memoriesDir)) {
       try {
-        const files = fs.readdirSync(memoriesDir);
+        const files = fs.readdirSync(memoriesDir).filter((f) => f.endsWith(".md")).slice(0, 3);
         for (const file of files) {
-          if (!file.endsWith(".md")) continue;
           const filePath = path.join(memoriesDir, file);
           try {
             const content = fs.readFileSync(filePath, "utf-8");
             const lines = content.split("\n");
-            for (let i = 0; i < lines.length; i++) {
+            const maxLinesPerFile = 500;
+            for (let i = 0; i < Math.min(lines.length, maxLinesPerFile); i++) {
               if (lines[i].toLowerCase().includes(q)) {
                 const topicName = file.replace(/\.md$/, "");
                 results.push({
@@ -571,10 +571,18 @@ No unresolved issues.`;
     if (recentCalls.length < 6) return { isLooping: false };
     const toolCounts = /* @__PURE__ */ new Map();
     for (const call of recentCalls) {
-      toolCounts.set(call.toolName, (toolCounts.get(call.toolName) ?? 0) + 1);
+      const existing = toolCounts.get(call.toolName);
+      const action = call.params.action || "";
+      if (existing) {
+        existing.count++;
+        existing.actions.add(action);
+      } else {
+        toolCounts.set(call.toolName, { count: 1, actions: /* @__PURE__ */ new Set([action]) });
+      }
     }
-    for (const [toolName, count] of toolCounts) {
+    for (const [toolName, { count, actions }] of toolCounts) {
       if (count >= 4) {
+        if (actions.size >= 3) continue;
         return {
           isLooping: true,
           toolName,
@@ -597,7 +605,7 @@ No unresolved issues.`;
       this.addModifiedFile(filePath);
     }
     try {
-      const { recordChange } = await import("./kumaDb-FQ3YKJ6K.js");
+      const { recordChange } = await import("./kumaDb-DJUDLYBJ.js");
       const gitHash = this.getGitHead();
       await recordChange({ filePath, changeType, symbol, gitCommitHash: gitHash || void 0 });
     } catch {

package/dist/{chunk-ZIFLGJ5R.js → chunk-FOQQ2CSL.js}

@@ -1,6 +1,6 @@
 import {
   sessionMemory
-} from "./chunk-PH4JKL6T.js";
+} from "./chunk-BI7KD3SG.js";
 import {
   getProjectRoot
 } from "./chunk-E2KFPEBT.js";

package/dist/{chunk-2NBESJTH.js → chunk-GDNAWLHF.js}

@@ -36,18 +36,29 @@ async function initDb() {
   dbInstance = db;
   return db;
 }
+var _saveTimeout = null;
+var _pendingDb = null;
+var SAVE_DEBOUNCE_MS = 100;
 function saveDb(db) {
   const d = db ?? dbInstance;
   if (!d) return;
-  try {
-    const kumaDir = getKumaDir();
-    const dbPath = path.join(kumaDir, DB_FILENAME);
-    const data = d.export();
-    const buffer = Buffer.from(data);
-    fs.writeFileSync(dbPath, buffer);
-  } catch (err) {
-    console.error(`[KumaDB] Failed to save database: ${err}`);
-  }
+  _pendingDb = d;
+  if (_saveTimeout) return;
+  _saveTimeout = setTimeout(() => {
+    _saveTimeout = null;
+    const targetDb = _pendingDb;
+    _pendingDb = null;
+    if (!targetDb) return;
+    try {
+      const kumaDir = getKumaDir();
+      const dbPath = path.join(kumaDir, DB_FILENAME);
+      const data = targetDb.export();
+      const buffer = Buffer.from(data);
+      fs.writeFileSync(dbPath, buffer);
+    } catch (err) {
+      console.error(`[KumaDB] Failed to save database: ${err}`);
+    }
+  }, SAVE_DEBOUNCE_MS);
 }
 function createSchema(db) {
   db.run(`CREATE TABLE IF NOT EXISTS nodes (

package/dist/{chunk-LLAPHR5W.js → chunk-K64NSHBR.js}

@@ -1,7 +1,7 @@
 import {
   getDb,
   saveDb
-} from "./chunk-2NBESJTH.js";
+} from "./chunk-GDNAWLHF.js";
 import {
   getProjectRoot
 } from "./chunk-E2KFPEBT.js";
@@ -458,7 +458,7 @@ The two nodes may not be connected in the knowledge graph yet. Use more tools to
 }
 async function buildFromSessionMemory() {
   try {
-    const { sessionMemory } = await import("./sessionMemory-PGYVS3BK.js");
+    const { sessionMemory } = await import("./sessionMemory-HBBXUSIP.js");
     const toolCalls = sessionMemory.getToolCallHistory(50);
     let edgeCount = 0;
     for (const call of toolCalls) {
@@ -586,8 +586,8 @@ async function codebaseSearchFallback(query, limit = 20) {
     return lines.join("\n");
   } catch {
     try {
-      let walk2 = function(dir) {
-        if (results.length >= limit) return;
+      let walk2 = function(dir, depth = 0) {
+        if (results.length >= limit || depth > MAX_WALK_DEPTH) return;
         let entries = [];
         try {
           entries = fs2.readdirSync(dir);
@@ -600,7 +600,7 @@ async function codebaseSearchFallback(query, limit = 20) {
           try {
             const stat = fs2.statSync(full);
             if (stat.isDirectory()) {
-              walk2(full);
+              walk2(full, depth + 1);
             } else if (entry.toLowerCase().includes(query.toLowerCase())) {
               results.push(path2.relative(root, full));
             }
@@ -613,7 +613,8 @@ async function codebaseSearchFallback(query, limit = 20) {
       const path2 = await import("path");
       const root = process.cwd();
       const results = [];
-      walk2(root);
+      const MAX_WALK_DEPTH = 8;
+      walk2(root, 0);
       if (results.length === 0) {
         return `\u{1F50D} **Codebase Search** \u2014 No results for "${query}". Try a different search term.`;
       }
@@ -744,7 +745,7 @@ async function codebaseImpactFallback(target) {
     const root = process.cwd();
     const grepResult = execSync2(
       `grep -rn --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" --include="*.json" -l "${target.replace(/"/g, '\\"')}" . 2>/dev/null | grep -v node_modules | grep -v .git | grep -v dist | grep -v .kuma | head -50`,
-      { cwd: root, encoding: "utf-8", timeout: 5e3, maxBuffer: 1024 * 1024 }
+      { cwd: root, encoding: "utf-8", timeout: 5e3, maxBuffer: 256 * 1024 }
     ).trim();
     const files = grepResult ? grepResult.split("\n").filter(Boolean).filter((f) => !f.startsWith("./")) : [];
     if (files.length === 0) {

package/dist/{chunk-6QX4LBHV.js → chunk-X5TPBDKO.js}

@@ -1,6 +1,6 @@
 import {
   sessionMemory
-} from "./chunk-PH4JKL6T.js";
+} from "./chunk-BI7KD3SG.js";
 import {
   getProjectRoot
 } from "./chunk-E2KFPEBT.js";
@@ -82,7 +82,7 @@ function recordDecision(decision) {
 }
 async function recordDecisionToGraph(decision) {
   try {
-    const { upsertNode, addEdge } = await import("./kumaGraph-ABVEVF4M.js");
+    const { upsertNode, addEdge } = await import("./kumaGraph-35TAIBWD.js");
     const decisionId = `decision::${decision.title.replace(/[^a-zA-Z0-9_\-\s]/g, "").trim().replace(/\s+/g, "-")}`;
     await upsertNode({
       id: decisionId,

package/dist/index.js

@@ -14,13 +14,22 @@ import {
   getGraphStats,
   searchGraph,
   traceFlow
-} from "./chunk-LLAPHR5W.js";
+} from "./chunk-K64NSHBR.js";
+import {
+  formatDecisionTemplate,
+  getProactiveMemories,
+  recordDecision,
+  scoreMemoryRelevance
+} from "./chunk-X5TPBDKO.js";
 import {
   buildDriftMessages,
   getGitDiffStat,
   getSessionStats,
   getUnresolvedCount
-} from "./chunk-ZIFLGJ5R.js";
+} from "./chunk-FOQQ2CSL.js";
+import {
+  sessionMemory
+} from "./chunk-BI7KD3SG.js";
 import {
   addContextNote,
   addSecurityFinding,
@@ -46,16 +55,7 @@ import {
   saveResearchCache,
   updateDecisionStatus,
   updateTodoStatus
-} from "./chunk-2NBESJTH.js";
-import {
-  formatDecisionTemplate,
-  getProactiveMemories,
-  recordDecision,
-  scoreMemoryRelevance
-} from "./chunk-6QX4LBHV.js";
-import {
-  sessionMemory
-} from "./chunk-PH4JKL6T.js";
+} from "./chunk-GDNAWLHF.js";
 import {
   getProjectRoot,
   validateFilePath
@@ -87,7 +87,7 @@ var CONTEXT_ALIASES = {
   "refactor": "impact",
   // Navigate synonyms
   "trace": "navigate",
-  "flow": "navigate",
+  "flow-trace": "navigate",
   "navigate": "navigate",
   // Init synonyms
   "init": "init",
@@ -111,7 +111,20 @@ var CONTEXT_ALIASES = {
   // Researches synonyms
   "researches": "researches",
   "research-list": "researches",
-  "list-research": "researches"
+  "list-research": "researches",
+  // Sync/Batch synonyms (Issue #12)
+  "sync": "sync",
+  "batch": "sync",
+  "kuma_sync": "sync",
+  "unified": "sync",
+  "state": "sync",
+  // Visualize synonyms (Issue #16)
+  "visualize": "visualize",
+  "graph": "visualize",
+  "diagram": "visualize",
+  "flow": "visualize",
+  "viz": "visualize",
+  "kuma_visualize": "visualize"
 };
 async function handleContext(params) {
   const rawAction = params.action || "init";
@@ -134,8 +147,12 @@ async function handleContext(params) {
       return handleResearches(params);
     case "health":
       return handleHealth(params);
+    case "sync":
+      return handleSync(params);
+    case "visualize":
+      return handleVisualize(params);
     default:
-      return `Unknown action "${action}". Use: init, research, impact, navigate, changes, rollback, researches, health`;
+      return `Unknown action "${action}". Use: init, research, impact, navigate, changes, rollback, researches, health, sync, visualize`;
   }
 }
 async function handleInit(_params) {
@@ -196,8 +213,8 @@ async function handleInit(_params) {
   lines.push(`  \u{1F4DD} Modified: ${summary.modifiedFiles?.length || 0} file(s)`);
   lines.push(`  \u{1F6E0}\uFE0F Tool calls: ${summary.toolCallCount}`);
   try {
-    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-VYT6OMVG.js");
-    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-FQ3YKJ6K.js");
+    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-PJGRRBWP.js");
+    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-DJUDLYBJ.js");
     const score = await computeSafetyScore(_params.goal);
     const checksStr = JSON.stringify(score.checks);
     await saveHealthSnapshot2(score.score, score.risk, checksStr, score.summary);
@@ -370,8 +387,8 @@ async function handleResearches(_params) {
 async function handleHealth(_params) {
   sessionMemory.recordToolCall("kuma_context_health", {});
   try {
-    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-VYT6OMVG.js");
-    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-FQ3YKJ6K.js");
+    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-PJGRRBWP.js");
+    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-DJUDLYBJ.js");
     const score = await computeSafetyScore();
     const checksStr = JSON.stringify(score.checks);
     await saveHealthSnapshot2(score.score, score.risk, checksStr, score.summary);
@@ -380,6 +397,64 @@ async function handleHealth(_params) {
     return `Error computing health: ${err}`;
   }
 }
+async function handleSync(params) {
+  sessionMemory.setGoal(params.goal || "Sync session");
+  sessionMemory.recordToolCall("kuma_context_sync", { goal: params.goal });
+  const lines = [
+    "\u{1F504} **Kuma Sync \u2014 Unified State**",
+    `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+    "",
+    `\u{1F4C1} Project: ${getProjectRoot().split("/").pop() || "unknown"}`,
+    `\u{1F550} Session: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    ""
+  ];
+  const summary = sessionMemory.getSummary();
+  lines.push("**Session State**");
+  lines.push(`  \u{1F3AF} Goal: ${summary.currentGoal || "not set"}`);
+  lines.push(`  \u{1F4DD} Modified: ${summary.modifiedFiles?.length || 0} file(s)`);
+  lines.push(`  \u{1F6E0}\uFE0F Tool calls: ${summary.toolCallCount}`);
+  lines.push("");
+  try {
+    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-PJGRRBWP.js");
+    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-DJUDLYBJ.js");
+    const score = await computeSafetyScore(params.goal);
+    const checksStr = JSON.stringify(score.checks);
+    await saveHealthSnapshot2(score.score, score.risk, checksStr, score.summary);
+    lines.push("**Health Score**");
+    lines.push(formatSafetyScore(score));
+  } catch {
+    lines.push("**Health Score**: \u26A0\uFE0F Could not compute");
+  }
+  lines.push("");
+  try {
+    const { getGraphStats: getGraphStats2 } = await import("./kumaGraph-35TAIBWD.js");
+    lines.push("**Knowledge Graph**");
+    lines.push(await getGraphStats2());
+  } catch {
+  }
+  lines.push("");
+  try {
+    const { getProactiveMemories: getProactiveMemories2 } = await import("./kumaMemory-5SR3TGRL.js");
+    const memories = getProactiveMemories2();
+    if (memories) {
+      lines.push("**Relevant Memories**");
+      lines.push(memories);
+      lines.push("");
+    }
+  } catch {
+  }
+  lines.push("\u{1F4A1} Sync complete \u2014 all state captured in a single roundtrip.");
+  return lines.join("\n");
+}
+async function handleVisualize(params) {
+  const scope = params.scope;
+  const { generateVisualizeReport } = await import("./kumaVisualize-ODCWFSUY.js");
+  return await generateVisualizeReport({
+    scope,
+    type: "flowchart",
+    maxNodes: 40
+  });
+}
 function computeProjectHash(scope) {
   try {
     const root = getProjectRoot();
@@ -501,7 +576,7 @@ async function handleDecision(params) {
     case "template":
       return formatDecisionTemplate();
     case "suggest": {
-      const { shouldRecordDecision } = await import("./kumaMemory-DDZQXMFZ.js");
+      const { shouldRecordDecision } = await import("./kumaMemory-5SR3TGRL.js");
       const check = shouldRecordDecision();
       return check.worth ? `\u{1F4A1} Decision suggested: "${check.title}"
 Use kuma_memory({ action: 'decision', title: '...', context: '...', rationale: '...', outcome: '...' }) to record.` : "\u2705 No decision needed at this time.";
@@ -579,8 +654,17 @@ async function handleSearch(params) {
   if (!query) return "\u26A0\uFE0F query or scope parameter required.";
   const limit = params.limit || 20;
   const memResults = sessionMemory.searchMemory(query, limit);
-  const { searchGraph: searchGraph2 } = await import("./kumaGraph-ABVEVF4M.js");
+  const { searchGraph: searchGraph2 } = await import("./kumaGraph-35TAIBWD.js");
   const graphResults = await searchGraph2(query, Math.min(limit, 10));
+  let hybridResults = "";
+  try {
+    const { hybridSearch, formatHybridResults } = await import("./kumaSearch-LG2OYEJY.js");
+    const semanticResults = await hybridSearch(query, 8);
+    if (semanticResults.length > 0) {
+      hybridResults = "\n" + formatHybridResults(query, semanticResults);
+    }
+  } catch {
+  }
   const lines = [`\u{1F50D} **Search Results** \u2014 "${query}"
 \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
 `];
@@ -590,6 +674,10 @@ async function handleSearch(params) {
     lines.push("");
   }
   lines.push("**Knowledge Graph:**\n" + graphResults);
+  if (hybridResults) {
+    lines.push("");
+    lines.push(hybridResults);
+  }
   return lines.join("\n");
 }
 async function handleChanges2(params) {
@@ -654,7 +742,7 @@ async function handleDecisionLog(params) {
 }
 async function handleMine(params) {
   sessionMemory.recordToolCall("kuma_memory_mine", { scope: params.scope });
-  const { mineHistoricalDecisions } = await import("./kumaMiner-GP6BITKV.js");
+  const { mineHistoricalDecisions } = await import("./kumaMiner-P5KCUSF7.js");
   return await mineHistoricalDecisions({
     scope: params.scope,
     since: typeof params.since === "string" ? params.since : void 0,
@@ -1791,7 +1879,7 @@ async function handleLock(params) {
 }
 async function handleHealth2(_params) {
   try {
-    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-VYT6OMVG.js");
+    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-PJGRRBWP.js");
     const score = await computeSafetyScore();
     await saveHealthSnapshot(score.score, score.risk, JSON.stringify(score.checks), score.summary);
     return formatSafetyScore(score);
@@ -1905,7 +1993,7 @@ async function handleVerify(params) {
   }
   _lastVerifyCall = now;
   sessionMemory.recordToolCall("kuma_safety_verify", { scope: params.scope || params.filePath });
-  const { runAutoVerification } = await import("./kumaVerifier-7TFWLEPG.js");
+  const { runAutoVerification } = await import("./kumaVerifier-LFRNIGSL.js");
   return await runAutoVerification({
     scope: params.scope || params.filePath,
     force: params.force,
@@ -1919,7 +2007,7 @@ function registerAllTools(server) {
     "kuma_context",
     "**Call FIRST every session.** Understand your project before making changes. Actions: init (load project brief), research (5-step pipeline: cache\u2192staleness\u2192graph\u2192impact\u2192decision), impact (analyze change effects), navigate (trace code flow), changes (view change log), health (project health score 0-100). RESEARCH IS REQUIRED before editing unfamiliar code.",
     {
-      action: z.enum(["init", "research", "impact", "navigate", "changes", "health", "rollback", "researches"]).describe("Action: init=project brief, research=5-step research pipeline (REQUIRED before edits), impact=analyze change effects, navigate=trace code flow, changes=view change log, rollback=undo a change by ID, researches=list all cached research, health=project health score"),
+      action: z.enum(["init", "research", "impact", "navigate", "changes", "health", "rollback", "researches", "sync", "visualize"]).describe("Action: init=project brief, research=5-step research pipeline (REQUIRED before edits), impact=analyze change effects, navigate=trace code flow, changes=view change log, rollback=undo a change by ID, researches=list all cached research, sync=unified batch state, visualize=Mermaid knowledge graph diagram, health=project health score"),
       scope: z.string().optional().describe("Research scope for research action (e.g. 'auth', 'database', 'api')"),
       target: z.string().optional().describe("Target symbol/file for impact/navigate/changes"),
       goal: z.string().optional().describe("Current goal (for init/health)"),
@@ -2104,7 +2192,7 @@ async function main() {
     console.error("");
     let killedCount = 0;
     try {
-      const { getRunningVerificationPid } = await import("./kumaVerifier-7TFWLEPG.js");
+      const { getRunningVerificationPid } = await import("./kumaVerifier-LFRNIGSL.js");
       const pid = getRunningVerificationPid();
       if (pid) {
         try {
@@ -2196,6 +2284,9 @@ async function main() {
     console.error("");
     process.exit(0);
   }
+  if (args[0] === "--hook") {
+    process.exit(0);
+  }
   if (args[0] === "init") {
     const flags = args.slice(1);
     if (flags.includes("--help") || flags.includes("-h")) {
@@ -2343,7 +2434,7 @@ async function main() {
         console.error(`[${SERVER_NAME}] \u2705 Restored session (${sessionInfo.toolCallCount} previous tool calls)`);
       }
       try {
-        const { buildFromSessionMemory } = await import("./kumaGraph-ABVEVF4M.js");
+        const { buildFromSessionMemory } = await import("./kumaGraph-35TAIBWD.js");
         const edgeCount = await buildFromSessionMemory();
         if (edgeCount > 0) {
           console.error(`[${SERVER_NAME}] \u2705 Graph auto-populated with ${edgeCount} entries from session memory`);
@@ -2363,7 +2454,7 @@ async function main() {
         console.error(`[${SERVER_NAME}] \u26A0\uFE0F Scratch directory setup: ${err}`);
       }
       try {
-        const { getDb: getDb2, saveDb: saveDb2 } = await import("./kumaDb-FQ3YKJ6K.js");
+        const { getDb: getDb2, saveDb: saveDb2 } = await import("./kumaDb-DJUDLYBJ.js");
         const db = await getDb2();
         db.run(
           `INSERT INTO sessions (started_at, goal, tool_calls) VALUES (?, ?, ?)`,
@@ -2373,6 +2464,44 @@ async function main() {
       } catch (err) {
         console.error(`[${SERVER_NAME}] \u26A0\uFE0F Session DB record: ${err}`);
       }
+      try {
+        const fs7 = await import("fs");
+        const path7 = await import("path");
+        const hooksDir = path7.resolve(process.cwd(), ".kuma", "hooks");
+        if (!fs7.existsSync(hooksDir)) {
+          fs7.mkdirSync(hooksDir, { recursive: true });
+          const hookContent = `#!/bin/bash
+# Kuma auto-capture hook (post-commit)
+# Auto-updates knowledge graph after git commits
+if command -v npx &> /dev/null; then
+  npx -y @plumpslabs/kuma --hook post-commit 2>/dev/null || true
+fi
+`;
+          const gitHooksDir = path7.resolve(process.cwd(), ".git", "hooks");
+          if (fs7.existsSync(gitHooksDir)) {
+            const postCommitPath = path7.join(gitHooksDir, "post-commit");
+            if (!fs7.existsSync(postCommitPath)) {
+              fs7.writeFileSync(postCommitPath, hookContent, "utf-8");
+              try {
+                fs7.chmodSync(postCommitPath, 493);
+              } catch {
+              }
+              console.error(`[${SERVER_NAME}] \u2705 Created .git/hooks/post-commit for auto-capture`);
+            }
+          }
+        }
+      } catch (err) {
+        console.error(`[${SERVER_NAME}] \u26A0\uFE0F Auto-capture hook setup: ${err}`);
+      }
+      try {
+        const { buildSearchVectors } = await import("./kumaSearch-LG2OYEJY.js");
+        const vectors = await buildSearchVectors();
+        if (vectors.length > 0) {
+          console.error(`[${SERVER_NAME}] \u2705 Search vector cache pre-warmed (${vectors.length} documents)`);
+        }
+      } catch (err) {
+        console.error(`[${SERVER_NAME}] \u26A0\uFE0F Search vector cache: ${err}`);
+      }
       console.error(`[${SERVER_NAME}] \u2705 Cold start bootstrap complete`);
     } catch (err) {
       console.error(`[${SERVER_NAME}] \u26A0\uFE0F Cold start bootstrap error: ${err}`);

package/dist/{kumaDb-FQ3YKJ6K.js → kumaDb-DJUDLYBJ.js}

@@ -28,7 +28,7 @@ import {
   saveVerification,
   updateDecisionStatus,
   updateTodoStatus
-} from "./chunk-2NBESJTH.js";
+} from "./chunk-GDNAWLHF.js";
 import "./chunk-E2KFPEBT.js";
 export {
   addContextNote,

package/dist/{kumaGraph-ABVEVF4M.js → kumaGraph-35TAIBWD.js}

@@ -14,8 +14,8 @@ import {
   searchGraph,
   traceFlow,
   upsertNode
-} from "./chunk-LLAPHR5W.js";
-import "./chunk-2NBESJTH.js";
+} from "./chunk-K64NSHBR.js";
+import "./chunk-GDNAWLHF.js";
 import "./chunk-E2KFPEBT.js";
 export {
   addEdge,

package/dist/{kumaMemory-DDZQXMFZ.js → kumaMemory-5SR3TGRL.js}

@@ -4,8 +4,8 @@ import {
   recordDecision,
   scoreMemoryRelevance,
   shouldRecordDecision
-} from "./chunk-6QX4LBHV.js";
-import "./chunk-PH4JKL6T.js";
+} from "./chunk-X5TPBDKO.js";
+import "./chunk-BI7KD3SG.js";
 import "./chunk-E2KFPEBT.js";
 export {
   formatDecisionTemplate,

package/dist/{kumaMiner-GP6BITKV.js → kumaMiner-P5KCUSF7.js}

@@ -1,10 +1,10 @@
-import {
-  recordDecisionLog
-} from "./chunk-2NBESJTH.js";
 import {
   recordDecision
-} from "./chunk-6QX4LBHV.js";
-import "./chunk-PH4JKL6T.js";
+} from "./chunk-X5TPBDKO.js";
+import "./chunk-BI7KD3SG.js";
+import {
+  recordDecisionLog
+} from "./chunk-GDNAWLHF.js";
 import "./chunk-E2KFPEBT.js";
 
 // src/engine/kumaMiner.ts
@@ -19,9 +19,10 @@ async function mineHistoricalDecisions(options = {}) {
   try {
     const sinceFlag = options.since ? `--since="${options.since}"` : `--since="1 year"`;
     const gitCmd = `git log ${sinceFlag} -n 100 --pretty=format:"%h|%an|%ad|%s" --date=short`;
-    const gitOutput = execSync(gitCmd, { cwd: root, encoding: "utf-8" });
+    const gitOutput = execSync(gitCmd, { cwd: root, encoding: "utf-8", timeout: 15e3 });
     const keywords = ["fix", "revert", "hack", "workaround", "urgent", "hotfix", "don't touch", "temporary", "deprecated", "workaround"];
     const lines = gitOutput.split("\n").filter(Boolean);
+    const matchingHashes = [];
     for (const line of lines) {
       const parts = line.split("|");
       if (parts.length < 4) continue;
@@ -29,9 +30,42 @@ async function mineHistoricalDecisions(options = {}) {
       const lowerSubj = subject.toLowerCase();
       const matchedKeyword = keywords.find((kw) => lowerSubj.includes(kw));
       if (matchedKeyword) {
-        let changedFiles = "";
+        matchingHashes.push({ hash, author, date, subject, keyword: matchedKeyword });
+        if (matchingHashes.length >= limit) break;
+      }
+    }
+    let changedFilesMap = /* @__PURE__ */ new Map();
+    if (matchingHashes.length > 0) {
+      try {
+        const hashesStr = matchingHashes.map((h) => h.hash).join(" ");
+        const batchOutput = execSync(
+          `git show --name-only --oneline ${hashesStr} 2>/dev/null | head -200`,
+          { cwd: root, encoding: "utf-8", timeout: 1e4, maxBuffer: 256 * 1024 }
+        );
+        let currentHash = "";
+        const files = [];
+        for (const line of batchOutput.split("\n")) {
+          if (matchingHashes.find((h) => line.startsWith(h.hash))) {
+            if (currentHash && files.length > 0) {
+              changedFilesMap.set(currentHash, files.slice(0, 3).join(", "));
+            }
+            currentHash = line.split(" ")[0];
+            files.length = 0;
+          } else if (line.trim() && !line.startsWith("diff")) {
+            files.push(line.trim());
+          }
+        }
+        if (currentHash && files.length > 0) {
+          changedFilesMap.set(currentHash, files.slice(0, 3).join(", "));
+        }
+      } catch {
+      }
+    }
+    for (const { hash, author, date, subject, keyword: matchedKeyword } of matchingHashes) {
+      let changedFiles = changedFilesMap.get(hash) || "";
+      if (!changedFiles) {
         try {
-          changedFiles = execSync(`git show --name-only --oneline ${hash}`, { cwd: root, encoding: "utf-8" }).split("\n").slice(1).filter(Boolean).slice(0, 3).join(", ");
+          changedFiles = execSync(`git show --name-only --oneline ${hash}`, { cwd: root, encoding: "utf-8", timeout: 5e3 }).split("\n").slice(1).filter(Boolean).slice(0, 3).join(", ");
         } catch {
         }
         candidates.push({

package/dist/kumaSearch-LG2OYEJY.js

@@ -0,0 +1,321 @@
+import {
+  getDb
+} from "./chunk-GDNAWLHF.js";
+import {
+  getProjectRoot
+} from "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaSearch.ts
+import fs from "fs";
+import path from "path";
+var SYNONYM_MAP = {
+  timeout: ["timeout", "duration", "expiry", "ttl", "deadline", "latency"],
+  duration: ["duration", "timeout", "length", "period", "interval"],
+  delay: ["delay", "wait", "latency", "defer", "throttle"],
+  latency: ["latency", "delay", "response time", "speed", "performance"],
+  error: ["error", "failure", "exception", "bug", "fault", "crash"],
+  crash: ["crash", "panic", "oom", "out of memory", "segfault"],
+  fail: ["fail", "error", "break", "regression", "broken"],
+  auth: ["auth", "authentication", "login", "oauth", "session", "token", "credential"],
+  login: ["login", "signin", "auth", "authenticate"],
+  token: ["token", "jwt", "session", "api key", "secret"],
+  permission: ["permission", "access", "role", "rbac", "authorization", "acl"],
+  database: ["database", "db", "storage", "persistence", "sql", "nosql"],
+  query: ["query", "search", "fetch", "select", "lookup"],
+  index: ["index", "key", "lookup", "search"],
+  cache: ["cache", "memcached", "redis", "buffer", "temporary storage"],
+  api: ["api", "endpoint", "route", "rest", "graphql", "service"],
+  route: ["route", "endpoint", "path", "handler"],
+  request: ["request", "http", "call", "fetch", "invocation"],
+  response: ["response", "reply", "result", "output"],
+  performance: ["performance", "speed", "latency", "throughput", "efficiency"],
+  memory: ["memory", "ram", "heap", "allocation", "leak"],
+  cpu: ["cpu", "processor", "compute", "thread", "worker"],
+  architecture: ["architecture", "design", "pattern", "structure", "system"],
+  service: ["service", "microservice", "module", "component", "layer"],
+  config: ["config", "configuration", "setting", "env", "environment"],
+  deploy: ["deploy", "release", "rollout", "publish", "ship"],
+  build: ["build", "compile", "bundle", "transpile", "package"],
+  test: ["test", "spec", "unit test", "integration", "e2e"],
+  lint: ["lint", "format", "style", "prettier", "eslint"],
+  redis: ["redis", "cache", "session store", "message queue"],
+  postgres: ["postgres", "postgresql", "psql", "relational db", "sql"],
+  docker: ["docker", "container", "image", "dockerfile", "compose"],
+  typescript: ["typescript", "ts", "type system", "compiler"],
+  prisma: ["prisma", "orm", "database client", "schema"],
+  create: ["create", "add", "new", "make", "generate"],
+  update: ["update", "modify", "change", "edit", "patch"],
+  delete: ["delete", "remove", "drop", "clear", "purge"]
+};
+function expandQueryTerms(query) {
+  const terms = query.toLowerCase().split(/[\s_-]+/).filter((t) => t.length > 2);
+  const expanded = /* @__PURE__ */ new Map();
+  for (const term of terms) {
+    const sources = /* @__PURE__ */ new Set();
+    sources.add(term);
+    if (SYNONYM_MAP[term]) {
+      for (const syn of SYNONYM_MAP[term]) {
+        sources.add(syn);
+      }
+    }
+    for (const [key, synonyms] of Object.entries(SYNONYM_MAP)) {
+      if (synonyms.includes(term)) {
+        sources.add(key);
+      }
+    }
+    expanded.set(term, sources);
+  }
+  return expanded;
+}
+var _vectorCache = null;
+var VECTOR_CACHE_TTL = 3e5;
+async function buildSearchVectors() {
+  if (_vectorCache && Date.now() - _vectorCache.builtAt < VECTOR_CACHE_TTL) {
+    return _vectorCache.vectors;
+  }
+  const vectors = [];
+  try {
+    const db = await getDb();
+    const stmt = db.prepare("SELECT id, name, metadata, file_path FROM nodes ORDER BY updated_at DESC LIMIT 500");
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      const name = row.name || "";
+      const metaStr = row.metadata || "{}";
+      let metaText = "";
+      try {
+        const meta = JSON.parse(metaStr);
+        metaText = Object.values(meta).join(" ");
+      } catch {
+      }
+      const filePath = row.file_path || "";
+      const nodeText = `${name} ${metaText} ${filePath}`.toLowerCase();
+      const rawTerms = extractTerms(nodeText);
+      const termCounts = /* @__PURE__ */ new Map();
+      for (const t of rawTerms) {
+        termCounts.set(t, (termCounts.get(t) || 0) + 1);
+      }
+      vectors.push({
+        terms: termCounts,
+        source: name || row.id,
+        sourceType: "graph"
+      });
+    }
+    stmt.free();
+  } catch {
+  }
+  try {
+    const root = getProjectRoot();
+    const memDir = path.join(root, ".kuma", "memories");
+    if (fs.existsSync(memDir)) {
+      const files = fs.readdirSync(memDir).filter((f) => f.endsWith(".md")).slice(0, 10);
+      for (const file of files) {
+        try {
+          const content = fs.readFileSync(path.join(memDir, file), "utf-8");
+          const text = content.toLowerCase();
+          const rawTerms = extractTerms(text);
+          const termCounts = /* @__PURE__ */ new Map();
+          for (const t of rawTerms) {
+            termCounts.set(t, (termCounts.get(t) || 0) + 1);
+          }
+          vectors.push({
+            terms: termCounts,
+            source: file.replace(/\.md$/, ""),
+            sourceType: "memory"
+          });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const db = await getDb();
+    const stmt = db.prepare("SELECT scope, record FROM research_cache ORDER BY updated_at DESC LIMIT 50");
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      const scope = row.scope || "";
+      const record = row.record || "";
+      const text = `${scope} ${record}`.toLowerCase();
+      const rawTerms = extractTerms(text);
+      const termCounts = /* @__PURE__ */ new Map();
+      for (const t of rawTerms) {
+        termCounts.set(t, (termCounts.get(t) || 0) + 1);
+      }
+      vectors.push({
+        terms: termCounts,
+        source: scope,
+        sourceType: "research"
+      });
+    }
+    stmt.free();
+  } catch {
+  }
+  const docCount = vectors.length || 1;
+  const docFreq = /* @__PURE__ */ new Map();
+  for (const vec of vectors) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [term] of vec.terms) {
+      if (!seen.has(term)) {
+        docFreq.set(term, (docFreq.get(term) || 0) + 1);
+        seen.add(term);
+      }
+    }
+  }
+  for (const vec of vectors) {
+    const maxFreq = Math.max(1, ...Array.from(vec.terms.values()));
+    for (const [term, rawFreq] of vec.terms) {
+      const tf = 0.5 + 0.5 * rawFreq / maxFreq;
+      const docsWithTerm = docFreq.get(term) || 1;
+      const idf = Math.log(1 + (docCount - docsWithTerm + 0.5) / (docsWithTerm + 0.5));
+      vec.terms.set(term, tf * idf);
+    }
+  }
+  _vectorCache = { vectors, builtAt: Date.now() };
+  return vectors;
+}
+function extractTerms(text) {
+  return text.toLowerCase().split(/[\s,.;:!?()\[\]{}"'\/\\|@#$%^&*+=<>~`]+/).filter((t) => t.length > 2 && t.length < 50 && !/^\d+$/.test(t));
+}
+function cosineSimilarity(queryVec, docVec) {
+  let dotProduct = 0;
+  let queryMagnitude = 0;
+  let docMagnitude = 0;
+  for (const [term, qWeight] of queryVec) {
+    queryMagnitude += qWeight * qWeight;
+    const dWeight = docVec.get(term) || 0;
+    dotProduct += qWeight * dWeight;
+  }
+  for (const [, dWeight] of docVec) {
+    docMagnitude += dWeight * dWeight;
+  }
+  const mag = Math.sqrt(queryMagnitude) * Math.sqrt(docMagnitude);
+  if (mag === 0) return 0;
+  return dotProduct / mag;
+}
+async function hybridSearch(query, limit = 10) {
+  const results = [];
+  const expandedTerms = expandQueryTerms(query);
+  const allSearchTerms = /* @__PURE__ */ new Set();
+  for (const [, sources] of expandedTerms) {
+    for (const term of sources) {
+      allSearchTerms.add(term);
+    }
+  }
+  const searchTerms = Array.from(allSearchTerms);
+  const queryVector = /* @__PURE__ */ new Map();
+  for (const [originalTerm, sources] of expandedTerms) {
+    for (const term of sources) {
+      const weight = term === originalTerm ? 2 : 1;
+      queryVector.set(term, (queryVector.get(term) || 0) + weight);
+    }
+  }
+  try {
+    const db = await getDb();
+    const likeClauses = searchTerms.map(() => `name LIKE ?`).join(" OR ");
+    const sql = `SELECT id, name, type, file_path, metadata FROM nodes WHERE (${likeClauses}) LIMIT ${limit * 3}`;
+    const stmt = db.prepare(sql);
+    stmt.bind(searchTerms.map((t) => `%${t}%`));
+    const seen = /* @__PURE__ */ new Set();
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      const name = row.name || "";
+      const filePath = row.file_path || "";
+      const sourceKey = name + filePath;
+      if (seen.has(sourceKey)) continue;
+      seen.add(sourceKey);
+      const lowerText = `${name} ${filePath}`.toLowerCase();
+      const matchedTerms = searchTerms.filter((t) => lowerText.includes(t));
+      const keywordScore = matchedTerms.length > 0 ? Math.round(matchedTerms.length / Math.max(1, searchTerms.length) * 100) : 0;
+      results.push({
+        source: name,
+        sourceType: "graph",
+        score: keywordScore,
+        keywordScore,
+        vectorScore: 0,
+        matchedTerms
+      });
+    }
+    stmt.free();
+  } catch (err) {
+    console.error(`[KumaSearch] DB search failed: ${err}`);
+  }
+  try {
+    const vectors = await buildSearchVectors();
+    for (const vec of vectors) {
+      const vectorScore = Math.round(cosineSimilarity(queryVector, vec.terms) * 100);
+      const existing = results.find((r) => r.source === vec.source);
+      if (existing) {
+        existing.vectorScore = vectorScore;
+        existing.score = Math.min(100, Math.round(existing.keywordScore * 0.6 + vectorScore * 0.4));
+        for (const [term] of vec.terms) {
+          if (queryVector.has(term) && !existing.matchedTerms.includes(term)) {
+            existing.matchedTerms.push(term);
+          }
+        }
+      } else if (vectorScore > 0) {
+        const matchedTerms = [];
+        for (const [term] of vec.terms) {
+          if (queryVector.has(term)) matchedTerms.push(term);
+        }
+        results.push({
+          source: vec.source,
+          sourceType: vec.sourceType,
+          score: Math.round(vectorScore * 0.4),
+          keywordScore: 0,
+          vectorScore,
+          matchedTerms
+        });
+      }
+    }
+  } catch (err) {
+    console.error(`[KumaSearch] Vector search failed: ${err}`);
+  }
+  const uniqueResults = Array.from(
+    new Map(results.map((r) => [r.source, r])).values()
+  );
+  return uniqueResults.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+function formatHybridResults(query, results) {
+  const expandedTerms = expandQueryTerms(query);
+  const originalTerms = Array.from(expandedTerms.keys()).join(", ");
+  const totalSynonyms = Array.from(expandedTerms.values()).reduce(
+    (sum, s) => sum + s.size,
+    0
+  );
+  const lines = [
+    "**Hybrid Search** \u2014 " + query,
+    "----------------------------------------",
+    "",
+    "Expanded query: " + originalTerms + " (" + totalSynonyms + " total terms with synonyms)",
+    ""
+  ];
+  if (results.length === 0) {
+    lines.push("No results found. Try different keywords or research first.");
+    return lines.join("\n");
+  }
+  lines.push(results.length + " result(s) \u2014 ranked by hybrid relevance");
+  lines.push("");
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    const typeIcon = r.sourceType === "graph" ? "file" : r.sourceType === "memory" ? "memory" : "research";
+    const matchType = r.vectorScore > r.keywordScore ? "semantic match" : r.keywordScore > 0 ? "keyword match" : "expanded match";
+    lines.push(i + 1 + ". [" + typeIcon + "] " + r.source + " \u2014 " + r.score + "%");
+    lines.push("   keyword: " + r.keywordScore + "% | vector: " + r.vectorScore + "% (" + matchType + ")");
+    if (r.matchedTerms.length > 0) {
+      lines.push("   Terms: " + r.matchedTerms.slice(0, 6).join(", "));
+    }
+    lines.push("");
+  }
+  lines.push("Hybrid search combines keyword matching with semantic synonym expansion.");
+  return lines.join("\n");
+}
+function clearSearchCache() {
+  _vectorCache = null;
+}
+export {
+  buildSearchVectors,
+  clearSearchCache,
+  expandQueryTerms,
+  formatHybridResults,
+  hybridSearch
+};

package/dist/{kumaVerifier-7TFWLEPG.js → kumaVerifier-LFRNIGSL.js}

@@ -1,10 +1,10 @@
+import {
+  sessionMemory
+} from "./chunk-BI7KD3SG.js";
 import {
   getLatestVerifications,
   saveVerification
-} from "./chunk-2NBESJTH.js";
-import {
-  sessionMemory
-} from "./chunk-PH4JKL6T.js";
+} from "./chunk-GDNAWLHF.js";
 import "./chunk-E2KFPEBT.js";
 
 // src/engine/kumaVerifier.ts

package/dist/kumaVisualize-ODCWFSUY.js

@@ -0,0 +1,248 @@
+import {
+  getDb
+} from "./chunk-GDNAWLHF.js";
+import "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaVisualize.ts
+async function visualizeGraph(options = {}) {
+  const {
+    type = "flowchart",
+    scope,
+    maxNodes = 30,
+    // depth unused: kept for API consistency
+    format = "mermaid"
+  } = options;
+  try {
+    const db = await getDb();
+    let nodeSql = `SELECT id, type, name, file_path FROM nodes WHERE 1=1`;
+    const nodeBind = [];
+    if (scope) {
+      nodeSql += ` AND (name LIKE ? OR file_path LIKE ? OR id LIKE ?)`;
+      nodeBind.push(`%${scope}%`, `%${scope}%`, `%${scope}%`);
+    }
+    nodeSql += ` ORDER BY updated_at DESC LIMIT ?`;
+    nodeBind.push(maxNodes);
+    const nodeStmt = db.prepare(nodeSql);
+    nodeStmt.bind(nodeBind);
+    const nodes = [];
+    while (nodeStmt.step()) {
+      nodes.push(nodeStmt.getAsObject());
+    }
+    nodeStmt.free();
+    if (nodes.length === 0) {
+      return format === "mermaid" ? "```mermaid\nflowchart TD\n  Start[Empty Graph \u2014 No nodes found]\n```" : "\u{1F4ED} **Empty Graph** \u2014 No nodes found to visualize.";
+    }
+    const nodeIds = nodes.map((n) => n.id);
+    const edgeSql = `
+      SELECT e.source_id, e.target_id, e.type, e.weight,
+        sn.name AS source_name, tn.name AS target_name
+      FROM edges e
+      JOIN nodes sn ON sn.id = e.source_id
+      JOIN nodes tn ON tn.id = e.target_id
+      WHERE (e.source_id IN (${nodeIds.map(() => "?").join(",")})
+         OR e.target_id IN (${nodeIds.map(() => "?").join(",")}))
+        AND e.source_id != e.target_id
+      ORDER BY e.weight DESC
+      LIMIT 100
+    `;
+    const edgeBind = [...nodeIds, ...nodeIds];
+    const edgeStmt = db.prepare(edgeSql);
+    edgeStmt.bind(edgeBind);
+    const edges = [];
+    while (edgeStmt.step()) {
+      edges.push(edgeStmt.getAsObject());
+    }
+    edgeStmt.free();
+    switch (type) {
+      case "flowchart":
+        return formatFlowchart(nodes, edges, format);
+      case "dependency":
+        return formatDependencyGraph(nodes, edges, format);
+      case "mindmap":
+        return formatMindMap(nodes, edges, format);
+      default:
+        return formatFlowchart(nodes, edges, format);
+    }
+  } catch (err) {
+    return `Error generating visualization: ${err}`;
+  }
+}
+function formatFlowchart(nodes, edges, _format) {
+  void _format;
+  const lines = ["```mermaid", "flowchart TD"];
+  for (const node of nodes) {
+    const id = sanitizeId(node.id);
+    const name = truncate(node.name, 30);
+    const nodeType = node.type;
+    const shape = getNodeShape(nodeType);
+    if (shape) {
+      lines.push(`  ${id}${shape}${name}${reverseShape(shape)}`);
+    } else {
+      lines.push(`  ${id}[${name}]`);
+    }
+  }
+  for (const edge of edges) {
+    const sourceId = sanitizeId(edge.source_id);
+    const targetId = sanitizeId(edge.target_id);
+    const edgeType = edge.type;
+    void edge.weight;
+    const label = truncate(edgeType, 15);
+    const edgeStyle = getEdgeStyle(edgeType);
+    lines.push(`  ${sourceId}${edgeStyle}|${label}|${targetId}`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatDependencyGraph(nodes, edges, _format) {
+  void _format;
+  const lines = ["```mermaid", "flowchart LR"];
+  const grouped = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const type = node.type || "unknown";
+    if (!grouped.has(type)) grouped.set(type, []);
+    grouped.get(type).push(node);
+  }
+  let subgraphIndex = 0;
+  for (const [type, typeNodes] of grouped) {
+    if (typeNodes.length < 1) continue;
+    lines.push(`  subgraph ${type.toUpperCase()}[${type.toUpperCase()}]`);
+    for (const node of typeNodes) {
+      const id = sanitizeId(node.id);
+      const name = truncate(node.name, 25);
+      lines.push(`    ${id}(${name})`);
+    }
+    lines.push("  end");
+    subgraphIndex++;
+  }
+  for (const edge of edges) {
+    const sourceId = sanitizeId(edge.source_id);
+    const targetId = sanitizeId(edge.target_id);
+    const edgeType = edge.type;
+    const style = getEdgeStyle(edgeType);
+    lines.push(`  ${sourceId}${style}|${edgeType}|${targetId}`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatMindMap(nodes, edges, _format) {
+  void _format;
+  const lines = ["```mermaid", "mindmap"];
+  const hasIncoming = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    hasIncoming.add(edge.target_id);
+  }
+  const roots = nodes.filter((n) => !hasIncoming.has(n.id));
+  if (roots.length === 0 && nodes.length > 0) {
+    const root = nodes[0];
+    lines.push(`  root((${truncate(root.name, 25)}))`);
+    for (const node of nodes.slice(1)) {
+      lines.push(`    ${sanitizeId(node.id)}(${truncate(node.name, 25)})`);
+    }
+  } else {
+    for (const root of roots.slice(0, 3)) {
+      lines.push(`  root((${truncate(root.name, 25)}))`);
+    }
+    const others = nodes.filter((n) => !roots.includes(n));
+    for (const node of others.slice(0, 10)) {
+      const parent = edges.find((e) => e.source_id === node.id || e.target_id === node.id);
+      const indent = parent ? "    " : "  ";
+      lines.push(`${indent}${sanitizeId(node.id)}(${truncate(node.name, 25)})`);
+    }
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function sanitizeId(id) {
+  const safe = id.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "n$1").substring(0, 40);
+  return safe || "n0";
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + "...";
+}
+function getNodeShape(type) {
+  switch (type) {
+    case "function":
+      return "([";
+    case "file":
+      return "[";
+    case "test":
+      return "{";
+    case "api_route":
+      return "[[";
+    case "db_table":
+      return ">";
+    // database shape approximation
+    case "class":
+      return "[";
+    case "interface":
+      return "(";
+    case "module":
+      return "[";
+    case "variable":
+      return "(";
+    default:
+      return "[";
+  }
+}
+function reverseShape(shape) {
+  const map = {
+    "([": "])",
+    "[": "]",
+    "{": "}",
+    "[[": "]]",
+    ">": "<]",
+    "(": ")"
+  };
+  return map[shape] || "]";
+}
+function getEdgeStyle(type) {
+  switch (type) {
+    case "calls":
+      return " ==> ";
+    case "imports":
+      return " -.-> ";
+    case "defines":
+      return " --- ";
+    case "tests":
+      return " -.-> ";
+    case "routes":
+      return " ==> ";
+    case "implements":
+      return " -.-> ";
+    case "extends":
+      return " ==> ";
+    case "depends_on":
+      return " -.-> ";
+    case "owns":
+      return " --- ";
+    case "modified_by":
+      return " -.-> ";
+    default:
+      return " --- ";
+  }
+}
+async function generateVisualizeReport(options = {}) {
+  const diagram = await visualizeGraph(options);
+  const lines = [
+    "\u{1F3A8} **Knowledge Graph Visualization**",
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+    "",
+    diagram,
+    "",
+    "\u{1F4CB} **Rendering Instructions:**",
+    "- Paste the Mermaid code above into any Mermaid-compatible viewer",
+    "- GitHub: Mermaid code blocks render automatically",
+    "- VS Code: Install 'Markdown Preview Mermaid Support' extension",
+    "- Online: https://mermaid.live",
+    "",
+    "\u{1F4A1} Use `kuma_visualize({ type: 'dependency' })` for clustered view",
+    "\u{1F4A1} Use `kuma_visualize({ type: 'mindmap' })` for overview",
+    "\u{1F4A1} Use `kuma_visualize({ scope: 'auth' })` to filter by topic"
+  ];
+  return lines.join("\n");
+}
+export {
+  generateVisualizeReport,
+  visualizeGraph
+};

package/dist/{safetyScore-VYT6OMVG.js → safetyScore-PJGRRBWP.js}

@@ -2,10 +2,10 @@ import {
   getGitDiffStat,
   getSessionStats,
   getUnresolvedCount
-} from "./chunk-ZIFLGJ5R.js";
+} from "./chunk-FOQQ2CSL.js";
 import {
   sessionMemory
-} from "./chunk-PH4JKL6T.js";
+} from "./chunk-BI7KD3SG.js";
 import "./chunk-E2KFPEBT.js";
 
 // src/engine/safetyScore.ts
@@ -15,7 +15,7 @@ async function computeSafetyScore(inputGoal) {
   let totalScore = 0;
   const maxScore = 100;
   const gitStat = getGitDiffStat();
-  if (gitStat) {
+  if (gitStat && gitStat !== "clean") {
     const lines = gitStat.split("\n").filter(Boolean).length;
     if (lines === 0) {
       checks.push({
@@ -42,6 +42,14 @@ async function computeSafetyScore(inputGoal) {
       });
       totalScore += 10;
     }
+  } else if (gitStat === "clean") {
+    checks.push({
+      label: "Git Clean",
+      status: "pass",
+      message: "Working tree is clean",
+      weight: 20
+    });
+    totalScore += 20;
   } else {
     checks.push({
       label: "Git Status",
@@ -52,7 +60,7 @@ async function computeSafetyScore(inputGoal) {
     totalScore += 20;
   }
   try {
-    const { getDb } = await import("./kumaDb-FQ3YKJ6K.js");
+    const { getDb } = await import("./kumaDb-DJUDLYBJ.js");
     const db = await getDb();
     const nodeCount = db.exec("SELECT COUNT(*) as c FROM nodes")[0]?.values[0][0] ?? 0;
     const edgeCount = db.exec("SELECT COUNT(*) as c FROM edges")[0]?.values[0][0] ?? 0;
@@ -83,7 +91,7 @@ async function computeSafetyScore(inputGoal) {
     totalScore += 5;
   }
   try {
-    const { getDb } = await import("./kumaDb-FQ3YKJ6K.js");
+    const { getDb } = await import("./kumaDb-DJUDLYBJ.js");
     const db = await getDb();
     const researchCount = db.exec("SELECT COUNT(*) as c FROM research_cache")[0]?.values[0][0] ?? 0;
     checks.push({
@@ -108,7 +116,7 @@ async function computeSafetyScore(inputGoal) {
   const hasRunTests = stats.hasRunTests;
   let latestVerif = null;
   try {
-    const { getLatestVerifications } = await import("./kumaDb-FQ3YKJ6K.js");
+    const { getLatestVerifications } = await import("./kumaDb-DJUDLYBJ.js");
     const verifs = await getLatestVerifications(1);
     if (verifs.length > 0) latestVerif = verifs[0];
   } catch {

package/dist/{sessionMemory-PGYVS3BK.js → sessionMemory-HBBXUSIP.js}

@@ -1,6 +1,6 @@
 import {
   sessionMemory
-} from "./chunk-PH4JKL6T.js";
+} from "./chunk-BI7KD3SG.js";
 export {
   sessionMemory
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumpslabs/kuma",
-  "version": "2.3.5",
+  "version": "2.3.7",
   "description": "Safety-first context & orchestration engine for AI coding agents. MCP server with mandatory research pipeline, knowledge graph, impact analysis, decision memory, and safety guard — works with any MCP client.",
   "type": "module",
   "main": "dist/index.js",