@plumpslabs/kuma 2.3.4 → 2.3.6

package/dist/{chunk-77G3APNG.js → chunk-BI7KD3SG.js}

@@ -320,7 +320,7 @@ No unresolved issues.`;
    */
   async autoTrackToDb(toolName, params, timestamp) {
     try {
-      const { getDb, saveDb } = await import("./kumaDb-I4AJ5A7H.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-I4AJ5A7H.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-BKEDQFEH.js → chunk-FOQQ2CSL.js}

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

package/dist/{chunk-NKNXJG2E.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 (
@@ -835,21 +846,6 @@ async function runDoctor() {
       }
     } catch {
     }
-    try {
-      const { isVerificationRunning, msSinceLastVerification, getRecentCallCount } = await import("./kumaVerifier-SSS4ZTJY.js");
-      const running = isVerificationRunning();
-      const sinceLast = msSinceLastVerification();
-      const callCount = getRecentCallCount();
-      checks.push("");
-      checks.push("**Verifier Status:**");
-      checks.push(`  ${running ? "\u{1F504}" : "\u{1F4A4}"} Currently ${running ? "running" : "idle"}`);
-      checks.push(`  \u23F1\uFE0F Last run: ${sinceLast < 0 ? "never" : `${Math.floor(sinceLast / 1e3)}s ago`}`);
-      checks.push(`  \u{1F4CA} Calls in 5min: ${callCount} (threshold: 3)`);
-      if (callCount >= 3) {
-        checks.push(`  \u{1F534} **Runaway protection active** \u2014 verifier is blocking further calls`);
-      }
-    } catch {
-    }
     return checks.join("\n");
   } catch (err) {
     return `\u274C Doctor failed: ${err}`;

package/dist/{chunk-5YCQG7V7.js → chunk-K64NSHBR.js}

@@ -1,7 +1,7 @@
 import {
   getDb,
   saveDb
-} from "./chunk-NKNXJG2E.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-SKKYUGB6.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-4CZSPSDW.js → chunk-X5TPBDKO.js}

@@ -1,6 +1,6 @@
 import {
   sessionMemory
-} from "./chunk-77G3APNG.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-KXI3Q7QF.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,7 +14,13 @@ import {
   getGraphStats,
   searchGraph,
   traceFlow
-} from "./chunk-5YCQG7V7.js";
+} from "./chunk-K64NSHBR.js";
+import {
+  buildDriftMessages,
+  getGitDiffStat,
+  getSessionStats,
+  getUnresolvedCount
+} from "./chunk-FOQQ2CSL.js";
 import {
   addContextNote,
   addSecurityFinding,
@@ -40,22 +46,16 @@ import {
   saveResearchCache,
   updateDecisionStatus,
   updateTodoStatus
-} from "./chunk-NKNXJG2E.js";
+} from "./chunk-GDNAWLHF.js";
 import {
   formatDecisionTemplate,
   getProactiveMemories,
   recordDecision,
   scoreMemoryRelevance
-} from "./chunk-4CZSPSDW.js";
-import {
-  buildDriftMessages,
-  getGitDiffStat,
-  getSessionStats,
-  getUnresolvedCount
-} from "./chunk-BKEDQFEH.js";
+} from "./chunk-X5TPBDKO.js";
 import {
   sessionMemory
-} from "./chunk-77G3APNG.js";
+} from "./chunk-BI7KD3SG.js";
 import {
   getProjectRoot,
   validateFilePath
@@ -111,7 +111,13 @@ 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"
 };
 async function handleContext(params) {
   const rawAction = params.action || "init";
@@ -134,8 +140,10 @@ async function handleContext(params) {
       return handleResearches(params);
     case "health":
       return handleHealth(params);
+    case "sync":
+      return handleSync(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`;
   }
 }
 async function handleInit(_params) {
@@ -196,8 +204,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-ZAOUPG6A.js");
-    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-I4AJ5A7H.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 +378,8 @@ async function handleResearches(_params) {
 async function handleHealth(_params) {
   sessionMemory.recordToolCall("kuma_context_health", {});
   try {
-    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-ZAOUPG6A.js");
-    const { saveHealthSnapshot: saveHealthSnapshot2 } = await import("./kumaDb-I4AJ5A7H.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 +388,55 @@ 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");
+}
 function computeProjectHash(scope) {
   try {
     const root = getProjectRoot();
@@ -501,7 +558,7 @@ async function handleDecision(params) {
     case "template":
       return formatDecisionTemplate();
     case "suggest": {
-      const { shouldRecordDecision } = await import("./kumaMemory-2HW4JLJU.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,7 +636,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-KXI3Q7QF.js");
+  const { searchGraph: searchGraph2 } = await import("./kumaGraph-35TAIBWD.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
@@ -654,7 +711,7 @@ async function handleDecisionLog(params) {
 }
 async function handleMine(params) {
   sessionMemory.recordToolCall("kuma_memory_mine", { scope: params.scope });
-  const { mineHistoricalDecisions } = await import("./kumaMiner-HZUBNYYP.js");
+  const { mineHistoricalDecisions } = await import("./kumaMiner-BIDSZE3Q.js");
   return await mineHistoricalDecisions({
     scope: params.scope,
     since: typeof params.since === "string" ? params.since : void 0,
@@ -1791,7 +1848,7 @@ async function handleLock(params) {
 }
 async function handleHealth2(_params) {
   try {
-    const { computeSafetyScore, formatSafetyScore } = await import("./safetyScore-ZAOUPG6A.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 +1962,7 @@ async function handleVerify(params) {
   }
   _lastVerifyCall = now;
   sessionMemory.recordToolCall("kuma_safety_verify", { scope: params.scope || params.filePath });
-  const { runAutoVerification } = await import("./kumaVerifier-SSS4ZTJY.js");
+  const { runAutoVerification } = await import("./kumaVerifier-B4D7NOFT.js");
   return await runAutoVerification({
     scope: params.scope || params.filePath,
     force: params.force,
@@ -2102,8 +2159,9 @@ async function main() {
   if (args[0] === "stop" && (args[1] === "--force" || args[1] === "-f")) {
     console.error(`\u{1F43B} Kuma v${SERVER_VERSION} \u2014 Kill Switch`);
     console.error("");
+    let killedCount = 0;
     try {
-      const { getRunningVerificationPid } = await import("./kumaVerifier-SSS4ZTJY.js");
+      const { getRunningVerificationPid } = await import("./kumaVerifier-B4D7NOFT.js");
       const pid = getRunningVerificationPid();
       if (pid) {
         try {
@@ -2114,10 +2172,41 @@ async function main() {
           process.kill(pid, "SIGKILL");
         } catch {
         }
-        console.error(`\u2705 Killed verification process (PID: ${pid})`);
+        console.error(`\u2705 Killed local verification process (PID: ${pid})`);
+        killedCount++;
       }
-    } catch (err) {
-      console.error(`\u26A0\uFE0F Could not check verifier: ${err}`);
+    } catch {
+    }
+    try {
+      const path7 = await import("path");
+      const fs7 = await import("fs");
+      const lockDir = path7.resolve(process.cwd(), ".kuma/verifier.lock");
+      if (fs7.existsSync(lockDir)) {
+        const pidFile = path7.join(lockDir, "pid");
+        if (fs7.existsSync(pidFile)) {
+          try {
+            const pid = parseInt(fs7.readFileSync(pidFile, "utf-8"), 10);
+            if (pid && pid !== process.pid) {
+              try {
+                process.kill(-pid, "SIGKILL");
+              } catch {
+              }
+              try {
+                process.kill(pid, "SIGKILL");
+              } catch {
+              }
+              console.error(`\u2705 Killed other instance verification (PID: ${pid})`);
+              killedCount++;
+            }
+          } catch {
+          }
+        }
+        fs7.rmSync(lockDir, { recursive: true, force: true });
+      }
+      if (killedCount === 0) {
+        console.error("\u2705 No running verifications found to kill.");
+      }
+    } catch {
     }
     try {
       const { execSync: execSync3 } = await import("child_process");
@@ -2311,7 +2400,7 @@ async function main() {
         console.error(`[${SERVER_NAME}] \u2705 Restored session (${sessionInfo.toolCallCount} previous tool calls)`);
       }
       try {
-        const { buildFromSessionMemory } = await import("./kumaGraph-KXI3Q7QF.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`);
@@ -2331,7 +2420,7 @@ async function main() {
         console.error(`[${SERVER_NAME}] \u26A0\uFE0F Scratch directory setup: ${err}`);
       }
       try {
-        const { getDb: getDb2, saveDb: saveDb2 } = await import("./kumaDb-I4AJ5A7H.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 (?, ?, ?)`,

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

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

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

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

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

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

package/dist/{kumaMiner-HZUBNYYP.js → kumaMiner-BIDSZE3Q.js}

@@ -1,10 +1,10 @@
 import {
   recordDecisionLog
-} from "./chunk-NKNXJG2E.js";
+} from "./chunk-GDNAWLHF.js";
 import {
   recordDecision
-} from "./chunk-4CZSPSDW.js";
-import "./chunk-77G3APNG.js";
+} from "./chunk-X5TPBDKO.js";
+import "./chunk-BI7KD3SG.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/kumaVerifier-B4D7NOFT.js

@@ -0,0 +1,235 @@
+import {
+  getLatestVerifications,
+  saveVerification
+} from "./chunk-GDNAWLHF.js";
+import {
+  sessionMemory
+} from "./chunk-BI7KD3SG.js";
+import "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaVerifier.ts
+import fs from "fs";
+import path from "path";
+import { exec } from "child_process";
+var LOCK_DIR_NAME = ".kuma/verifier.lock";
+function getLockDir(root = process.cwd()) {
+  return path.resolve(root, LOCK_DIR_NAME);
+}
+function getPidFile(root = process.cwd()) {
+  return path.join(getLockDir(root), "pid");
+}
+function acquireFileLock(root) {
+  const lockDir = getLockDir(root);
+  try {
+    fs.mkdirSync(lockDir, { recursive: false });
+    fs.writeFileSync(getPidFile(root), String(process.pid), "utf-8");
+    return true;
+  } catch {
+    try {
+      if (fs.existsSync(getPidFile(root))) {
+        const pid = parseInt(fs.readFileSync(getPidFile(root), "utf-8"), 10);
+        try {
+          process.kill(pid, 0);
+          return false;
+        } catch {
+          fs.rmSync(lockDir, { recursive: true, force: true });
+          return acquireFileLock(root);
+        }
+      }
+    } catch {
+    }
+    try {
+      fs.rmSync(lockDir, { recursive: true, force: true });
+      return acquireFileLock(root);
+    } catch {
+      return false;
+    }
+  }
+}
+function releaseFileLock(root) {
+  try {
+    fs.rmSync(getLockDir(root), { recursive: true, force: true });
+  } catch {
+  }
+}
+var _localRunning = false;
+var _currentProcess = null;
+var STALE_RESULT_MS = 3e5;
+var DEFAULT_TIMEOUT_MS = 3e4;
+function getRunningVerificationPid() {
+  return _currentProcess?.pid ?? null;
+}
+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'" };
+}
+function checkAllowed(root) {
+  if (_localRunning) return "\u23F3 Verification already in progress (this instance).";
+  if (!acquireFileLock(root)) return "\u23F3 Another Kuma instance is running verification.";
+  return null;
+}
+async function checkStaleness(scope) {
+  if (scope !== "session-impact" && scope !== void 0) return null;
+  try {
+    const recent = await getLatestVerifications(1);
+    if (recent.length === 0) return null;
+    const age = Date.now() - recent[0].created_at * 1e3;
+    if (age >= STALE_RESULT_MS) return null;
+    const ageSeconds = Math.floor(age / 1e3);
+    return [
+      `\u23E9 **Using cached verification** (${ageSeconds}s old, < 5 min threshold)`,
+      `\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`,
+      "",
+      `\u{1F6E0}\uFE0F Runner: \`${recent[0].runner}\``,
+      `\u{1F4BB} Command: \`${recent[0].test_command}\``,
+      `\u{1F3AF} Scope: \`${recent[0].scope}\``,
+      `\u23F1\uFE0F Original duration: ${recent[0].duration_ms}ms`,
+      "",
+      recent[0].passed ? "\u2705 **Result: PASSED** (served from cache)" : "\u{1F534} **Result: FAILED** (served from cache)",
+      "",
+      "\u{1F4A1} Use `force: true` to bypass cache and run tests again."
+    ].join("\n");
+  } catch {
+    return null;
+  }
+}
+async function runAutoVerification(options = {}) {
+  const startTime = Date.now();
+  const root = process.cwd();
+  const scope = options.scope || "session-impact";
+  const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+  const denial = checkAllowed(root);
+  if (denial) return denial;
+  try {
+    if (!options.force) {
+      const cached = await checkStaleness(scope);
+      if (cached) {
+        releaseFileLock(root);
+        return cached;
+      }
+    }
+    _localRunning = true;
+    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");
+          testFiles = await glob([`**/*${term}*test*.*`, `**/*test*/*${term}*.*`], { cwd: root, ignore: ["node_modules/**", "dist/**"] });
+        } 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 await new Promise((resolve) => {
+      const killTimer = setTimeout(() => {
+        if (_currentProcess && !_currentProcess.killed) {
+          try {
+            const childPid = _currentProcess.pid;
+            if (childPid) {
+              try {
+                process.kill(-childPid, "SIGKILL");
+              } catch {
+              }
+              try {
+                _currentProcess.kill("SIGKILL");
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+      }, timeoutMs + 5e3);
+      const heartbeatTimer = setInterval(() => {
+        if (getLockDir(root)) {
+          try {
+            fs.writeFileSync(getPidFile(root), String(process.pid), "utf-8");
+          } catch {
+          }
+        }
+      }, 15e3);
+      const child = 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);
+        _localRunning = false;
+        _currentProcess = null;
+        releaseFileLock(root);
+        clearInterval(heartbeatTimer);
+        const statusSymbol = passed ? "\u2705" : "\u{1F534}";
+        const lines = [
+          `${statusSymbol} **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`,
+          "",
+          `\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) {
+          lines.push("\u26A0\uFE0F **Verification failed!** Please fix test failures before shipping.");
+          if (error && error.killed) {
+            lines.push(`\u23F0 **Process was killed after ${timeoutMs}ms timeout**`);
+          }
+          lines.push("```text", rawOutput.substring(0, 1500), "```");
+        } else {
+          lines.push("\u{1F389} All scoped tests passed!");
+          if (rawOutput) lines.push("```text", rawOutput.substring(0, 800), "```");
+        }
+        resolve(lines.join("\n"));
+      });
+      _currentProcess = child;
+      _localRunning = true;
+      child.on("close", () => {
+        clearTimeout(killTimer);
+      });
+    });
+  } catch (err) {
+    releaseFileLock(root);
+    _localRunning = false;
+    _currentProcess = null;
+    return `\u274C Verification failed with error: ${err}`;
+  }
+}
+export {
+  detectTestRunner,
+  getRunningVerificationPid,
+  runAutoVerification
+};

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

@@ -2,10 +2,10 @@ import {
   getGitDiffStat,
   getSessionStats,
   getUnresolvedCount
-} from "./chunk-BKEDQFEH.js";
+} from "./chunk-FOQQ2CSL.js";
 import {
   sessionMemory
-} from "./chunk-77G3APNG.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-I4AJ5A7H.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-I4AJ5A7H.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-I4AJ5A7H.js");
+    const { getLatestVerifications } = await import("./kumaDb-DJUDLYBJ.js");
     const verifs = await getLatestVerifications(1);
     if (verifs.length > 0) latestVerif = verifs[0];
   } catch {

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

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

package/package.json

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

package/dist/kumaVerifier-SSS4ZTJY.js

@@ -1,243 +0,0 @@
-import {
-  getLatestVerifications,
-  saveVerification
-} from "./chunk-NKNXJG2E.js";
-import {
-  sessionMemory
-} from "./chunk-77G3APNG.js";
-import "./chunk-E2KFPEBT.js";
-
-// src/engine/kumaVerifier.ts
-import fs from "fs";
-import path from "path";
-import { exec } from "child_process";
-var _isRunning = false;
-var _lastCompletedAt = 0;
-var _callHistory = [];
-var RUNAWAY_WINDOW_MS = 5 * 60 * 1e3;
-var RUNAWAY_THRESHOLD = 3;
-var MIN_INTERVAL_MS = 6e4;
-var STALE_RESULT_MS = 3e5;
-var DEFAULT_TIMEOUT_MS = 3e4;
-var _currentProcess = null;
-function getRunningVerificationPid() {
-  return _currentProcess?.pid ?? null;
-}
-function isVerificationRunning() {
-  return _isRunning;
-}
-function msSinceLastVerification() {
-  if (_lastCompletedAt === 0) return -1;
-  return Date.now() - _lastCompletedAt;
-}
-function getRecentCallCount() {
-  const cutoff = Date.now() - RUNAWAY_WINDOW_MS;
-  return _callHistory.filter((t) => t > cutoff).length;
-}
-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'" };
-}
-function checkRateLimit() {
-  if (_isRunning) {
-    return "\u23F3 Verification already in progress \u2014 only 1 verification at a time. Wait for it to complete, or try again later.";
-  }
-  const cutoff = Date.now() - RUNAWAY_WINDOW_MS;
-  const recent = _callHistory.filter((t) => t > cutoff);
-  if (recent.length >= RUNAWAY_THRESHOLD) {
-    return `\u{1F534} **Runaway Detection Triggered**
-
-Verification has been called ${recent.length} times in the last 5 minutes. This looks like an uncontrolled loop. Verification has been **blocked** to prevent resource exhaustion.
-
-\u{1F4A1} If you need to verify, wait ${Math.ceil((RUNAWAY_WINDOW_MS - (Date.now() - recent[0])) / 6e4)} minutes, or run \`kuma_safety({ action: "doctor" })\` to check system status.
-
-\u{1F6A8} If this is unexpected, run \`pkill -f "pnpm test"\` to kill orphaned processes.`;
-  }
-  if (_lastCompletedAt > 0) {
-    const elapsed = Date.now() - _lastCompletedAt;
-    if (elapsed < MIN_INTERVAL_MS) {
-      const remaining = Math.ceil((MIN_INTERVAL_MS - elapsed) / 1e3);
-      return `\u23F3 Rate limit: verification was run ${Math.floor(elapsed / 1e3)}s ago. Please wait ${remaining}s before running verification again. (Minimum interval: ${MIN_INTERVAL_MS / 1e3}s)`;
-    }
-  }
-  return null;
-}
-async function checkStaleness(scope) {
-  if (scope === "session-impact" || scope === void 0) {
-    try {
-      const recent = await getLatestVerifications(1);
-      if (recent.length > 0) {
-        const age = Date.now() - recent[0].created_at * 1e3;
-        if (age < STALE_RESULT_MS) {
-          const ageSeconds = Math.floor(age / 1e3);
-          return [
-            `\u23E9 **Using cached verification** (${ageSeconds}s old, < 5 min threshold)`,
-            `\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`,
-            "",
-            `\u{1F6E0}\uFE0F Runner: \`${recent[0].runner}\``,
-            `\u{1F4BB} Command: \`${recent[0].test_command}\``,
-            `\u{1F3AF} Scope: \`${recent[0].scope}\``,
-            `\u23F1\uFE0F Original duration: ${recent[0].duration_ms}ms`,
-            "",
-            recent[0].passed ? "\u2705 **Result: PASSED** (served from cache)" : "\u{1F534} **Result: FAILED** (served from cache)",
-            "",
-            "\u{1F4A1} Use `force: true` to bypass cache and run tests again."
-          ].join("\n");
-        }
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-async function runAutoVerification(options = {}) {
-  const startTime = Date.now();
-  const root = process.cwd();
-  const scope = options.scope || "session-impact";
-  const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
-  const denial = checkRateLimit();
-  if (denial) {
-    return denial;
-  }
-  if (!options.force) {
-    const cached = await checkStaleness(scope);
-    if (cached) return cached;
-  }
-  _isRunning = true;
-  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) => {
-    const child = 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);
-      _isRunning = false;
-      _lastCompletedAt = Date.now();
-      _callHistory.push(Date.now());
-      while (_callHistory.length > 100) _callHistory.shift();
-      _currentProcess = null;
-      const statusSymbol = passed ? "\u2705" : "\u{1F534}";
-      const summaryHeader = `${statusSymbol} **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 **Verification failed!** Please fix test failures before shipping.");
-        if (error && error.killed) {
-          details.push(`\u23F0 **Process was killed after ${timeoutMs}ms timeout**`);
-        }
-        details.push("```text");
-        details.push(rawOutput.substring(0, 1500));
-        details.push("```");
-      } else {
-        details.push("\u{1F389} All scoped tests passed!");
-        if (rawOutput) {
-          details.push("```text");
-          details.push(rawOutput.substring(0, 800));
-          details.push("```");
-        }
-      }
-      resolve(details.join("\n"));
-    });
-    _currentProcess = child;
-    _isRunning = true;
-    const killTimer = setTimeout(() => {
-      if (_currentProcess && !_currentProcess.killed) {
-        try {
-          const childPid = _currentProcess.pid;
-          if (childPid) {
-            try {
-              process.kill(-childPid, "SIGKILL");
-            } catch {
-            }
-            try {
-              _currentProcess.kill("SIGKILL");
-            } catch {
-            }
-          }
-        } catch {
-        }
-      }
-    }, timeoutMs + 5e3);
-    child.on("close", () => {
-      clearTimeout(killTimer);
-    });
-  });
-}
-export {
-  detectTestRunner,
-  getRecentCallCount,
-  getRunningVerificationPid,
-  isVerificationRunning,
-  msSinceLastVerification,
-  runAutoVerification
-};