@plumpslabs/kuma 2.4.7 → 2.4.8

package/dist/index.js

@@ -258,9 +258,23 @@ function generateNodeId(type, name) {
 function resetDbInstance() {
   dbInstance = null;
   initPromise = null;
+  lastLoadedMtime = 0;
 }
 async function getDb() {
-  if (dbInstance) return dbInstance;
+  if (dbInstance) {
+    try {
+      const kumaDir = getKumaDir();
+      const dbPath = path2.join(kumaDir, DB_FILENAME);
+      if (fs2.existsSync(dbPath)) {
+        const stat = fs2.statSync(dbPath);
+        if (stat.mtimeMs > lastLoadedMtime + 50) {
+          resetDbInstance();
+        }
+      }
+    } catch {
+    }
+    if (dbInstance) return dbInstance;
+  }
   if (initPromise) return initPromise;
   initPromise = initDb();
   return initPromise;
@@ -274,6 +288,10 @@ async function initDb() {
   }
   let db;
   if (fs2.existsSync(dbPath)) {
+    try {
+      lastLoadedMtime = fs2.statSync(dbPath).mtimeMs;
+    } catch {
+    }
     const buffer = fs2.readFileSync(dbPath);
     db = new SQL.Database(buffer);
   } else {
@@ -309,8 +327,16 @@ function flushDb(db) {
     fs2.writeFileSync(tmpPath, buffer);
     try {
       fs2.renameSync(tmpPath, dbPath);
+      try {
+        lastLoadedMtime = fs2.statSync(dbPath).mtimeMs;
+      } catch {
+      }
     } catch {
       fs2.writeFileSync(dbPath, buffer);
+      try {
+        lastLoadedMtime = fs2.statSync(dbPath).mtimeMs;
+      } catch {
+      }
       try {
         if (fs2.existsSync(tmpPath)) fs2.unlinkSync(tmpPath);
       } catch {
@@ -1146,8 +1172,8 @@ async function runDoctor() {
     } catch {
     }
     try {
-      const { execSync: execSync6 } = await import("child_process");
-      const psOutput = execSync6(
+      const { execSync: execSync7 } = await import("child_process");
+      const psOutput = execSync7(
         `ps -eo pid,ppid,command | grep -E "(jest|pnpm test|npm test|yarn test)" | grep -v grep | head -10`,
         { encoding: "utf-8", timeout: 5e3 }
       ).trim();
@@ -1265,7 +1291,7 @@ function rebuildFtsIndex() {
   } catch {
   }
 }
-var DB_FILENAME, dbInstance, initPromise, _saveTimeout, _pendingDb, SAVE_DEBOUNCE_MS;
+var DB_FILENAME, dbInstance, initPromise, lastLoadedMtime, _saveTimeout, _pendingDb, SAVE_DEBOUNCE_MS;
 var init_kumaDb = __esm({
   "src/engine/kumaDb.ts"() {
     "use strict";
@@ -1273,6 +1299,7 @@ var init_kumaDb = __esm({
     DB_FILENAME = "kuma.db";
     dbInstance = null;
     initPromise = null;
+    lastLoadedMtime = 0;
     _saveTimeout = null;
     _pendingDb = null;
     SAVE_DEBOUNCE_MS = 100;
@@ -2556,6 +2583,8 @@ var init_languageSupport = __esm({
 // src/engine/kumaDriftDetector.ts
 var kumaDriftDetector_exports = {};
 __export(kumaDriftDetector_exports, {
+  computeProjectHash: () => computeProjectHash,
+  computeScopeHash: () => computeScopeHash,
   detectDrift: () => detectDrift,
   flagStaleRecords: () => flagStaleRecords,
   formatDriftReport: () => formatDriftReport,
@@ -2565,6 +2594,7 @@ __export(kumaDriftDetector_exports, {
 import fs5 from "fs";
 import path6 from "path";
 import crypto2 from "crypto";
+import { execSync as execSync3 } from "child_process";
 function hashFile(filePath) {
   try {
     const root = getProjectRoot();
@@ -2644,34 +2674,70 @@ async function detectDrift() {
 }
 function computeScopeHash(scope) {
   try {
-    const hash = crypto2.createHash("sha256");
     const root = getProjectRoot();
+    let gitHead = "";
+    let gitStatus = "";
+    try {
+      gitHead = execSync3("git rev-parse HEAD", {
+        cwd: root,
+        encoding: "utf-8",
+        timeout: 1500,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      gitStatus = execSync3("git status --porcelain", {
+        cwd: root,
+        encoding: "utf-8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    } catch {
+    }
+    const hash = crypto2.createHash("sha256");
     hash.update(scope);
     let found = false;
-    try {
-      const files = fs5.readdirSync(root);
-      for (const file of files) {
-        if (file.toLowerCase().includes(scope.toLowerCase())) {
+    if (gitHead || gitStatus) {
+      hash.update(gitHead);
+      hash.update(gitStatus);
+      found = true;
+    } else {
+      const checkDirs = [
+        root,
+        path6.join(root, "src"),
+        path6.join(root, "lib"),
+        path6.join(root, "backend"),
+        path6.join(root, "packages"),
+        path6.join(root, "app")
+      ];
+      for (const dir of checkDirs) {
+        if (fs5.existsSync(dir)) {
           try {
-            if (fs5.statSync(path6.join(root, file)).isFile()) {
-              const content = fs5.readFileSync(path6.join(root, file), "utf-8");
-              hash.update(file);
-              hash.update(content.substring(0, 1e4));
-              found = true;
+            const files = fs5.readdirSync(dir).slice(0, 30);
+            for (const f of files) {
+              try {
+                const fullPath = path6.join(dir, f);
+                const stat = fs5.statSync(fullPath);
+                if (stat.isFile()) {
+                  hash.update(`${f}:${stat.mtimeMs}`);
+                  found = true;
+                }
+              } catch {
+              }
             }
           } catch {
           }
         }
       }
-    } catch {
     }
     const researchDir = path6.join(root, ".kuma", "research");
     if (fs5.existsSync(researchDir)) {
       const scopeFile = path6.join(researchDir, `${scope}.json`);
       if (fs5.existsSync(scopeFile)) {
-        const content = fs5.readFileSync(scopeFile, "utf-8");
-        hash.update(content);
-        found = true;
+        try {
+          const content = fs5.readFileSync(scopeFile, "utf-8");
+          hash.update(content);
+          found = true;
+        } catch {
+        }
       }
     }
     if (!found) return null;
@@ -2744,11 +2810,13 @@ async function getDriftSummary() {
   if (staleCount === 0) return "\u2705 All records fresh";
   return `\u26A0\uFE0F ${staleCount} stale record(s) detected. Use kuma_memory({ action: 'heal' }) to repair.`;
 }
+var computeProjectHash;
 var init_kumaDriftDetector = __esm({
   "src/engine/kumaDriftDetector.ts"() {
     "use strict";
     init_kumaDb();
     init_pathValidator();
+    computeProjectHash = (scope) => computeScopeHash(scope) || Date.now().toString(16);
   }
 });
 
@@ -4342,9 +4410,9 @@ async function analyzeImpact(target) {
 }
 async function codebaseImpactFallback(target) {
   try {
-    const { execSync: execSync6 } = await import("child_process");
+    const { execSync: execSync7 } = await import("child_process");
     const root = process.cwd();
-    const grepResult = execSync6(
+    const grepResult = execSync7(
       `grep -rn ${grepIncludeFlags()} --include="*.json" --include="*.md" -l "${target.replace(/"/g, '\\"')}" . 2>/dev/null | grep -v node_modules | grep -v .git | grep -v dist | grep -v .kuma | head -50`,
       { cwd: root, encoding: "utf-8", timeout: 5e3, maxBuffer: 256 * 1024 }
     ).trim();
@@ -4471,7 +4539,7 @@ var init_kumaGraph = __esm({
 });
 
 // src/utils/kumaShared.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function isEditTool(toolName) {
   const n = (toolName || "").toLowerCase();
   return n.includes("edit") || n.includes("write") || n.includes("patch") || n.includes("apply") || n.includes("replace");
@@ -4509,7 +4577,7 @@ function getSessionStats(inputGoal) {
 function getGitDiffStat(timeout = 3e3) {
   try {
     const root = getProjectRoot();
-    return execSync3("git diff --stat", {
+    return execSync4("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
       timeout
@@ -5656,39 +5724,8 @@ async function syncGotchasGraph() {
     return { created: 0 };
   }
 }
-async function resolveGotchasForScope(scope) {
-  try {
-    await ensureGotchasSchema();
-    const db = await getDb();
-    const stmt = db.prepare(
-      `SELECT id, file_path, content_hash FROM known_gotchas
-       WHERE status = 'active' AND (file_path LIKE ? OR file_path = ?) AND content_hash IS NOT NULL`
-    );
-    stmt.bind([`%${scope}%`, scope]);
-    const rows = [];
-    while (stmt.step()) rows.push(stmt.getAsObject());
-    stmt.free();
-    let resolved = 0;
-    const resolvedPaths = [];
-    for (const r of rows) {
-      const current = hashFileContent(r.file_path);
-      if (current && current !== r.content_hash) {
-        db.run(
-          `UPDATE known_gotchas SET status = 'resolved', last_verified_at = strftime('%s','now') WHERE id = ?`,
-          [r.id]
-        );
-        resolved++;
-        resolvedPaths.push(r.file_path);
-      }
-    }
-    if (resolved > 0) {
-      saveDb();
-      syncGotchaStatusToMarkdown([scope, ...resolvedPaths], "resolved", "auto-verified");
-    }
-    return { resolved };
-  } catch {
-    return { resolved: 0 };
-  }
+async function resolveGotchasForScope(_scope) {
+  return { resolved: 0 };
 }
 async function getActiveGotchasForCommand(command) {
   try {
@@ -7502,10 +7539,29 @@ async function createCheckpoint(label, description) {
       return `\u26A0\uFE0F Checkpoint "${label}" already exists. Use a different label or remove it first.`;
     }
     fs22.mkdirSync(cpDir, { recursive: true });
+    let gitHead;
+    let isGitClean = false;
+    try {
+      const { execSync: execSync7 } = await import("child_process");
+      gitHead = execSync7("git rev-parse HEAD", {
+        cwd: root,
+        encoding: "utf-8",
+        timeout: 3e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const statusOut = execSync7("git status --porcelain", {
+        cwd: root,
+        encoding: "utf-8",
+        timeout: 3e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      isGitClean = statusOut.length === 0;
+    } catch {
+    }
     const candidatePaths = /* @__PURE__ */ new Set();
     try {
-      const { execSync: execSync6 } = await import("child_process");
-      const gitOut = execSync6("git status --porcelain", {
+      const { execSync: execSync7 } = await import("child_process");
+      const gitOut = execSync7("git status --porcelain", {
         cwd: root,
         encoding: "utf-8",
         timeout: 4e3,
@@ -7553,9 +7609,10 @@ async function createCheckpoint(label, description) {
         if (fs22.existsSync(fullPath) && fs22.statSync(fullPath).isFile()) {
           const content = fs22.readFileSync(fullPath, "utf-8");
           const hash = simpleHash2(content);
-          const fileDir = path23.dirname(path23.join(cpDir, "files", fp));
+          const snapFile = path23.join(cpDir, "files", `${fp}.kuma-snap`);
+          const fileDir = path23.dirname(snapFile);
           if (!fs22.existsSync(fileDir)) fs22.mkdirSync(fileDir, { recursive: true });
-          fs22.writeFileSync(path23.join(cpDir, "files", fp), content, "utf-8");
+          fs22.writeFileSync(snapFile, content, "utf-8");
           files.push({ path: fp, hash });
         }
       } catch {
@@ -7567,6 +7624,8 @@ async function createCheckpoint(label, description) {
     const manifest = {
       label,
       timestamp: Date.now(),
+      gitHead,
+      isGitClean,
       files,
       dbSnapshot: true,
       description
@@ -7578,13 +7637,15 @@ async function createCheckpoint(label, description) {
     );
     sessionMemory.recordToolCall("kuma_checkpoint_create", {
       label,
-      filesCount: files.length
+      filesCount: files.length,
+      gitHead
     });
+    const fileNotice = files.length > 0 ? `\u{1F4E6} **${files.length} file(s)** snapshotted` : gitHead ? `\u{1F4E6} **Git commit snapshotted** (\`${gitHead.substring(0, 8)}\` \u2014 clean tree)` : `\u{1F4E6} **0 file(s)** snapshotted`;
     return [
       `\u2705 **Checkpoint Created**: "${label}"`,
       `\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{1F4E6} **${files.length} file(s)** snapshotted`,
+      fileNotice,
       `\u{1F5C4}\uFE0F  **Database** snapshotted`,
       `\u{1F4CD} ${cpDir}`,
       ``,
@@ -7611,10 +7672,12 @@ ${listCheckpoints()}`;
     let restored = 0;
     let failed = 0;
     for (const f of manifest.files) {
-      const snapshotPath = path23.join(cpDir, "files", f.path);
-      if (fs22.existsSync(snapshotPath)) {
+      const snapPath = path23.join(cpDir, "files", `${f.path}.kuma-snap`);
+      const legacyPath = path23.join(cpDir, "files", f.path);
+      const sourcePath = fs22.existsSync(snapPath) ? snapPath : legacyPath;
+      if (fs22.existsSync(sourcePath)) {
         try {
-          const content = fs22.readFileSync(snapshotPath, "utf-8");
+          const content = fs22.readFileSync(sourcePath, "utf-8");
           const targetPath = path23.resolve(root, f.path);
           const targetDir = path23.dirname(targetPath);
           if (!fs22.existsSync(targetDir)) fs22.mkdirSync(targetDir, { recursive: true });
@@ -7625,6 +7688,20 @@ ${listCheckpoints()}`;
         }
       }
     }
+    if (manifest.files.length === 0 && manifest.gitHead) {
+      try {
+        const { execSync: execSync7 } = await import("child_process");
+        execSync7(`git checkout ${manifest.gitHead} -- .`, {
+          cwd: root,
+          encoding: "utf-8",
+          timeout: 8e3,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        restored++;
+      } catch {
+        failed++;
+      }
+    }
     const dbSnapshotPath = path23.join(cpDir, "kuma.db");
     if (fs22.existsSync(dbSnapshotPath)) {
       const kumaDir = path23.join(root, ".kuma");
@@ -7993,10 +8070,12 @@ async function runAutoVerification(options = {}) {
   const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
   const denial = checkAllowed(root);
   if (denial) return denial;
-  const runawayBlock = checkRunaway();
-  if (runawayBlock) {
-    releaseFileLock(root);
-    return runawayBlock;
+  if (!options.force) {
+    const runawayBlock = checkRunaway();
+    if (runawayBlock) {
+      releaseFileLock(root);
+      return runawayBlock;
+    }
   }
   try {
     if (!options.force) {
@@ -8032,8 +8111,8 @@ async function runAutoVerification(options = {}) {
     let modified = sessionMemory.getModifiedFiles().map((f) => f.filePath);
     if (modified.length === 0) {
       try {
-        const { execSync: execSync6 } = await import("child_process");
-        const gitDiff = execSync6("git diff --name-only HEAD", { encoding: "utf-8", timeout: 3e3, cwd: root }).trim();
+        const { execSync: execSync7 } = await import("child_process");
+        const gitDiff = execSync7("git diff --name-only HEAD", { encoding: "utf-8", timeout: 3e3, cwd: root }).trim();
         if (gitDiff) {
           modified = gitDiff.split("\n").map((f) => f.trim()).filter(Boolean);
         }
@@ -8173,14 +8252,6 @@ async function runAutoVerification(options = {}) {
           } catch {
           }
         }
-        if (passed && !isNoTests && scope !== "session-impact") {
-          try {
-            const { resolveGotchasForScope: resolveGotchasForScope2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
-            const { resolved } = await resolveGotchasForScope2(scope);
-            if (resolved > 0) autoGotchaMessage = `\u2705 ${resolved} gotcha(s) resolved automatically (verification passed after file changes).`;
-          } catch {
-          }
-        }
         _localRunning = false;
         _currentProcess = null;
         releaseFileLock(root);
@@ -8245,7 +8316,7 @@ var init_kumaVerifier = __esm({
     STALE_RESULT_MS = 3e5;
     DEFAULT_TIMEOUT_MS = 6e4;
     RUNAWAY_WINDOW_MS = 3e5;
-    RUNAWAY_MAX_CALLS = 3;
+    RUNAWAY_MAX_CALLS = 10;
     _verifyCallTimestamps = [];
   }
 });
@@ -10519,10 +10590,10 @@ init_sessionMemory();
 init_kumaDb();
 init_kumaGraph();
 init_kumaMemory();
+init_kumaDriftDetector();
 init_pathValidator();
 import fs16 from "fs";
 import path17 from "path";
-import crypto3 from "crypto";
 var CONTEXT_ALIASES = {
   "research": "research",
   "search": "research",
@@ -10858,10 +10929,10 @@ async function handleHistory(params) {
       lines.push(traceFormatted);
     } else {
       try {
-        const { execSync: execSync6 } = await import("child_process");
+        const { execSync: execSync7 } = await import("child_process");
         const { getProjectRoot: getProjectRoot2 } = await Promise.resolve().then(() => (init_pathValidator(), pathValidator_exports));
         const root = getProjectRoot2();
-        const gitHistory = execSync6(
+        const gitHistory = execSync7(
           `git log -n 5 --pretty=format:"  \u2022 %h (%ad) %s" --date=short -- "${target}"`,
           { cwd: root, encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }
         ).trim();
@@ -10962,24 +11033,6 @@ async function handleImpact(params) {
   const impact = await analyzeImpact2(target);
   return formatImpact2(impact);
 }
-function computeProjectHash(scope) {
-  try {
-    const root = getProjectRoot();
-    const files = fs16.readdirSync(root).slice(0, 20);
-    const hash = crypto3.createHash("md5");
-    hash.update(scope);
-    for (const f of files) {
-      try {
-        const stat = fs16.statSync(path17.join(root, f));
-        hash.update(`${f}:${stat.mtimeMs}`);
-      } catch {
-      }
-    }
-    return hash.digest("hex").substring(0, 12);
-  } catch {
-    return Date.now().toString(16);
-  }
-}
 
 // src/tools/kumaMemoryTool.ts
 init_sessionMemory();
@@ -11281,7 +11334,7 @@ init_sessionMemory();
 init_kumaShared();
 import fs19 from "fs";
 import path20 from "path";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 var SCRIPT_PATCH_PATTERNS = [
   "writeFileSync",
   "writeFile",
@@ -11375,7 +11428,7 @@ function scanRecentFiles(projectRoot) {
 function detectGitPatchScripts(projectRoot) {
   const warnings = [];
   try {
-    const statusStdout = execSync4("git status --porcelain", {
+    const statusStdout = execSync5("git status --porcelain", {
       cwd: projectRoot,
       encoding: "utf-8",
       timeout: 3e3
@@ -11408,7 +11461,7 @@ function detectGitPatchScripts(projectRoot) {
         }
       }
     }
-    const deletedStdout = execSync4("git diff --name-only --diff-filter=D HEAD", {
+    const deletedStdout = execSync5("git diff --name-only --diff-filter=D HEAD", {
       cwd: projectRoot,
       encoding: "utf-8",
       timeout: 3e3
@@ -11480,7 +11533,7 @@ init_sessionMemory();
 init_pathValidator();
 import fs20 from "fs";
 import path21 from "path";
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 var SNAPSHOT_DIR = "context-snapshots";
 function snapshotDir() {
   return path21.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
@@ -11552,7 +11605,7 @@ function formatSnapshot(snapshot) {
 function getGitDiffStat2() {
   try {
     const root = getProjectRoot();
-    const stdout = execSync5("git diff --stat", {
+    const stdout = execSync6("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
       timeout: 3e3
@@ -12152,25 +12205,25 @@ async function main() {
     } catch {
     }
     try {
-      const { execSync: execSync6 } = await import("child_process");
+      const { execSync: execSync7 } = await import("child_process");
       try {
-        execSync6("pkill -f 'jest' 2>/dev/null || true");
+        execSync7("pkill -f 'jest' 2>/dev/null || true");
       } catch {
       }
       try {
-        execSync6("pkill -f 'jest-worker' 2>/dev/null || true");
+        execSync7("pkill -f 'jest-worker' 2>/dev/null || true");
       } catch {
       }
       try {
-        execSync6("pkill -f 'pnpm test' 2>/dev/null || true");
+        execSync7("pkill -f 'pnpm test' 2>/dev/null || true");
       } catch {
       }
       try {
-        execSync6("pkill -f 'npm test' 2>/dev/null || true");
+        execSync7("pkill -f 'npm test' 2>/dev/null || true");
       } catch {
       }
       try {
-        execSync6("pkill -f 'yarn test' 2>/dev/null || true");
+        execSync7("pkill -f 'yarn test' 2>/dev/null || true");
       } catch {
       }
       console.error("\u2705 Killed orphaned test processes");

package/hooks/kuma-agy-hooks.js

@@ -5,11 +5,18 @@
 import fs from "node:fs";
 import path from "node:path";
 
+const GENERIC_FILENAMES = new Set([
+  "index.ts", "index.js", "index.tsx", "index.jsx",
+  "types.ts", "types.d.ts", "constants.ts", "utils.ts",
+  "config.ts", "schema.ts", "styles.css", "main.ts", "main.js"
+]);
+
 function findGotchasForFile(targetPath) {
   if (!targetPath) return [];
   const results = [];
   const normalized = targetPath.replace(/\\/g, "/");
   const baseName = path.basename(normalized);
+  const isGeneric = GENERIC_FILENAMES.has(baseName.toLowerCase());
 
   const gotchasMd = path.resolve(process.cwd(), ".kuma", "KNOWN_GOTCHAS.md");
   if (fs.existsSync(gotchasMd)) {
@@ -17,11 +24,29 @@ function findGotchasForFile(targetPath) {
       const content = fs.readFileSync(gotchasMd, "utf-8");
       const sections = content.split(/(?=^###\s+)/m);
       for (const sec of sections) {
-        if (sec.includes(baseName) || sec.includes(normalized)) {
-          const firstLine = sec.split("\n")[0].replace(/^###\s+/, "").trim();
+        // Skip resolved or deprecated gotchas
+        if (/[-*]\s*(?:🏷️\s*)?\*\*Status\*\*:\s*(?:resolved|deprecated)/i.test(sec)) {
+          continue;
+        }
+
+        const headingLine = sec.split("\n")[0] || "";
+        const headingMatch = headingLine.match(/^###\s+\[?(.+?)\]?\s*(?:[—–-]+\s*(.+))?$/);
+        if (!headingMatch) continue;
+
+        const secFilePath = headingMatch[1].trim().replace(/\\/g, "/");
+        const secBase = path.basename(secFilePath);
+
+        // Path matching: exact match, suffix match, or non-generic basename match
+        const isMatch =
+          normalized.endsWith(secFilePath) ||
+          secFilePath.endsWith(normalized) ||
+          (!isGeneric && secBase.toLowerCase() === baseName.toLowerCase());
+
+        if (isMatch) {
+          const firstLine = headingLine.replace(/^###\s+/, "").trim();
           const trapMatch = sec.match(/- \S*\s*\*\*Trap\*\*:\s*([^\n]+)/i) || sec.match(/- \*\*Issue\*\*:\s*([^\n]+)/i);
           const ruleMatch = sec.match(/- \S*\s*\*\*Rule(?:\/Fix)?\*\*:\s*([^\n]+)/i) || sec.match(/- \*\*Workaround\*\*:\s*([^\n]+)/i);
-          const trap = trapMatch ? trapMatch[1].trim() : firstLine;
+          const trap = trapMatch ? trapMatch[1].trim() : (headingMatch[2]?.trim() || firstLine);
           const rule = ruleMatch ? ruleMatch[1].trim() : "";
           results.push({ file: baseName, trap, rule });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumpslabs/kuma",
-  "version": "2.4.7",
+  "version": "2.4.8",
   "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",
@@ -82,6 +82,6 @@
     "studio:dev": "bun run packages/ide/studio/src/index.ts",
     "typecheck": "tsc --noEmit",
     "lint": "echo 'No linting configured'",
-    "test": "NODE_OPTIONS=--experimental-vm-modules pnpm exec jest"
+    "test": "NODE_OPTIONS=--experimental-vm-modules pnpm exec jest --runInBand"
   }
 }

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://antigravity.google/schemas/v1/plugin.json",
   "name": "kuma",
-  "version": "2.4.7",
+  "version": "2.4.8",
   "description": "Safety-first context & orchestration engine for AI coding agents. Shadow memory, gotcha lifecycle, blast radius impact analysis, and test verification.",
   "author": {
     "name": "plumpslabs",