@plumpslabs/kuma 2.4.12 → 2.4.13

package/dist/index.js

@@ -1735,6 +1735,19 @@ No unresolved issues.`;
         this.autoTrackToDb(toolName, params, timestamp).catch(() => {
         });
       }
+      /**
+       * Issue #32 P1 — obedience enforcement helper (non-blocking).
+       * Returns true when a tool call with the given prefix was recorded
+       * in this session (checks in-memory toolCalls, last 100).
+       */
+      hasToolCall(prefix) {
+        try {
+          this.ensureInit();
+          return this.state.toolCalls.some((t) => t.toolName.startsWith(prefix));
+        } catch {
+          return false;
+        }
+      }
       /**
        * Auto-track tool calls to the database sessions + tool_calls + experiences tables.
        * This is the passive observability pipeline — every tool call gets recorded
@@ -7529,7 +7542,9 @@ async function getFileSummary2(filePath) {
 function parseHookInput(raw) {
   try {
     const data = JSON.parse(raw);
-    const ti = (data && typeof data === "object" ? data.tool_input : {}) || {};
+    const root = data && typeof data === "object" ? data : {};
+    const ti = root.tool_input && typeof root.tool_input === "object" ? root.tool_input : {};
+    const args = root.args && typeof root.args === "object" ? root.args : {};
     const paths = /* @__PURE__ */ new Set();
     const add = (p) => {
       if (typeof p === "string" && p.trim()) paths.add(p.trim());
@@ -7538,10 +7553,22 @@ function parseHookInput(raw) {
     add(ti.new_file_path);
     add(ti.notebook_path);
     if (Array.isArray(ti.file_paths)) ti.file_paths.forEach(add);
-    return {
-      filePaths: [...paths],
-      goal: typeof ti.goal === "string" ? ti.goal : void 0
-    };
+    add(root.file_path);
+    add(root.file);
+    add(root.path);
+    add(root.targetFile);
+    if (Array.isArray(root.file_paths)) root.file_paths.forEach(add);
+    if (Array.isArray(root.files)) root.files.forEach(add);
+    add(args.filePath);
+    add(args.targetFile);
+    add(args.path);
+    add(args.file);
+    const cmd = (typeof ti.command === "string" ? ti.command : void 0) ?? (typeof root.command === "string" ? root.command : void 0) ?? (typeof root.commandline === "string" ? root.commandline : void 0) ?? (typeof args.command === "string" ? args.command : void 0);
+    const goal = (typeof ti.goal === "string" ? ti.goal : void 0) ?? (typeof root.goal === "string" ? root.goal : void 0);
+    const out = { filePaths: [...paths] };
+    if (goal) out.goal = goal;
+    if (cmd) out.command = cmd;
+    return out;
   } catch {
     return { filePaths: [] };
   }
@@ -7845,7 +7872,7 @@ async function listGotchas(params) {
     } else if (!params.status) {
       sql += " AND status IN ('active', 'verified')";
     }
-    sql += " ORDER BY severity DESC, created_at DESC LIMIT 50";
+    sql += " ORDER BY CASE severity WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 ELSE 3 END, updated_at DESC LIMIT 51";
     const stmt = db.prepare(sql);
     stmt.bind(bind);
     const results = [];
@@ -7854,14 +7881,44 @@ async function listGotchas(params) {
     if (results.length === 0) {
       return "\u2705 **No gotchas recorded** \u2014 legacy codebase looks clean.";
     }
+    let total = results.length;
+    try {
+      let countSql = "SELECT COUNT(*) as cnt FROM known_gotchas WHERE 1=1";
+      const countBind = [];
+      if (params.filePath) {
+        countSql += " AND file_path LIKE ?";
+        countBind.push(`%${params.filePath}%`);
+      }
+      if (params.severity) {
+        countSql += " AND severity = ?";
+        countBind.push(params.severity);
+      }
+      if (params.status && params.status !== "all") {
+        countSql += " AND status = ?";
+        countBind.push(params.status);
+      } else if (!params.status) {
+        countSql += " AND status IN ('active', 'verified')";
+      }
+      const cs = db.prepare(countSql);
+      cs.bind(countBind);
+      if (cs.step()) total = cs.getAsObject().cnt || results.length;
+      cs.free();
+    } catch {
+    }
+    const truncated = total > results.length;
+    const shown = truncated ? results.slice(0, 50) : results;
+    const nowSec = Math.floor(Date.now() / 1e3);
     const lines = [
-      `\u26A0\uFE0F **Known Gotchas** \u2014 ${results.length} recorded`,
+      `\u26A0\uFE0F **Known Gotchas** \u2014 showing ${shown.length} of ${total}${truncated ? " (truncated: true \u2014 narrow with filePath/severity)" : ""}`,
       "\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",
       ""
     ];
-    for (const g of results) {
+    for (const g of shown) {
       const icon = g.severity === "critical" ? "\u{1F534}" : g.severity === "high" ? "\u{1F7E0}" : g.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
-      lines.push(`${icon} [${g.severity}] ${g.file_path}`);
+      const ageSec = nowSec - (Number(g.created_at) || nowSec);
+      const isNew = ageSec < 24 * 3600 ? " \u{1F195}" : "";
+      const updated = g.updated_at ? ` \xB7 lastSeen ${new Date(Number(g.updated_at) * 1e3).toISOString().split("T")[0]}` : "";
+      lines.push(`${icon} [${g.severity}]${isNew} ${g.file_path}${updated}`);
       lines.push(`   \u{1F4DD} ${g.description?.toString().substring(0, 100)}`);
       if (g.trigger_command) lines.push(`   \u2328\uFE0F when running: \`${g.trigger_command.substring(0, 80)}\``);
       if (g.workaround) lines.push(`   \u{1F4A1} ${g.workaround.substring(0, 100)}`);
@@ -9188,7 +9245,9 @@ var init_architectureGuard = __esm({
 var kumaCheckpoint_exports = {};
 __export(kumaCheckpoint_exports, {
   createCheckpoint: () => createCheckpoint,
+  isRiskyEditPath: () => isRiskyEditPath,
   listCheckpoints: () => listCheckpoints,
+  maybeAutoCheckpoint: () => maybeAutoCheckpoint,
   pruneCheckpoints: () => pruneCheckpoints,
   rollbackToCheckpoint: () => rollbackToCheckpoint
 });
@@ -9463,7 +9522,61 @@ function simpleHash2(str) {
   }
   return Math.abs(hash).toString(36);
 }
-var CHECKPOINT_DIR;
+function isRiskyEditPath(filePath) {
+  return RISKY_EDIT_PATTERN.test(filePath);
+}
+function loadAutoCpDone(root) {
+  try {
+    const fp = path27.join(root, AUTO_CP_STATE);
+    if (fs24.existsSync(fp)) {
+      const parsed = JSON.parse(fs24.readFileSync(fp, "utf-8"));
+      return parsed?.autoCheckpoints ?? {};
+    }
+  } catch {
+  }
+  return {};
+}
+function saveAutoCpDone(root, done) {
+  try {
+    const fp = path27.join(root, AUTO_CP_STATE);
+    const parsed = fs24.existsSync(fp) ? JSON.parse(fs24.readFileSync(fp, "utf-8")) : {};
+    parsed.autoCheckpoints = done;
+    fs24.writeFileSync(fp, JSON.stringify(parsed), "utf-8");
+  } catch {
+  }
+}
+function maybeAutoCheckpoint(filePath) {
+  try {
+    if (!isRiskyEditPath(filePath)) return null;
+    const root = getProjectRoot();
+    const done = loadAutoCpDone(root);
+    if (done[filePath]) return null;
+    const abs = path27.isAbsolute(filePath) ? filePath : path27.join(root, filePath);
+    if (!fs24.existsSync(abs) || !fs24.statSync(abs).isFile()) return null;
+    const label = `auto-pre-${sanitizeLabel(path27.basename(filePath))}`;
+    const cpDir = path27.join(root, CHECKPOINT_DIR, label);
+    if (!fs24.existsSync(cpDir)) fs24.mkdirSync(cpDir, { recursive: true });
+    fs24.copyFileSync(abs, path27.join(cpDir, path27.basename(abs)));
+    fs24.writeFileSync(
+      path27.join(cpDir, "manifest.json"),
+      JSON.stringify({
+        label,
+        timestamp: Date.now(),
+        files: [{ path: filePath, hash: "" }],
+        dbSnapshot: false,
+        description: `Auto-checkpoint before risky edit of ${filePath} (issue #32)`,
+        auto: true
+      }),
+      "utf-8"
+    );
+    done[filePath] = true;
+    saveAutoCpDone(root, done);
+    return label;
+  } catch {
+    return null;
+  }
+}
+var CHECKPOINT_DIR, RISKY_EDIT_PATTERN, AUTO_CP_STATE;
 var init_kumaCheckpoint = __esm({
   "src/engine/kumaCheckpoint.ts"() {
     "use strict";
@@ -9471,6 +9584,8 @@ var init_kumaCheckpoint = __esm({
     init_pathValidator();
     init_sessionMemory();
     CHECKPOINT_DIR = ".kuma/checkpoints";
+    RISKY_EDIT_PATTERN = /(migrations?|drizzle|schema|prisma|\.sql$|\.db$)/i;
+    AUTO_CP_STATE = ".kuma/hook-state.json";
   }
 });
 
@@ -9765,9 +9880,12 @@ function geminiTemplate() {
 function opencodePluginTemplate() {
   return [
     "/**",
-    " * \u{1F43B} Kuma MCP \u2014 OpenCode Plugin",
-    " * Auto-injects gotcha warnings and safety guidance before file edits and commands in OpenCode.",
+    " * \u{1F43B} Kuma MCP \u2014 OpenCode Plugin (risk-sensitive, token-efficient)",
     " * OpenCode loads all plugins from .opencode/plugins/*.js automatically.",
+    " *",
+    " * - tool.execute.before: throws ONLY on critical/high gotchas for the",
+    " *   file being edited (thrown message IS shown to the agent).",
+    " *   Medium/low gotchas stay silent (0 tokens) \u2014 use MCP tools for those.",
     " */",
     'import fs from "node:fs";',
     'import path from "node:path";',
@@ -9783,24 +9901,26 @@ function opencodePluginTemplate() {
     "  return process.cwd();",
     "}",
     "",
-    "function getActiveGotchasForFile(filePath) {",
+    "function getBlockingGotchasForFile(filePath) {",
     "  try {",
     "    const root = getProjectRoot();",
     '    const gotchasPath = path.join(root, ".kuma", "KNOWN_GOTCHAS.md");',
     "    if (!fs.existsSync(gotchasPath)) return [];",
     '    const content = fs.readFileSync(gotchasPath, "utf-8");',
-    "    const gotchas = [];",
-    '    const normalizedTarget = filePath.replace(/^[./]+/, "");',
+    "    const blocking = [];",
+    '    const normalizedTarget = String(filePath).replace(/^[./]+/, "");',
     "    const sections = content.split(/###\\s+/);",
     "    for (const section of sections) {",
     "      if (!section.trim()) continue;",
     '      const lines = section.split("\\n");',
     '      const title = lines[0] || "";',
-    "      if (title.includes(normalizedTarget) || section.includes(normalizedTarget)) {",
-    "        gotchas.push(title.trim());",
-    "      }",
+    "      if (!title.includes(normalizedTarget) && !section.includes(normalizedTarget)) continue;",
+    "      const sevMatch = section.match(/\\*\\*Severity\\*\\*:\\s*(critical|high|medium|low)/i);",
+    '      const severity = (sevMatch ? sevMatch[1] : "medium").toLowerCase();',
+    '      if (severity !== "critical" && severity !== "high") continue;',
+    "      blocking.push(`[${severity}] ${title.trim()}`);",
     "    }",
-    "    return gotchas;",
+    "    return blocking.slice(0, 3);",
     "  } catch {",
     "    return [];",
     "  }",
@@ -9809,20 +9929,25 @@ function opencodePluginTemplate() {
     "export const KumaPlugin = async () => {",
     "  return {",
     '    "tool.execute.before": async (input, output) => {',
-    '      const tool = (input.tool || "").toLowerCase();',
+    '      const tool = String(input.tool || "").toLowerCase();',
     "      const args = output.args || {};",
     '      const targetPath = args.filePath || args.targetFile || args.path || args.file || "";',
-    '      if (targetPath && (tool.includes("edit") || tool.includes("write") || tool.includes("patch"))) {',
-    "        const gotchas = getActiveGotchasForFile(String(targetPath));",
-    "        if (gotchas.length > 0) {",
-    "          console.warn(",
-    "            `\\n\u{1F43B} [Kuma Alert] Active gotchas found for ${targetPath}:\\n` +",
-    '            gotchas.map((g) => `  \u26A0\uFE0F ${g}`).join("\\n") +',
-    '            `\\n\u{1F449} Remember to record any new gotchas via kuma_memory({ action: "gotcha" })\\n`',
-    "          );",
-    "        }",
+    "      if (!targetPath) return;",
+    '      if (!(tool.includes("edit") || tool.includes("write") || tool.includes("patch"))) return;',
+    "      const blocking = getBlockingGotchasForFile(String(targetPath));",
+    "      if (blocking.length > 0) {",
+    "        throw new Error(",
+    "          `\u{1F43B} [Kuma] ${blocking.length} critical/high gotcha(s) for ${targetPath}:\\n` +",
+    '          blocking.map((g) => `  \u{1F534} ${g}`).join("\\n") +',
+    '          `\\nRead .kuma/KNOWN_GOTCHAS.md for workarounds, or run kuma_memory({ action: "gotcha" }) to list.`',
+    "        );",
     "      }",
     "    },",
+    '    "file.edited": async (input) => {',
+    "      // Post-edit verify nudge (log channel only \u2014 never blocks).",
+    '      const fp = input.filePath || input.path || (input.file && input.file.path) || "";',
+    '      if (fp) console.warn(`\u{1F43B} [Kuma] ${fp} edited \u2014 consider kuma_safety({ action: "verify", scope: "${fp}" })`);',
+    "    },",
     "  };",
     "};",
     ""
@@ -10773,6 +10898,107 @@ function handleClaudeSecondary(root, results) {
     }
   }
 }
+function writeHooksFile(root, relPath, type, results, build) {
+  const fullPath = path28.resolve(root, relPath);
+  try {
+    let existing = {};
+    let existed = false;
+    if (fs25.existsSync(fullPath)) {
+      existed = true;
+      try {
+        existing = JSON.parse(fs25.readFileSync(fullPath, "utf-8"));
+      } catch {
+        existing = {};
+      }
+    } else {
+      const dir = path28.dirname(fullPath);
+      if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+    }
+    const { doc, changed } = build(existing);
+    if (!changed) {
+      results.push({ type, filePath: relPath, action: "skipped" });
+      return;
+    }
+    fs25.writeFileSync(fullPath, JSON.stringify(doc, null, 2) + "\n", "utf-8");
+    results.push({ type, filePath: relPath, action: existed ? "appended" : "created" });
+  } catch (err) {
+    results.push({ type, filePath: relPath, action: "error", error: err instanceof Error ? err.message : String(err) });
+  }
+}
+function dedupeCommands(list, entry) {
+  const cmd = String(entry.command || "");
+  if (list.some((e) => String(e.command || "") === cmd)) return false;
+  list.push(entry);
+  return true;
+}
+function handleCursorHooks(root, results) {
+  writeHooksFile(root, ".cursor/hooks.json", "cursor", results, (existing) => {
+    const doc = { version: 1, ...existing };
+    const hooks = doc.hooks && typeof doc.hooks === "object" ? doc.hooks : {};
+    let changed = false;
+    const after = Array.isArray(hooks.afterFileEdit) ? [...hooks.afterFileEdit] : [];
+    changed = dedupeCommands(after, { command: "kuma hook pre-edit" }) || changed;
+    const before = Array.isArray(hooks.beforeShellExecution) ? [...hooks.beforeShellExecution] : [];
+    changed = dedupeCommands(before, { command: "kuma hook pre-bash" }) || changed;
+    hooks.afterFileEdit = after;
+    hooks.beforeShellExecution = before;
+    doc.version = 1;
+    doc.hooks = hooks;
+    return { doc, changed };
+  });
+}
+function handleWindsurfHooks(root, results) {
+  writeHooksFile(root, ".windsurf/hooks.json", "windsurf", results, (existing) => {
+    const doc = { ...existing };
+    const hooks = doc.hooks && typeof doc.hooks === "object" ? doc.hooks : {};
+    let changed = false;
+    const preWrite = Array.isArray(hooks.pre_write_code) ? [...hooks.pre_write_code] : [];
+    changed = dedupeCommands(preWrite, { command: "kuma hook pre-edit", show_output: false }) || changed;
+    const preRun = Array.isArray(hooks.pre_run_command) ? [...hooks.pre_run_command] : [];
+    changed = dedupeCommands(preRun, { command: "kuma hook pre-bash", show_output: false }) || changed;
+    hooks.pre_write_code = preWrite;
+    hooks.pre_run_command = preRun;
+    doc.hooks = hooks;
+    return { doc, changed };
+  });
+}
+function handleCopilotHooks(root, results) {
+  writeHooksFile(root, ".vscode/settings.json", "copilot", results, (existing) => {
+    const doc = { ...existing };
+    const hooks = doc.hooks && typeof doc.hooks === "object" ? doc.hooks : {};
+    let changed = false;
+    const pre = Array.isArray(hooks.PreToolUse) ? [...hooks.PreToolUse] : [];
+    const hasEdit = pre.some((e) => String(e.command || "") === "kuma hook pre-edit");
+    if (!hasEdit) {
+      pre.push({ matcher: "Edit|Write|MultiEdit", type: "command", command: "kuma hook pre-edit", timeout: 15 });
+      changed = true;
+    }
+    const hasBash = pre.some((e) => String(e.command || "") === "kuma hook pre-bash");
+    if (!hasBash) {
+      pre.push({ matcher: "Bash", type: "command", command: "kuma hook pre-bash", timeout: 15 });
+      changed = true;
+    }
+    hooks.PreToolUse = pre;
+    doc.hooks = hooks;
+    return { doc, changed };
+  });
+}
+function handleCodexHooks(root, results) {
+  writeHooksFile(root, ".codex/hooks.json", "codex", results, (existing) => {
+    const doc = { ...existing };
+    const hooks = doc.hooks && typeof doc.hooks === "object" ? doc.hooks : {};
+    let changed = false;
+    const pre = Array.isArray(hooks.PreToolUse) ? [...hooks.PreToolUse] : [];
+    const hasEdit = pre.some((e) => String(e.command || "") === "kuma hook pre-edit");
+    if (!hasEdit) {
+      pre.push({ matcher: "Edit|Write", type: "command", command: "kuma hook pre-edit" });
+      changed = true;
+    }
+    hooks.PreToolUse = pre;
+    doc.hooks = hooks;
+    return { doc, changed };
+  });
+}
 function handleCursorGotchaRules(root, results) {
   const rulesDir2 = path28.resolve(root, ".cursor", "rules", "kuma-gotchas");
   try {
@@ -10936,6 +11162,16 @@ function runInit(options) {
   }
   if (selectedSet.has("cursor")) {
     handleCursorGotchaRules(root, results);
+    handleCursorHooks(root, results);
+  }
+  if (selectedSet.has("windsurf")) {
+    handleWindsurfHooks(root, results);
+  }
+  if (selectedSet.has("copilot")) {
+    handleCopilotHooks(root, results);
+  }
+  if (selectedSet.has("codex")) {
+    handleCodexHooks(root, results);
   }
   return results;
 }
@@ -11803,25 +12039,31 @@ async function handleContext(params) {
   const rawAction = params.action || "init";
   const resolvedAction = CONTEXT_ALIASES[rawAction.toLowerCase()] || rawAction;
   const action = resolvedAction;
+  let obediencePrefix = "";
+  if (action !== "init" && !sessionMemory.hasToolCall("kuma_context_init")) {
+    obediencePrefix = `\u26A0\uFE0F **Obedience nudge**: \`kuma_context({ action: "init" })\` was not called yet this session. Run it first so project brief + fresh gotchas are loaded. Continuing anyway\u2026
+
+`;
+  }
   switch (action) {
     case "init":
       return handleInit(params);
     case "research":
-      return handleResearch(params);
+      return obediencePrefix + await handleResearch(params);
     case "history":
-      return handleHistory(params);
+      return obediencePrefix + await handleHistory(params);
     case "flow":
-      return handleFlow(params);
+      return obediencePrefix + await handleFlow(params);
     case "map":
-      return handleMap(params);
+      return obediencePrefix + await handleMap(params);
     case "impact":
-      return handleImpact(params);
+      return obediencePrefix + await handleImpact(params);
     case "cluster":
-      return handleCluster(params);
+      return obediencePrefix + await handleCluster(params);
     case "skeleton":
-      return handleSkeleton(params);
+      return obediencePrefix + await handleSkeleton(params);
     case "reuse":
-      return handleReuse(params);
+      return obediencePrefix + await handleReuse(params);
     default:
       return `Unknown action "${action}". Use: init, research, history, flow, map, impact, cluster, skeleton, reuse`;
   }
@@ -13004,24 +13246,41 @@ async function handleKumaGuard(params) {
 async function handleSafety(params) {
   const { action } = params;
   sessionMemory.recordToolCall("kuma_safety", { action });
+  let prefix = "";
+  if (!sessionMemory.hasToolCall("kuma_context_init")) {
+    prefix = `\u26A0\uFE0F **Obedience nudge**: \`kuma_context({ action: "init" })\` was not called yet this session. Run it first so project brief + fresh gotchas are loaded. Continuing anyway\u2026
+
+`;
+  }
   switch (action) {
     case "guard":
-      return handleGuard(params);
+      return prefix + await handleGuard(params);
     case "verify":
-      return handleVerify(params);
+      return prefix + await handleVerify(params);
     case "checkpoint":
-      return handleCheckpoint(params);
+      return prefix + await handleCheckpoint(params);
     case "rollback_label":
-      return handleRollbackLabel(params);
+      return prefix + await handleRollbackLabel(params);
     default:
       return `Unknown action "${action}". Use: guard, verify, checkpoint, rollback_label`;
   }
 }
 async function handleGuard(params) {
-  return await handleKumaGuard({
+  const base = await handleKumaGuard({
     goal: params.guardGoal,
     check: params.guardCheck || "all"
   });
+  try {
+    const summary = sessionMemory.getSummary();
+    const modified = summary.modifiedFiles?.length || 0;
+    if (modified > 0 && !sessionMemory.hasToolCall("kuma_safety_verify")) {
+      return base + `
+
+\u26A0\uFE0F **Post-edit nudge**: ${modified} file(s) modified but \`kuma_safety({ action: "verify" })\` not called yet. Run verify to close the edit\u2192verify loop.`;
+    }
+  } catch {
+  }
+  return base;
 }
 async function handleCheckpoint(params) {
   sessionMemory.recordToolCall("kuma_safety_checkpoint", { label: params.label });
@@ -13042,6 +13301,17 @@ async function handleVerify(params) {
     const { analyzeImpact: analyzeImpact2, formatImpact: formatImpact2 } = await Promise.resolve().then(() => (init_kumaGraph(), kumaGraph_exports));
     const impact = await analyzeImpact2(target);
     const formattedImpact = formatImpact2(impact);
+    let gotchaScan = "";
+    try {
+      const { getFreshGotchasForFile: getFreshGotchasForFile2 } = await Promise.resolve().then(() => (init_kumaInject(), kumaInject_exports));
+      const gotchas = await getFreshGotchasForFile2(target, 5, true);
+      if (gotchas.length > 0) {
+        gotchaScan = "\n\n\u26A0\uFE0F **Gotcha-scan** \u2014 this scope touches file(s) with known gotchas:\n" + gotchas.map((g) => `  ${g.stale ? "\u26AA(stale)" : "\u{1F7E1}"} [${g.severity}] ${g.filePath} \u2014 ${g.description.substring(0, 120)}`).join("\n") + "\n  \u2192 Confirm the fix does not reintroduce them.";
+      } else {
+        gotchaScan = "\n\n\u2705 **Gotcha-scan**: no known gotchas for this scope.";
+      }
+    } catch {
+    }
     let recommendedCmd = "";
     try {
       const { getWorkspaceInfo: getWorkspaceInfo2, findPackageForFile: findPackageForFile2 } = await Promise.resolve().then(() => (init_workspaceIntelligence(), workspaceIntelligence_exports));
@@ -13077,7 +13347,8 @@ async function handleVerify(params) {
       formattedImpact,
       "",
       `\u{1F4CB} **Recommended Scoped Test Command:**`,
-      `   \`${recommendedCmd}\``
+      `   \`${recommendedCmd}\``,
+      gotchaScan
     ].join("\n");
   }
   return [
@@ -13505,6 +13776,15 @@ async function main() {
       }
       const target = hook.filePaths[0];
       await trackFileEditLoop2(target);
+      try {
+        const { maybeAutoCheckpoint: maybeAutoCheckpoint2 } = await Promise.resolve().then(() => (init_kumaCheckpoint(), kumaCheckpoint_exports));
+        const autoCp = maybeAutoCheckpoint2(target);
+        if (autoCp) {
+          const { recordInjection: recordInjection2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
+          await recordInjection2({ filePath: target, kind: "edit" });
+        }
+      } catch {
+      }
       if (!checkInjectDedupe2(target)) {
         process.stdout.write("{}");
         process.exit(0);
@@ -13526,9 +13806,12 @@ async function main() {
   if (args[0] === "hook" && args[1] === "pre-bash") {
     try {
       const stdin = await readStdin();
-      const { getCommandContext: getCommandContext2, buildHookResponse: buildHookResponse2 } = await Promise.resolve().then(() => (init_kumaInject(), kumaInject_exports));
-      const data = JSON.parse(stdin || "{}");
-      const command = data && typeof data === "object" && data.tool_input && typeof data.tool_input.command === "string" ? data.tool_input.command : "";
+      const { getCommandContext: getCommandContext2, buildHookResponse: buildHookResponse2, parseHookInput: parseHookInput2 } = await Promise.resolve().then(() => (init_kumaInject(), kumaInject_exports));
+      let command = "";
+      try {
+        command = parseHookInput2(stdin).command || "";
+      } catch {
+      }
       if (!command.trim()) {
         process.stdout.write("{}");
         process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumpslabs/kuma",
-  "version": "2.4.12",
+  "version": "2.4.13",
   "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/plugin.json

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