@plumpslabs/kuma 2.3.1 → 2.3.3

package/README.md

@@ -122,6 +122,7 @@ Kuma consolidates everything into **3 coarse-grained tools**. Each action trigge
 | Action | Use case |
 |--------|----------|
 | `decision` | ADR-style recording: template, suggest, or record. |
+| `mine` | Mine historical decisions from git log & inline code comments. |
 | `research_save` | Persist research to graph + `.kuma/research/<scope>.json`. |
 | `session` | "What happened this session?" — files, failures, progress. |
 | `heal` | Self-heal knowledge graph — stale detection, git repair. |
@@ -133,6 +134,7 @@ Kuma consolidates everything into **3 coarse-grained tools**. Each action trigge
 | Action | Use case |
 |--------|----------|
 | `guard` | Anti-pattern, drift, tool-loop, and failure checks. |
+| `verify` | Integrated auto-verification — auto-detect runner & execute scoped tests. |
 | `check` | Pre-execution safety: policy, path, lock, risk level. |
 | `audit` | Query audit trail + stats + override log. |
 | `lock` | Multi-agent file locking. |

package/dist/{chunk-ZDQVSBFB.js → chunk-FSDW4F3U.js}

@@ -1,7 +1,7 @@
 import {
   getDb,
   saveDb
-} from "./chunk-2IIDVJPW.js";
+} from "./chunk-MTH4DRP7.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-JQT5GEWO.js");
+    const { sessionMemory } = await import("./sessionMemory-45V6XJRH.js");
     const toolCalls = sessionMemory.getToolCallHistory(50);
     let edgeCount = 0;
     for (const call of toolCalls) {

package/dist/{chunk-5WSPGLXS.js → chunk-L5WU2HTN.js}

@@ -270,6 +270,7 @@ function generateInitMdContent() {
     "",
     '- `kuma_memory({ action: "research_save", scope: "...", ... })` \u2014 Save research results',
     '- `kuma_memory({ action: "decision", decisionAction: "record", ... })` \u2014 ADR-style decision',
+    '- **`kuma_memory({ action: "mine", scope: "..." })` \u2014 Mine historical decisions from git log & comments**',
     '- `kuma_memory({ action: "session" })` \u2014 Session summary',
     '- `kuma_memory({ action: "heal" })` \u2014 Self-heal knowledge graph',
     '- `kuma_memory({ action: "search", query: "..." })` \u2014 Search memories + graph',
@@ -278,6 +279,7 @@ function generateInitMdContent() {
     "### \u{1F6E1}\uFE0F kuma_safety \u2014 Safety & Policy",
     "",
     '- `kuma_safety({ action: "guard", guardGoal: "..." })` \u2014 Anti-pattern, drift, loop detection',
+    '- **`kuma_safety({ action: "verify", scope: "..." })` \u2014 Auto-run scoped tests & verify correctness**',
     '- `kuma_safety({ action: "check", ... })` \u2014 Pre-execution safety check',
     '- `kuma_safety({ action: "audit" })` \u2014 Query safety audit trail',
     '- `kuma_safety({ action: "lock", lockAction: "acquire", ... })` \u2014 Multi-agent file lock',

package/dist/{chunk-WG47POMW.js → chunk-MSKQRKME.js}

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

package/dist/{chunk-2IIDVJPW.js → chunk-MTH4DRP7.js}

@@ -239,6 +239,39 @@ function createSchema(db) {
     created_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
     updated_at INTEGER NOT NULL DEFAULT (strftime('%s','now'))
   )`);
+  db.run(`CREATE TABLE IF NOT EXISTS otel_config (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    endpoint TEXT,
+    service_name TEXT DEFAULT 'kuma',
+    enabled INTEGER DEFAULT 0,
+    created_at INTEGER NOT NULL DEFAULT (strftime('%s','now'))
+  )`);
+  db.run(`CREATE TABLE IF NOT EXISTS cost_tracking (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id INTEGER REFERENCES sessions(id),
+    tool_name TEXT NOT NULL,
+    token_estimate INTEGER DEFAULT 0,
+    cost_estimate REAL DEFAULT 0.0,
+    budget_limit REAL DEFAULT 0.0,
+    escalated INTEGER DEFAULT 0,
+    created_at INTEGER NOT NULL DEFAULT (strftime('%s','now'))
+  )`);
+  db.run(`CREATE TABLE IF NOT EXISTS scratch_entries (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_path TEXT NOT NULL,
+    reason TEXT,
+    created_at INTEGER NOT NULL DEFAULT (strftime('%s','now'))
+  )`);
+  db.run(`CREATE TABLE IF NOT EXISTS verifications (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    scope TEXT NOT NULL,
+    runner TEXT NOT NULL,
+    test_command TEXT NOT NULL,
+    passed INTEGER NOT NULL,
+    output TEXT,
+    duration_ms INTEGER,
+    created_at INTEGER NOT NULL DEFAULT (strftime('%s','now'))
+  )`);
   db.run(`CREATE TABLE IF NOT EXISTS portability_entries (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     entry_type TEXT NOT NULL,
@@ -804,6 +837,38 @@ async function saveHealthSnapshot(score, riskLevel, checks, summary) {
     console.error(`[KumaDB] Failed to save health snapshot: ${err}`);
   }
 }
+async function saveVerification(scope, runner, command, passed, output, durationMs = 0) {
+  try {
+    const db = await getDb();
+    db.run(
+      `INSERT INTO verifications (scope, runner, test_command, passed, output, duration_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+      [scope, runner, command, passed ? 1 : 0, output, durationMs]
+    );
+    saveDb();
+  } catch (err) {
+    console.error(`[KumaDB] Failed to save verification: ${err}`);
+  }
+}
+async function getLatestVerifications(limit = 10) {
+  try {
+    const db = await getDb();
+    const res = db.exec(`SELECT id, scope, runner, test_command, passed, output, duration_ms, created_at FROM verifications ORDER BY created_at DESC LIMIT ${limit}`);
+    if (!res[0] || !res[0].values) return [];
+    return res[0].values.map((row) => ({
+      id: row[0],
+      scope: row[1],
+      runner: row[2],
+      test_command: row[3],
+      passed: Boolean(row[4]),
+      output: row[5],
+      duration_ms: row[6],
+      created_at: row[7]
+    }));
+  } catch (err) {
+    console.error(`[KumaDB] Failed to get verifications: ${err}`);
+    return [];
+  }
+}
 
 export {
   getDb,
@@ -832,5 +897,7 @@ export {
   runDoctor,
   checkPortability,
   ensureGitignore,
-  saveHealthSnapshot
+  saveHealthSnapshot,
+  saveVerification,
+  getLatestVerifications
 };

package/dist/{chunk-6W7YV4AF.js → chunk-N6QMWZGQ.js}

@@ -320,7 +320,7 @@ No unresolved issues.`;
    */
   async autoTrackToDb(toolName, params, timestamp) {
     try {
-      const { getDb, saveDb } = await import("./kumaDb-PA7XVERC.js");
+      const { getDb, saveDb } = await import("./kumaDb-7VSQ4QLW.js");
       const db = await getDb();
       db.run(
         `INSERT INTO tool_calls (tool_name, params, success, duration_ms, created_at) VALUES (?, ?, 1, 0, ?)`,
@@ -597,7 +597,7 @@ No unresolved issues.`;
       this.addModifiedFile(filePath);
     }
     try {
-      const { recordChange } = await import("./kumaDb-PA7XVERC.js");
+      const { recordChange } = await import("./kumaDb-7VSQ4QLW.js");
       const gitHash = this.getGitHead();
       await recordChange({ filePath, changeType, symbol, gitCommitHash: gitHash || void 0 });
     } catch {

package/dist/{chunk-4CKTTORL.js → chunk-RWPJ5RWM.js}

@@ -1,6 +1,6 @@
 import {
   sessionMemory
-} from "./chunk-6W7YV4AF.js";
+} from "./chunk-N6QMWZGQ.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-VUTLTOFY.js");
+    const { upsertNode, addEdge } = await import("./kumaGraph-NHEAXC2V.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

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+import {
+  ALL_CONFIG_TYPES,
+  formatInitResults,
+  runInit
+} from "./chunk-L5WU2HTN.js";
 import {
   analyzeImpact,
   autoHeal,
@@ -9,7 +14,13 @@ import {
   getGraphStats,
   searchGraph,
   traceFlow
-} from "./chunk-ZDQVSBFB.js";
+} from "./chunk-FSDW4F3U.js";
+import {
+  buildDriftMessages,
+  getGitDiffStat,
+  getSessionStats,
+  getUnresolvedCount
+} from "./chunk-MSKQRKME.js";
 import {
   addContextNote,
   addSecurityFinding,
@@ -35,27 +46,16 @@ import {
   saveResearchCache,
   updateDecisionStatus,
   updateTodoStatus
-} from "./chunk-2IIDVJPW.js";
+} from "./chunk-MTH4DRP7.js";
 import {
   formatDecisionTemplate,
   getProactiveMemories,
   recordDecision,
   scoreMemoryRelevance
-} from "./chunk-4CKTTORL.js";
-import {
-  buildDriftMessages,
-  getGitDiffStat,
-  getSessionStats,
-  getUnresolvedCount
-} from "./chunk-WG47POMW.js";
+} from "./chunk-RWPJ5RWM.js";
 import {
   sessionMemory
-} from "./chunk-6W7YV4AF.js";
-import {
-  ALL_CONFIG_TYPES,
-  formatInitResults,
-  runInit
-} from "./chunk-5WSPGLXS.js";
+} from "./chunk-N6QMWZGQ.js";
 import {
   getProjectRoot,
   validateFilePath
@@ -74,8 +74,49 @@ import { z } from "zod";
 import fs from "fs";
 import path from "path";
 import crypto from "crypto";
+var CONTEXT_ALIASES = {
+  // Research synonyms
+  "research": "research",
+  "search": "research",
+  "explore": "research",
+  "inspect": "research",
+  // Impact synonyms
+  "analyze": "impact",
+  "impact": "impact",
+  "whatif": "impact",
+  "refactor": "impact",
+  // Navigate synonyms
+  "trace": "navigate",
+  "flow": "navigate",
+  "navigate": "navigate",
+  // Init synonyms
+  "init": "init",
+  "start": "init",
+  "load": "init",
+  "brief": "init",
+  "project": "init",
+  "summary": "init",
+  // Changes synonyms
+  "changes": "changes",
+  "log": "changes",
+  "history": "changes",
+  // Health synonyms
+  "health": "health",
+  "score": "health",
+  "status": "health",
+  // Rollback synonyms
+  "rollback": "rollback",
+  "undo": "rollback",
+  "revert": "rollback",
+  // Researches synonyms
+  "researches": "researches",
+  "research-list": "researches",
+  "list-research": "researches"
+};
 async function handleContext(params) {
-  const { action } = params;
+  const rawAction = params.action || "init";
+  const resolvedAction = CONTEXT_ALIASES[rawAction.toLowerCase()] || rawAction;
+  const action = resolvedAction;
   switch (action) {
     case "init":
       return handleInit(params);
@@ -155,8 +196,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-OQFYLLP7.js");
-    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-PA7XVERC.js");
+    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-GX2YMCQT.js");
+    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-7VSQ4QLW.js");
     const score = await computeSafetyScore(_params.goal);
     const checksStr = JSON.stringify(score.checks);
     await saveHealthSnapshot2(score.score, score.risk, checksStr, score.summary);
@@ -329,8 +370,8 @@ async function handleResearches(_params) {
 async function handleHealth(_params) {
   sessionMemory.recordToolCall("kuma_context_health", {});
   try {
-    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-OQFYLLP7.js");
-    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-PA7XVERC.js");
+    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-GX2YMCQT.js");
+    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-7VSQ4QLW.js");
     const score = await computeSafetyScore();
     const checksStr = JSON.stringify(score.checks);
     await saveHealthSnapshot2(score.score, score.risk, checksStr, score.summary);
@@ -361,12 +402,77 @@ function computeProjectHash(scope) {
 // src/tools/kumaMemoryTool.ts
 import fs2 from "fs";
 import path2 from "path";
+var MEMORY_ALIASES = {
+  // Session synonyms
+  "session": "session",
+  "summary": "session",
+  "status": "session",
+  "get": "session",
+  "read": "session",
+  "fetch": "session",
+  "current": "session",
+  // Decision synonyms
+  "decision": "decision",
+  "adr": "decision",
+  "record-decision": "decision",
+  // Research save synonyms
+  "research_save": "research_save",
+  "save": "research_save",
+  "store": "research_save",
+  "write": "research_save",
+  "persist": "research_save",
+  "cache": "research_save",
+  // Mine synonyms
+  "mine": "mine",
+  "mine-decisions": "mine",
+  "git-mine": "mine",
+  "dig": "mine",
+  // Heal synonyms
+  "heal": "heal",
+  "repair": "heal",
+  "fix-graph": "heal",
+  "clean-graph": "heal",
+  // Search synonyms
+  "search": "search",
+  "find": "search",
+  "query": "search",
+  "lookup": "search",
+  // Todo synonyms
+  "todo": "todo",
+  "task": "todo",
+  "todos": "todo",
+  "tasks": "todo",
+  // Context notes synonyms
+  "context": "context",
+  "notes": "context",
+  "note": "context",
+  "inject": "context",
+  "context-note": "context",
+  // Benchmark synonyms
+  "benchmark": "benchmark",
+  "perf": "benchmark",
+  "metrics": "benchmark",
+  "measure": "benchmark",
+  // Decision log synonyms
+  "decision_log": "decision_log",
+  "decisions": "decision_log",
+  "log": "decision_log",
+  "decision-log": "decision_log",
+  // Changes synonyms
+  "changes": "changes",
+  "change-log": "changes",
+  "history": "changes"
+};
 async function handleMemory(params) {
-  const { action } = params;
-  sessionMemory.recordToolCall("kuma_memory", { action });
+  const rawAction = params.action || "session";
+  const key = rawAction.toLowerCase().replace(/[\s_-]+/g, "-");
+  const action = MEMORY_ALIASES[key] || rawAction;
+  sessionMemory.recordToolCall("kuma_memory", { action: rawAction });
   switch (action) {
     case "decision":
       return handleDecision(params);
+    case "mine":
+      return handleMine(params);
     case "research_save":
       return handleResearchSave(params);
     case "session":
@@ -395,7 +501,7 @@ async function handleDecision(params) {
     case "template":
       return formatDecisionTemplate();
     case "suggest": {
-      const { shouldRecordDecision } = await import("./kumaMemory-YEIEXGNW.js");
+      const { shouldRecordDecision } = await import("./kumaMemory-UFRSJTWL.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.";
@@ -473,7 +579,7 @@ 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-VUTLTOFY.js");
+  const { searchGraph: searchGraph2 } = await import("./kumaGraph-NHEAXC2V.js");
   const graphResults = await searchGraph2(query, Math.min(limit, 10));
   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
@@ -487,7 +593,8 @@ async function handleSearch(params) {
   return lines.join("\n");
 }
 async function handleChanges2(params) {
-  return await getChanges({ filePath: params.target, since: params.since });
+  const sinceNum = typeof params.since === "number" ? params.since : typeof params.since === "string" ? parseInt(params.since, 10) || void 0 : void 0;
+  return await getChanges({ filePath: params.target, since: sinceNum });
 }
 async function handleTodo(params) {
   if (params.todoId && params.status) {
@@ -545,6 +652,16 @@ async function handleDecisionLog(params) {
   }
   return await listDecisionLog(params.status);
 }
+async function handleMine(params) {
+  sessionMemory.recordToolCall("kuma_memory_mine", { scope: params.scope });
+  const { mineHistoricalDecisions } = await import("./kumaMiner-UFDDVBRP.js");
+  return await mineHistoricalDecisions({
+    scope: params.scope,
+    since: typeof params.since === "string" ? params.since : void 0,
+    confirm: params.confirm,
+    limit: params.limit
+  });
+}
 
 // src/engine/kumaLock.ts
 import fs3 from "fs";
@@ -1257,7 +1374,7 @@ function findPatchScripts(projectRoot) {
     const ext = path5.extname(file).toLowerCase();
     if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
     const relativePath = path5.relative(projectRoot, file);
-    if (relativePath.startsWith("src") || relativePath.startsWith("test") || relativePath.startsWith("node_modules") || relativePath.startsWith(".")) {
+    if (relativePath.startsWith("src") || relativePath.startsWith("test") || relativePath.startsWith("node_modules") || relativePath.startsWith(".") || relativePath.startsWith(".kuma/scratch")) {
       continue;
     }
     try {
@@ -1607,6 +1724,8 @@ async function handleSafety(params) {
   switch (action) {
     case "guard":
       return handleGuard(params);
+    case "verify":
+      return handleVerify(params);
     case "check":
       return handleCheck(params);
     case "audit":
@@ -1627,6 +1746,8 @@ async function handleSafety(params) {
       return handlePortability(params);
     case "gitignore":
       return handleGitignore(params);
+    case "clean":
+      return handleClean(params);
     default:
       return `Unknown action "${action}".`;
   }
@@ -1670,7 +1791,7 @@ async function handleLock(params) {
 }
 async function handleHealth2(_params) {
   try {
-    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-OQFYLLP7.js");
+    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-GX2YMCQT.js");
     const score = await computeSafetyScore();
     await saveHealthSnapshot(score.score, score.risk, JSON.stringify(score.checks), score.summary);
     return formatSafetyScore(score);
@@ -1742,6 +1863,47 @@ async function handleGitignore(_params) {
   sessionMemory.recordToolCall("kuma_safety_gitignore", {});
   return await ensureGitignore();
 }
+async function handleClean(_params) {
+  sessionMemory.recordToolCall("kuma_safety_clean", {});
+  const fs7 = await import("fs");
+  const path7 = await import("path");
+  const root = process.cwd();
+  const scratchDir = path7.resolve(root, ".kuma", "scratch");
+  let removed = 0;
+  if (fs7.existsSync(scratchDir)) {
+    try {
+      const entries = fs7.readdirSync(scratchDir);
+      for (const entry of entries) {
+        const fullPath = path7.join(scratchDir, entry);
+        try {
+          const stat = fs7.statSync(fullPath);
+          if (stat.isFile()) {
+            fs7.unlinkSync(fullPath);
+            removed++;
+          } else if (stat.isDirectory()) {
+            fs7.rmSync(fullPath, { recursive: true, force: true });
+            removed++;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  sessionMemory.setGoal(sessionMemory.getSummary().currentGoal || "cleaned");
+  const result = removed > 0 ? `\u{1F9F9} **Scratch Clean** \u2014 Removed ${removed} item(s) from .kuma/scratch/` : `\u{1F9F9} **Scratch Clean** \u2014 No scratch files to clean.`;
+  return `${result}
+\u{1F4A1} Drift warnings have been reset. Any temporary debug artifacts are now cleared.`;
+}
+async function handleVerify(params) {
+  sessionMemory.recordToolCall("kuma_safety_verify", { scope: params.scope || params.filePath });
+  const { runAutoVerification } = await import("./kumaVerifier-Y4FQ2LOD.js");
+  return await runAutoVerification({
+    scope: params.scope || params.filePath,
+    force: params.force,
+    timeoutMs: 3e4
+  });
+}
 
 // src/manifest.ts
 function registerAllTools(server) {
@@ -1774,14 +1936,15 @@ function registerAllTools(server) {
   );
   server.tool(
     "kuma_memory",
-    "Record and retrieve project knowledge. Actions: decision (ADR-style record/template/suggest), research_save (save research), session (session summary), heal (graph repair), search (search all), changes (change log), todo (persistent todo CRUD), context (inject context notes), benchmark (capture/diff metrics), decision_log (living document with status tracking).",
+    "Record and retrieve project knowledge. Actions: decision (ADR-style record/template/suggest), mine (mine historical decisions from git log & code comments), research_save (save research), session (session summary), heal (graph repair), search (search all), changes (change log), todo (persistent todo CRUD), context (inject context notes), benchmark (capture/diff metrics), decision_log (living document with status tracking).",
     {
-      action: z.enum(["decision", "research_save", "session", "heal", "search", "changes", "todo", "context", "benchmark", "decision_log"]).describe("Memory action: decision=ADR, research_save=save, session=summary, heal=repair, search=search, changes=log, todo=manage todos, context=inject notes, benchmark=capture/diff, decision_log=manage decisions"),
-      scope: z.string().optional().describe("Scope for research_save/search/todo/context"),
+      action: z.enum(["decision", "mine", "research_save", "session", "heal", "search", "changes", "todo", "context", "benchmark", "decision_log"]).describe("Memory action: decision=ADR, mine=mine git log & comments, research_save=save, session=summary, heal=repair, search=search, changes=log, todo=manage todos, context=inject notes, benchmark=capture/diff, decision_log=manage decisions"),
+      scope: z.string().optional().describe("Scope for research_save/search/todo/context/mine"),
       query: z.string().optional().describe("Search query for search action"),
       content: z.string().optional().describe("Content/notes for research_save / context"),
       record: z.string().optional().describe("JSON record string for research_save"),
       confidence: z.number().min(0).max(1).optional().describe("Confidence for research_save (0-1)"),
+      confirm: z.boolean().optional().describe("Confirm and record candidates automatically for mine action"),
       // Decision params
       decisionAction: z.enum(["template", "suggest", "record"]).optional().describe("Decision sub-action"),
       title: z.string().optional().describe("Decision/todo/benchmark title"),
@@ -1817,6 +1980,7 @@ function registerAllTools(server) {
           content: params.content,
           record: params.record,
           confidence: params.confidence,
+          confirm: params.confirm,
           decisionAction: params.decisionAction,
           title: params.title,
           context: params.context,
@@ -1836,9 +2000,11 @@ function registerAllTools(server) {
   );
   server.tool(
     "kuma_safety",
-    "Safety checks, policy enforcement, security scanning, and project hygiene. Actions: guard (anti-pattern detection), check (pre-exec safety), audit (query trail), lock (multi-agent), health (score), security (scan for leaks), gc (garbage collection), doctor (health check), portability (path check), gitignore (auto-config), override (bypass).",
+    "Safety checks, policy enforcement, security scanning, integrated auto-verification, and project hygiene. Actions: guard (anti-pattern detection), verify (auto-run scoped tests), check (pre-exec safety), audit (query trail), lock (multi-agent), health (score), security (scan for leaks), gc (garbage collection), doctor (health check), portability (path check), gitignore (auto-config), override (bypass).",
     {
-      action: z.enum(["guard", "check", "audit", "lock", "health", "override", "security", "gc", "doctor", "portability", "gitignore"]).describe("Safety action: guard=anti-patterns, check=pre-exec safety, audit=query trail, lock=multi-agent, health=score, security=scan leaks, gc=garbage collect, doctor=health check, portability=paths, gitignore=config, override=bypass"),
+      action: z.enum(["guard", "verify", "check", "audit", "lock", "health", "override", "security", "gc", "doctor", "portability", "gitignore", "clean"]).describe("Safety action: guard=anti-patterns, verify=auto-run scoped tests, check=pre-exec safety, audit=query trail, lock=multi-agent, health=score, security=scan leaks, gc=garbage collect, doctor=health check, portability=paths, gitignore=config, clean=purge scratch dir & drift, override=bypass"),
+      // Verify params
+      scope: z.string().optional().describe("Scope for verify or context (e.g. 'auth', file path)"),
       // Guard params
       guardGoal: z.string().optional().describe("Goal for guard check"),
       guardCheck: z.enum(["all", "anti-pattern", "loop", "drift", "context"]).optional().describe("Guard check type"),
@@ -1866,6 +2032,7 @@ function registerAllTools(server) {
           guardGoal: params.guardGoal,
           guardCheck: params.guardCheck,
           filePath: params.filePath,
+          scope: params.scope,
           command: params.command,
           toolName: params.toolName,
           riskLevel: params.riskLevel,
@@ -2013,7 +2180,7 @@ async function main() {
   });
   (async () => {
     try {
-      const { generateInitMdContent } = await import("./init-3MBHSTWD.js");
+      const { generateInitMdContent } = await import("./init-AJAESUZZ.js");
       const fs7 = await import("fs");
       const path7 = await import("path");
       const initMdPath = path7.resolve(process.cwd(), ".kuma/init.md");
@@ -2071,7 +2238,7 @@ async function main() {
         console.error(`[${SERVER_NAME}] \u2705 Restored session (${sessionInfo.toolCallCount} previous tool calls)`);
       }
       try {
-        const { buildFromSessionMemory } = await import("./kumaGraph-VUTLTOFY.js");
+        const { buildFromSessionMemory } = await import("./kumaGraph-NHEAXC2V.js");
         const edgeCount = await buildFromSessionMemory();
         if (edgeCount > 0) {
           console.error(`[${SERVER_NAME}] \u2705 Graph auto-populated with ${edgeCount} entries from session memory`);
@@ -2080,7 +2247,18 @@ async function main() {
         console.error(`[${SERVER_NAME}] \u26A0\uFE0F Graph auto-population: ${err}`);
       }
       try {
-        const { getDb: getDb2, saveDb: saveDb2 } = await import("./kumaDb-PA7XVERC.js");
+        const fs7 = await import("fs");
+        const path7 = await import("path");
+        const scratchDir = path7.resolve(process.cwd(), ".kuma", "scratch");
+        if (!fs7.existsSync(scratchDir)) {
+          fs7.mkdirSync(scratchDir, { recursive: true });
+          console.error(`[${SERVER_NAME}] \u2705 Created .kuma/scratch/ for temporary debug artifacts`);
+        }
+      } catch (err) {
+        console.error(`[${SERVER_NAME}] \u26A0\uFE0F Scratch directory setup: ${err}`);
+      }
+      try {
+        const { getDb: getDb2, saveDb: saveDb2 } = await import("./kumaDb-7VSQ4QLW.js");
         const db = await getDb2();
         db.run(
           `INSERT INTO sessions (started_at, goal, tool_calls) VALUES (?, ?, ?)`,

package/dist/{init-3MBHSTWD.js → init-AJAESUZZ.js}

@@ -4,7 +4,7 @@ import {
   formatInitResults,
   generateInitMdContent,
   runInit
-} from "./chunk-5WSPGLXS.js";
+} from "./chunk-L5WU2HTN.js";
 import "./chunk-E2KFPEBT.js";
 export {
   ALL_CONFIG_TYPES,

package/dist/{kumaDb-PA7XVERC.js → kumaDb-7VSQ4QLW.js}

@@ -8,6 +8,7 @@ import {
   getChanges,
   getDb,
   getFileSummary,
+  getLatestVerifications,
   getResearchCache,
   getSecurityFindings,
   listContextNotes,
@@ -24,9 +25,10 @@ import {
   saveFileSummary,
   saveHealthSnapshot,
   saveResearchCache,
+  saveVerification,
   updateDecisionStatus,
   updateTodoStatus
-} from "./chunk-2IIDVJPW.js";
+} from "./chunk-MTH4DRP7.js";
 import "./chunk-E2KFPEBT.js";
 export {
   addContextNote,
@@ -38,6 +40,7 @@ export {
   getChanges,
   getDb,
   getFileSummary,
+  getLatestVerifications,
   getResearchCache,
   getSecurityFindings,
   listContextNotes,
@@ -54,6 +57,7 @@ export {
   saveFileSummary,
   saveHealthSnapshot,
   saveResearchCache,
+  saveVerification,
   updateDecisionStatus,
   updateTodoStatus
 };

package/dist/{kumaGraph-VUTLTOFY.js → kumaGraph-NHEAXC2V.js}

@@ -14,8 +14,8 @@ import {
   searchGraph,
   traceFlow,
   upsertNode
-} from "./chunk-ZDQVSBFB.js";
-import "./chunk-2IIDVJPW.js";
+} from "./chunk-FSDW4F3U.js";
+import "./chunk-MTH4DRP7.js";
 import "./chunk-E2KFPEBT.js";
 export {
   addEdge,

package/dist/{kumaMemory-YEIEXGNW.js → kumaMemory-UFRSJTWL.js}

@@ -4,8 +4,8 @@ import {
   recordDecision,
   scoreMemoryRelevance,
   shouldRecordDecision
-} from "./chunk-4CKTTORL.js";
-import "./chunk-6W7YV4AF.js";
+} from "./chunk-RWPJ5RWM.js";
+import "./chunk-N6QMWZGQ.js";
 import "./chunk-E2KFPEBT.js";
 export {
   formatDecisionTemplate,

package/dist/kumaMiner-UFDDVBRP.js

@@ -0,0 +1,142 @@
+import {
+  recordDecisionLog
+} from "./chunk-MTH4DRP7.js";
+import {
+  recordDecision
+} from "./chunk-RWPJ5RWM.js";
+import "./chunk-N6QMWZGQ.js";
+import "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaMiner.ts
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import fastGlob from "fast-glob";
+async function mineHistoricalDecisions(options = {}) {
+  const root = process.cwd();
+  const limit = options.limit || 15;
+  const candidates = [];
+  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 keywords = ["fix", "revert", "hack", "workaround", "urgent", "hotfix", "don't touch", "temporary", "deprecated", "workaround"];
+    const lines = gitOutput.split("\n").filter(Boolean);
+    for (const line of lines) {
+      const parts = line.split("|");
+      if (parts.length < 4) continue;
+      const [hash, author, date, subject] = parts;
+      const lowerSubj = subject.toLowerCase();
+      const matchedKeyword = keywords.find((kw) => lowerSubj.includes(kw));
+      if (matchedKeyword) {
+        let 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(", ");
+        } catch {
+        }
+        candidates.push({
+          id: `git-${hash}`,
+          type: "git_commit",
+          title: `[Git Commit] ${subject}`,
+          context: `Commit ${hash} by ${author} on ${date}.${changedFiles ? ` Files touched: ${changedFiles}` : ""}`,
+          rationale: `Historical signal pattern "${matchedKeyword}" found in commit message.`,
+          commitHash: hash,
+          pattern: matchedKeyword
+        });
+        if (candidates.length >= limit) break;
+      }
+    }
+  } catch {
+  }
+  if (candidates.length < limit) {
+    try {
+      const scopePattern = options.scope ? `**/*${options.scope}*.*` : "**/*.{ts,js,py,go,rs,java,md}";
+      const files = await fastGlob(scopePattern, {
+        cwd: root,
+        ignore: ["node_modules/**", "dist/**", ".kuma/**", ".git/**", "coverage/**"],
+        onlyFiles: true
+      });
+      const commentPatterns = [
+        { tag: "HACK", regex: /\/\/\s*HACK:?\s*(.*)|#\s*HACK:?\s*(.*)/i },
+        { tag: "FIXME", regex: /\/\/\s*FIXME:?\s*(.*)|#\s*FIXME:?\s*(.*)/i },
+        { tag: "TODO", regex: /\/\/\s*TODO:?\s*(.*)|#\s*TODO:?\s*(.*)/i },
+        { tag: "XXX", regex: /\/\/\s*XXX:?\s*(.*)|#\s*XXX:?\s*(.*)/i },
+        { tag: "WARNING", regex: /\/\/\s*WARNING:?\s*(.*)|#\s*WARNING:?\s*(.*)/i }
+      ];
+      for (const file of files.slice(0, 50)) {
+        if (candidates.length >= limit) break;
+        const fullPath = path.join(root, file);
+        if (!fs.existsSync(fullPath)) continue;
+        const content = fs.readFileSync(fullPath, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const l = lines[i];
+          for (const cp of commentPatterns) {
+            const match = cp.regex.exec(l);
+            if (match) {
+              const text = (match[1] || match[2] || l).trim();
+              candidates.push({
+                id: `comment-${file}-${i + 1}`,
+                type: "inline_comment",
+                title: `[${cp.tag}] ${file}:${i + 1}`,
+                context: `Inline comment marker "${cp.tag}" found in file "${file}" at line ${i + 1}.`,
+                rationale: text || l.trim(),
+                filePath: file,
+                lineNumber: i + 1,
+                pattern: cp.tag
+              });
+              if (candidates.length >= limit) break;
+            }
+          }
+          if (candidates.length >= limit) break;
+        }
+      }
+    } catch {
+    }
+  }
+  if (options.confirm && candidates.length > 0) {
+    let recordedCount = 0;
+    for (const c of candidates) {
+      await recordDecisionLog({
+        title: c.title,
+        context: c.context,
+        rationale: c.rationale,
+        outcome: `Mined from ${c.type} (${c.pattern})`,
+        status: "proposed"
+      });
+      await recordDecision({
+        title: c.title,
+        context: c.context,
+        options: [],
+        rationale: c.rationale,
+        outcome: `Mined from ${c.type}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      recordedCount++;
+    }
+    return `\u26CF\uFE0F **Mined & Recorded ${recordedCount} Decisions** into decision log & graph.
+Use \`kuma_memory({ action: 'decision_log' })\` to view all active & proposed decisions.`;
+  }
+  if (candidates.length === 0) {
+    return "\u26CF\uFE0F **Decision Mining**: No significant historical decision markers (HACK/FIXME/git fix) found for the requested scope.";
+  }
+  const report = [
+    `\u26CF\uFE0F **Decision Mining Candidates** (${candidates.length} candidate(s) found)`,
+    "\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\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",
+    "Review these draft historical decisions mined from git history & inline comments:",
+    ""
+  ];
+  candidates.forEach((c, idx) => {
+    report.push(`**${idx + 1}. ${c.title}**`);
+    report.push(`  \u2022 **Type**: \`${c.type}\` | **Signal**: \`${c.pattern}\``);
+    report.push(`  \u2022 **Context**: ${c.context}`);
+    report.push(`  \u2022 **Rationale**: ${c.rationale}`);
+    report.push("");
+  });
+  report.push("\u{1F4A1} *To accept and record these mined decisions into knowledge graph & decision.md:*");
+  report.push(`Run: \`kuma_memory({ action: 'mine', confirm: true${options.scope ? `, scope: '${options.scope}'` : ""} })\``);
+  return report.join("\n");
+}
+export {
+  mineHistoricalDecisions
+};

package/dist/kumaVerifier-Y4FQ2LOD.js

@@ -0,0 +1,123 @@
+import {
+  saveVerification
+} from "./chunk-MTH4DRP7.js";
+import {
+  sessionMemory
+} from "./chunk-N6QMWZGQ.js";
+import "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaVerifier.ts
+import fs from "fs";
+import path from "path";
+import { exec } from "child_process";
+function detectTestRunner(root = process.cwd()) {
+  const pkgPath = path.join(root, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      if (pkg.scripts && pkg.scripts.test) {
+        if (fs.existsSync(path.join(root, "pnpm-lock.yaml"))) {
+          return { runner: "pnpm", baseCommand: "pnpm test" };
+        }
+        if (fs.existsSync(path.join(root, "yarn.lock"))) {
+          return { runner: "yarn", baseCommand: "yarn test" };
+        }
+        return { runner: "npm", baseCommand: "npm test" };
+      }
+    } catch {
+    }
+  }
+  if (fs.existsSync(path.join(root, "pytest.ini")) || fs.existsSync(path.join(root, "pyproject.toml"))) {
+    return { runner: "pytest", baseCommand: "pytest" };
+  }
+  if (fs.existsSync(path.join(root, "Cargo.toml"))) {
+    return { runner: "cargo", baseCommand: "cargo test" };
+  }
+  if (fs.existsSync(path.join(root, "go.mod"))) {
+    return { runner: "go", baseCommand: "go test ./..." };
+  }
+  if (fs.existsSync(path.join(root, "Makefile"))) {
+    return { runner: "make", baseCommand: "make test" };
+  }
+  if (fs.existsSync(path.join(root, "package.json"))) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));
+      if (pkg.dependencies || pkg.devDependencies) {
+        if (fs.existsSync(path.join(root, "tsconfig.json"))) {
+          return { runner: "tsc", baseCommand: "npx tsc --noEmit" };
+        }
+        const srcDir = path.join(root, "src");
+        if (fs.existsSync(srcDir)) {
+          return { runner: "node", baseCommand: `node -c "${srcDir}/**/*.js" 2>/dev/null || node --check $(find src -name '*.js' 2>/dev/null | head -5)` };
+        }
+      }
+    } catch {
+    }
+  }
+  return { runner: "unknown", baseCommand: "npm test || echo 'No test runner configured'" };
+}
+async function runAutoVerification(options = {}) {
+  const startTime = Date.now();
+  const root = process.cwd();
+  const scope = options.scope || "session-impact";
+  const timeoutMs = options.timeoutMs || 3e4;
+  const { runner, baseCommand } = detectTestRunner(root);
+  let testFiles = [];
+  const modified = sessionMemory.getModifiedFiles().map((f) => f.filePath);
+  if (options.scope) {
+    const term = options.scope.toLowerCase();
+    testFiles = modified.filter((f) => f.toLowerCase().includes(term));
+    if (testFiles.length === 0) {
+      try {
+        const { default: glob } = await import("fast-glob");
+        const found = await glob([`**/*${term}*test*.*`, `**/*test*/*${term}*.*`], { cwd: root, ignore: ["node_modules/**", "dist/**"] });
+        testFiles = found;
+      } catch {
+      }
+    }
+  } else {
+    testFiles = modified.filter((f) => f.includes(".test.") || f.includes(".spec.") || f.includes("_test."));
+  }
+  let fullCommand = baseCommand;
+  if (testFiles.length > 0 && runner === "npm") {
+    fullCommand = `${baseCommand} -- ${testFiles.map((f) => `"${f}"`).join(" ")}`;
+  }
+  return new Promise((resolve) => {
+    exec(fullCommand, { cwd: root, timeout: timeoutMs }, async (error, stdout, stderr) => {
+      const durationMs = Date.now() - startTime;
+      const rawOutput = (stdout + "\n" + stderr).trim();
+      const passed = !error;
+      const truncatedOutput = rawOutput.length > 2e3 ? rawOutput.substring(rawOutput.length - 2e3) : rawOutput;
+      await saveVerification(scope, runner, fullCommand, passed, truncatedOutput, durationMs);
+      const statusSymbol = passed ? "\u2705" : "\u{1F534}";
+      const summaryHeader = `${statusSymbol} **Auto-Verification ${passed ? "PASSED" : "FAILED"}**
+\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\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`;
+      const details = [
+        summaryHeader,
+        `\u{1F6E0}\uFE0F **Runner**: \`${runner}\``,
+        `\u{1F4BB} **Command**: \`${fullCommand}\``,
+        `\u{1F3AF} **Scope**: \`${scope}\`${testFiles.length > 0 ? ` (${testFiles.length} file(s) matched)` : ""}`,
+        `\u23F1\uFE0F **Duration**: ${durationMs}ms`,
+        ""
+      ];
+      if (!passed) {
+        details.push("\u26A0\uFE0F **BLOCKER**: Verification failed! Please fix test failures before shipping or continuing edits.");
+        details.push("```text");
+        details.push(rawOutput.substring(0, 1500));
+        details.push("```");
+      } else {
+        details.push("\u{1F389} All scoped tests passed cleanly!");
+        if (rawOutput) {
+          details.push("```text");
+          details.push(rawOutput.substring(0, 800));
+          details.push("```");
+        }
+      }
+      resolve(details.join("\n"));
+    });
+  });
+}
+export {
+  detectTestRunner,
+  runAutoVerification
+};

package/dist/{safetyScore-OQFYLLP7.js → safetyScore-GX2YMCQT.js}

@@ -2,10 +2,10 @@ import {
   getGitDiffStat,
   getSessionStats,
   getUnresolvedCount
-} from "./chunk-WG47POMW.js";
+} from "./chunk-MSKQRKME.js";
 import {
   sessionMemory
-} from "./chunk-6W7YV4AF.js";
+} from "./chunk-N6QMWZGQ.js";
 import "./chunk-E2KFPEBT.js";
 
 // src/engine/safetyScore.ts
@@ -52,7 +52,7 @@ async function computeSafetyScore(inputGoal) {
     totalScore += 20;
   }
   try {
-    const { getDb } = await import("./kumaDb-PA7XVERC.js");
+    const { getDb } = await import("./kumaDb-7VSQ4QLW.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 +83,7 @@ async function computeSafetyScore(inputGoal) {
     totalScore += 5;
   }
   try {
-    const { getDb } = await import("./kumaDb-PA7XVERC.js");
+    const { getDb } = await import("./kumaDb-7VSQ4QLW.js");
     const db = await getDb();
     const researchCount = db.exec("SELECT COUNT(*) as c FROM research_cache")[0]?.values[0][0] ?? 0;
     checks.push({
@@ -106,14 +106,38 @@ async function computeSafetyScore(inputGoal) {
   const allFailures = stats.failedFiles.flatMap((f) => f.failures);
   const testFailures = allFailures.filter((f) => f.error.toLowerCase().includes("test") || f.error.toLowerCase().includes("fail"));
   const hasRunTests = stats.hasRunTests;
-  if (!hasRunTests) {
+  let latestVerif = null;
+  try {
+    const { getLatestVerifications } = await import("./kumaDb-7VSQ4QLW.js");
+    const verifs = await getLatestVerifications(1);
+    if (verifs.length > 0) latestVerif = verifs[0];
+  } catch {
+  }
+  if (!hasRunTests && !latestVerif) {
     checks.push({
       label: "Tests Status",
       status: "warn",
-      message: "No tests run yet this session",
+      message: "No tests run yet this session \u2014 run kuma_safety({ action: 'verify' })",
       weight: 10
     });
     totalScore += 10;
+  } else if (latestVerif) {
+    if (latestVerif.passed) {
+      checks.push({
+        label: "Tests Status",
+        status: "pass",
+        message: `Auto-verified passed (${latestVerif.scope})`,
+        weight: 15
+      });
+      totalScore += 15;
+    } else {
+      checks.push({
+        label: "Tests Status",
+        status: "fail",
+        message: `Auto-verification failed (${latestVerif.scope}) \u2014 fix before shipping`,
+        weight: 0
+      });
+    }
   } else if (testFailures.length === 0 && unresolvedCount === 0) {
     checks.push({
       label: "Tests Status",

package/dist/{sessionMemory-JQT5GEWO.js → sessionMemory-45V6XJRH.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumpslabs/kuma",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "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",