@plumpslabs/kuma 2.4.5 → 2.4.6

package/dist/index.js

@@ -5339,15 +5339,17 @@ async function addGotcha(entry) {
     const severity = entry.severity || "medium";
     const status = entry.status || "active";
     const contentHash = hashFileContent(entry.filePath);
+    const trap = entry.description;
+    const ruleFix = entry.workaround || "Review implementation carefully before modifying.";
     const formatted = [
-      `### ${entry.filePath} \u2014 ${entry.description}`,
-      `- **Issue**: ${entry.description}`,
-      `- **Severity**: ${severity}`,
-      entry.workaround ? `- **Workaround**: ${entry.workaround}` : "",
-      entry.triggerCommand ? `- **Trigger**: when running \`${entry.triggerCommand}\`` : "",
-      entry.status ? `- **Status**: ${entry.status}` : "",
-      entry.scopePackage ? `- **Scope Package**: ${entry.scopePackage}` : "",
-      `- **Added**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`
+      `### ${entry.filePath} \u2014 ${trap}`,
+      `- \u{1FAA4} **Trap**: ${trap}`,
+      `- \u{1F6E1}\uFE0F **Rule/Fix**: ${ruleFix}`,
+      `- \u26A1 **Severity**: ${severity}`,
+      entry.triggerCommand ? `- \u2328\uFE0F **Trigger**: when running \`${entry.triggerCommand}\`` : "",
+      entry.status ? `- \u{1F3F7}\uFE0F **Status**: ${status}` : "",
+      entry.scopePackage ? `- \u{1F4E6} **Scope Package**: ${entry.scopePackage}` : "",
+      `- \u{1F4C5} **Added**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`
     ].filter(Boolean).join("\n");
     const checkStmt = db.prepare(
       `SELECT id FROM known_gotchas WHERE file_path = ? AND description LIKE ?`
@@ -10589,6 +10591,8 @@ var MEMORY_ALIASES = {
   "resolve_gotcha": "gotcha",
   "resolve-gotcha": "gotcha",
   "resolve": "gotcha",
+  "gotcha_resolve": "gotcha",
+  "gotcha-resolve": "gotcha",
   "deprecate_gotcha": "gotcha",
   "deprecate-gotcha": "gotcha",
   "deprecate": "gotcha"
@@ -10784,7 +10788,7 @@ async function handleArchFlow(params) {
 async function handleGotchaAction(params) {
   const rawStatus = (params.status || "").toLowerCase().trim();
   const rawAction = (params.action || "").toLowerCase().trim();
-  const isResolution = rawStatus === "resolved" || rawStatus === "resolve" || rawAction === "resolve_gotcha" || rawAction === "resolve";
+  const isResolution = rawStatus === "resolved" || rawStatus === "resolve" || rawAction === "resolve_gotcha" || rawAction === "gotcha_resolve" || rawAction === "gotcha-resolve" || rawAction === "resolve";
   const isDeprecation = rawStatus === "deprecated" || rawStatus === "deprecate" || rawAction === "deprecate_gotcha" || rawAction === "deprecate";
   const target = params.target || params.id || params.scope;
   if (isResolution && target) {
@@ -11449,127 +11453,123 @@ async function doInit() {
 // src/manifest.ts
 var CORE_NOTE = "\n\nCORE ACTIONS (use these): ";
 function registerAllTools(server) {
-  server.tool(
-    "kuma_context",
-    "Context & memory recall. Call FIRST each session. Lean \u2014 each call returns only what you need." + CORE_NOTE + "`init` (start of session: project brief + session state), `research` (before editing unfamiliar code), `history` (why is this file written this way), `flow` (read a recorded architecture flow), `map` (repository topology), `impact` (blast radius analysis).",
-    {
-      action: z.enum(["init", "research", "history", "flow", "map", "impact"]).describe(
-        "init=project brief + session restore, research=research pipeline, history=file rationale + fresh gotchas, flow=read recorded domain flow, map=repo topology, impact=blast radius"
-      ),
-      scope: z.string().optional().describe("Research scope or target for impact"),
-      target: z.string().optional().describe("Target symbol/file for history/flow/impact"),
-      goal: z.string().optional().describe("Current goal (for init)")
-    },
-    async (params) => {
-      try {
-        await ensureInitialized();
-        const text = await handleContext({
-          action: params.action,
-          scope: params.scope,
-          target: params.target,
-          goal: params.goal
-        });
-        return { content: [{ type: "text", text }] };
-      } catch (err) {
-        return { content: [{ type: "text", text: `Error in kuma_context: ${err}` }], isError: true };
-      }
+  const contextDesc = "Context & memory recall. Call FIRST each session. Lean \u2014 each call returns only what you need." + CORE_NOTE + "`init` (start of session: project brief + session state), `research` (before editing unfamiliar code), `history` (why is this file written this way), `flow` (read a recorded architecture flow), `map` (repository topology), `impact` (blast radius analysis).";
+  const contextSchema = {
+    action: z.enum(["init", "research", "history", "flow", "map", "impact"]).describe(
+      "init=project brief + session restore, research=research pipeline, history=file rationale + fresh gotchas, flow=read recorded domain flow, map=repo topology, impact=blast radius"
+    ),
+    scope: z.string().optional().describe("Research scope or target for impact"),
+    target: z.string().optional().describe("Target symbol/file for history/flow/impact"),
+    goal: z.string().optional().describe("Current goal (for init)")
+  };
+  const contextHandler = async (params) => {
+    try {
+      await ensureInitialized();
+      const text = await handleContext({
+        action: params.action,
+        scope: params.scope,
+        target: params.target,
+        goal: params.goal
+      });
+      return { content: [{ type: "text", text }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error in kuma_context: ${err}` }], isError: true };
     }
-  );
-  server.tool(
-    "kuma_memory",
-    "Persistent knowledge. Record what matters, skip what doesn't. This is what saves time in future sessions. Don't record what grep/glob answers faster (functions, imports, types, components)." + CORE_NOTE + "`gotcha` (IMMEDIATELY when you find a bug/quirk), `decision` (when choosing between options), `arch_flow` (after tracing a complete flow, max 5 core files), `research_save` (after exploring an area), `search` (quick lookup of memory + knowledge graph).",
-    {
-      action: z.enum(["gotcha", "decision", "arch_flow", "research_save", "search"]).describe(
-        "gotcha=record bug/quirk, decision=ADR, arch_flow=record architecture flow, research_save=save findings, search=quick memory+graph lookup"
-      ),
-      scope: z.string().optional().describe("File path for gotcha \u2014 or scope for research_save/search"),
-      target: z.string().optional().describe("Target file, gotcha ID, or component"),
-      trigger_command: z.string().optional().describe("Gotcha trigger: shell command that hits this gotcha"),
-      query: z.string().optional().describe("Search query for search action"),
-      content: z.string().optional().describe("Content/notes for research_save / gotcha description / arch_flow record"),
-      record: z.string().optional().describe("JSON record string for research_save"),
-      confidence: z.number().min(0).max(1).optional().describe("Confidence for research_save (0-1)"),
-      title: z.string().optional().describe("Decision title (optional if content/target provided)"),
-      context: z.string().optional().describe("Decision context"),
-      rationale: z.string().optional().describe("Decision rationale (optional if content provided)"),
-      outcome: z.string().optional().describe("Decision outcome (default: implemented)"),
-      status: z.string().optional().describe("Gotcha severity (low|medium|high|critical) or status (resolved|deprecated)"),
-      severity: z.string().optional().describe("Gotcha severity (low|medium|high|critical)"),
-      description: z.string().optional().describe("Gotcha workaround / rationale"),
-      id: z.union([z.number(), z.string()]).optional().describe("Gotcha ID for resolution or deprecation"),
-      limit: z.number().min(1).max(100).optional().describe("Result limit for search")
-    },
-    async (params) => {
-      try {
-        await ensureInitialized();
-        const text = await handleMemory({
-          action: params.action,
-          scope: params.scope,
-          target: params.target,
-          query: params.query,
-          content: params.content,
-          record: params.record,
-          confidence: params.confidence,
-          title: params.title,
-          context: params.context,
-          rationale: params.rationale,
-          outcome: params.outcome,
-          limit: params.limit,
-          status: params.status,
-          severity: params.severity,
-          description: params.description,
-          trigger_command: params.trigger_command,
-          id: params.id
-        });
-        return { content: [{ type: "text", text }] };
-      } catch (err) {
-        return { content: [{ type: "text", text: `Error in kuma_memory: ${err}` }], isError: true };
-      }
+  };
+  server.tool("kuma_context", contextDesc, contextSchema, contextHandler);
+  server.tool("kuma_kuma_context", contextDesc, contextSchema, contextHandler);
+  const memoryDesc = "Persistent knowledge. Record what matters, skip what doesn't. This is what saves time in future sessions. Don't record what grep/glob answers faster (functions, imports, types, components)." + CORE_NOTE + "`gotcha` (IMMEDIATELY when you find a bug/quirk), `decision` (when choosing between options), `arch_flow` (after tracing a complete flow, max 5 core files), `research_save` (after exploring an area), `search` (quick lookup of memory + knowledge graph), `gotcha_resolve` (archive fixed bugs).";
+  const memorySchema = {
+    action: z.enum(["gotcha", "decision", "arch_flow", "research_save", "search", "gotcha_resolve"]).describe(
+      "gotcha=record bug/quirk, decision=ADR, arch_flow=record architecture flow, research_save=save findings, search=quick memory+graph lookup, gotcha_resolve=archive fixed bug"
+    ),
+    scope: z.string().optional().describe("File path for gotcha \u2014 or scope for research_save/search"),
+    target: z.string().optional().describe("Target file, gotcha ID, or component"),
+    trigger_command: z.string().optional().describe("Gotcha trigger: shell command that hits this gotcha"),
+    query: z.string().optional().describe("Search query for search action"),
+    content: z.string().optional().describe("Content/notes for research_save / gotcha description / arch_flow record"),
+    record: z.string().optional().describe("JSON record string for research_save"),
+    confidence: z.number().min(0).max(1).optional().describe("Confidence for research_save (0-1)"),
+    title: z.string().optional().describe("Decision title (optional if content/target provided)"),
+    context: z.string().optional().describe("Decision context"),
+    rationale: z.string().optional().describe("Decision rationale (optional if content provided)"),
+    outcome: z.string().optional().describe("Decision outcome (default: implemented)"),
+    status: z.string().optional().describe("Gotcha severity (low|medium|high|critical) or status (resolved|deprecated)"),
+    severity: z.string().optional().describe("Gotcha severity (low|medium|high|critical)"),
+    description: z.string().optional().describe("Gotcha workaround / rationale"),
+    id: z.union([z.number(), z.string()]).optional().describe("Gotcha ID for resolution or deprecation"),
+    limit: z.number().min(1).max(100).optional().describe("Result limit for search")
+  };
+  const memoryHandler = async (params) => {
+    try {
+      await ensureInitialized();
+      const text = await handleMemory({
+        action: params.action,
+        scope: params.scope,
+        target: params.target,
+        query: params.query,
+        content: params.content,
+        record: params.record,
+        confidence: params.confidence,
+        title: params.title,
+        context: params.context,
+        rationale: params.rationale,
+        outcome: params.outcome,
+        limit: params.limit,
+        status: params.status,
+        severity: params.severity,
+        description: params.description,
+        trigger_command: params.trigger_command,
+        id: params.id
+      });
+      return { content: [{ type: "text", text }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error in kuma_memory: ${err}` }], isError: true };
     }
-  );
-  server.tool(
-    "kuma_safety",
-    "Safety & verification. Use at task boundaries, not on every edit." + CORE_NOTE + "`guard` (before risky work: anti-patterns, drift, loops), `verify` (after edits: scoped tests + validation), `checkpoint` + `rollback_label` (the one rollback mechanism: snapshot before risky work, restore after).",
-    {
-      action: z.enum(["guard", "verify", "checkpoint", "rollback_label"]).describe(
-        "guard=anti-patterns/drift/loops before risky work, verify=scoped tests after edits, checkpoint=labeled snapshot before risky work, rollback_label=restore a labeled snapshot"
-      ),
-      scope: z.string().optional().describe("Scope for verify (e.g. 'auth', file path)"),
-      target: z.string().optional().describe("Target test file or scope for verify"),
-      command: z.string().optional().describe("Custom test command to run during verify"),
-      timeoutMs: z.number().optional().describe("Custom timeout in milliseconds for verify (default: 60000)"),
-      timeout: z.number().optional().describe("Custom timeout in seconds for verify"),
-      force: z.boolean().optional().describe("Force re-run even if cache is fresh or rate limited (verify)"),
-      guardGoal: z.string().optional().describe("Goal for guard check"),
-      guardCheck: z.enum(["all", "anti-pattern", "loop", "drift", "context"]).optional().describe("Guard check type"),
-      label: z.string().optional().describe("Checkpoint label for checkpoint/rollback_label"),
-      description: z.string().optional().describe("Description for checkpoint")
-    },
-    async (params) => {
-      try {
-        await ensureInitialized();
-        const text = await handleSafety({
-          action: params.action,
-          guardGoal: params.guardGoal,
-          guardCheck: params.guardCheck,
-          scope: params.scope,
-          target: params.target,
-          command: params.command,
-          timeoutMs: params.timeoutMs,
-          timeout: params.timeout,
-          force: params.force,
-          label: params.label,
-          description: params.description
-        });
-        return { content: [{ type: "text", text }] };
-      } catch (err) {
-        return { content: [{ type: "text", text: `Error in kuma_safety: ${err}` }], isError: true };
-      }
+  };
+  server.tool("kuma_memory", memoryDesc, memorySchema, memoryHandler);
+  server.tool("kuma_kuma_memory", memoryDesc, memorySchema, memoryHandler);
+  const safetyDesc = "Safety & verification. Use at task boundaries, not on every edit." + CORE_NOTE + "`guard` (before risky work: anti-patterns, drift, loops), `verify` (after edits: scoped tests + validation), `checkpoint` + `rollback_label` (the one rollback mechanism: snapshot before risky work, restore after).";
+  const safetySchema = {
+    action: z.enum(["guard", "verify", "checkpoint", "rollback_label"]).describe(
+      "guard=anti-patterns/drift/loops before risky work, verify=scoped tests after edits, checkpoint=labeled snapshot before risky work, rollback_label=restore a labeled snapshot"
+    ),
+    scope: z.string().optional().describe("Scope for verify (e.g. 'auth', file path)"),
+    target: z.string().optional().describe("Target test file or scope for verify"),
+    command: z.string().optional().describe("Custom test command to run during verify"),
+    timeoutMs: z.number().optional().describe("Custom timeout in milliseconds for verify (default: 60000)"),
+    timeout: z.number().optional().describe("Custom timeout in seconds for verify"),
+    force: z.boolean().optional().describe("Force re-run even if cache is fresh or rate limited (verify)"),
+    guardGoal: z.string().optional().describe("Goal for guard check"),
+    guardCheck: z.enum(["all", "anti-pattern", "loop", "drift", "context"]).optional().describe("Guard check type"),
+    label: z.string().optional().describe("Checkpoint label for checkpoint/rollback_label"),
+    description: z.string().optional().describe("Description for checkpoint")
+  };
+  const safetyHandler = async (params) => {
+    try {
+      await ensureInitialized();
+      const text = await handleSafety({
+        action: params.action,
+        guardGoal: params.guardGoal,
+        guardCheck: params.guardCheck,
+        scope: params.scope,
+        target: params.target,
+        command: params.command,
+        timeoutMs: params.timeoutMs,
+        timeout: params.timeout,
+        force: params.force,
+        label: params.label,
+        description: params.description
+      });
+      return { content: [{ type: "text", text }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error in kuma_safety: ${err}` }], isError: true };
     }
-  );
-  console.error("[Manifest] Registered 3 coarse-grained tools with 13 core actions (init/research/history/flow \xB7 gotcha/decision/arch_flow/research_save/search \xB7 guard/verify/checkpoint/rollback_label).");
+  };
+  server.tool("kuma_safety", safetyDesc, safetySchema, safetyHandler);
+  server.tool("kuma_kuma_safety", safetyDesc, safetySchema, safetyHandler);
+  console.error("[Manifest] Registered 3 core tools with universal dual-prefix aliases (kuma_* and kuma_kuma_*).");
   console.error("[Manifest] Auto-init hooks installed on all tools.");
-  console.error("[Manifest] Namespace aliases active (kuma_kuma_* \u2192 kuma_*, context \u2192 kuma_context).");
 }
 
 // src/index.ts
@@ -11624,6 +11624,64 @@ async function main() {
     printHelp();
     process.exit(0);
   }
+  if (args[0] === "status") {
+    console.log(`\u{1F43B} Kuma v${SERVER_VERSION} \u2014 Health & Memory Status`);
+    console.log(`\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+    try {
+      const { getProjectRoot: getProjectRoot2 } = await Promise.resolve().then(() => (init_pathValidator(), pathValidator_exports));
+      const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
+      const root = getProjectRoot2();
+      console.log(`\u{1F4C1} Project Root: ${root}`);
+      const db = await getDb2();
+      let decisionsCount = 0;
+      try {
+        const dRes = db.exec("SELECT COUNT(*) FROM nodes WHERE type = 'decision'");
+        decisionsCount = dRes[0]?.values[0]?.[0] || 0;
+      } catch {
+      }
+      let activeGotchas = 0;
+      let resolvedGotchas = 0;
+      let candidateGotchas = 0;
+      try {
+        const gRes = db.exec("SELECT status, COUNT(*) FROM known_gotchas GROUP BY status");
+        for (const row of gRes[0]?.values || []) {
+          const status = String(row[0]);
+          const cnt = Number(row[1]);
+          if (status === "active" || status === "verified") activeGotchas += cnt;
+          else if (status === "resolved") resolvedGotchas += cnt;
+          else if (status === "candidate") candidateGotchas += cnt;
+        }
+      } catch {
+      }
+      let shadowInjections = 0;
+      let savedMinutes = 0;
+      try {
+        const { getInjectionStats: getInjectionStats2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
+        const stats = getInjectionStats2(24);
+        shadowInjections = stats.count;
+        savedMinutes = Math.round(stats.savedMs / 6e4);
+      } catch {
+      }
+      let workspaceDesc = "Single project";
+      try {
+        const { getWorkspaceInfo: getWorkspaceInfo2 } = await Promise.resolve().then(() => (init_workspaceIntelligence(), workspaceIntelligence_exports));
+        const wsInfo = await getWorkspaceInfo2(root);
+        if (wsInfo.isWorkspace) {
+          workspaceDesc = `${wsInfo.packages.length} package(s) (${wsInfo.type.toUpperCase()})`;
+        }
+      } catch {
+      }
+      console.log(`\u{1F3DB}\uFE0F Decisions Recorded: ${decisionsCount}`);
+      console.log(`\u26A0\uFE0F Active Gotchas: ${activeGotchas} active \xB7 ${resolvedGotchas} resolved \xB7 ${candidateGotchas} candidate`);
+      console.log(`\u{1FA84} Shadow Memory: ${shadowInjections} prevention(s) in last 24h (~${savedMinutes} min saved)`);
+      console.log(`\u{1F4E6} Workspace: ${workspaceDesc}`);
+      console.log(`\u{1F6E1}\uFE0F Safety Hooks: Active`);
+      console.log(`\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+    } catch (err) {
+      console.error(`\u274C Failed to retrieve status: ${err}`);
+    }
+    process.exit(0);
+  }
   if (args[0] === "stop" && (args[1] === "--force" || args[1] === "-f")) {
     console.error(`\u{1F43B} Kuma v${SERVER_VERSION} \u2014 Kill Switch`);
     console.error("");

package/hooks/kuma-agy-hooks.js

@@ -1,37 +1,90 @@
 /**
- * 🐻 Kuma MCP — Antigravity Lifecycle Hook
- * Intercepts file writes to warn about known gotchas and fragile files.
+ * 🐻 Kuma MCP — JIT Gotcha Guard Hook
+ * Intercepts file writes/edits in real time to inject active gotcha warnings.
  */
 import fs from "node:fs";
 import path from "node:path";
 
-function runHook() {
-  try {
-    const input = process.env.AGY_TOOL_INPUT ? JSON.parse(process.env.AGY_TOOL_INPUT) : {};
-    const targetFile = input.TargetFile || input.file || "";
+function findGotchasForFile(targetPath) {
+  if (!targetPath) return [];
+  const results = [];
+  const normalized = targetPath.replace(/\\/g, "/");
+  const baseName = path.basename(normalized);
 
-    if (!targetFile) {
-      process.stdout.write(JSON.stringify({ decision: "allow" }) + "\n");
-      return;
-    }
-
-    const gotchasFile = path.resolve(process.cwd(), ".kuma", "KNOWN_GOTCHAS.md");
-    if (fs.existsSync(gotchasFile)) {
-      const content = fs.readFileSync(gotchasFile, "utf-8");
-      const baseName = path.basename(targetFile);
-      if (content.includes(baseName) || content.includes(targetFile)) {
-        process.stdout.write(JSON.stringify({
-          decision: "allow",
-          systemMessage: `⚠️ Kuma Gotcha Warning: ${baseName} has recorded gotchas in .kuma/KNOWN_GOTCHAS.md. Review before editing!`
-        }) + "\n");
-        return;
+  const gotchasMd = path.resolve(process.cwd(), ".kuma", "KNOWN_GOTCHAS.md");
+  if (fs.existsSync(gotchasMd)) {
+    try {
+      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();
+          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 rule = ruleMatch ? ruleMatch[1].trim() : "";
+          results.push({ file: baseName, trap, rule });
+        }
       }
+    } catch {}
+  }
+  return results;
+}
+
+function processPayload(rawInput) {
+  let data = {};
+  if (rawInput && typeof rawInput === "string") {
+    try { data = JSON.parse(rawInput); } catch {}
+  } else if (rawInput && typeof rawInput === "object") {
+    data = rawInput;
+  }
+
+  const input = data.input || data;
+  const targetFile = input.TargetFile || input.targetFile || input.file_path || input.path || input.file || "";
+
+  if (!targetFile) {
+    return { decision: "allow" };
+  }
+
+  const gotchas = findGotchasForFile(targetFile);
+  if (gotchas.length > 0) {
+    const baseName = path.basename(targetFile);
+    const lines = [
+      `⚠️ [🐻 Kuma JIT Warning] File "${baseName}" has ${gotchas.length} known gotcha(s):`
+    ];
+    for (const g of gotchas.slice(0, 3)) {
+      lines.push(`  • 🪤 Trap: ${g.trap}`);
+      if (g.rule) lines.push(`    🛡️ Rule: ${g.rule}`);
     }
+    lines.push("💡 Review before modifying to prevent known regressions.");
 
-    process.stdout.write(JSON.stringify({ decision: "allow" }) + "\n");
-  } catch {
-    process.stdout.write(JSON.stringify({ decision: "allow" }) + "\n");
+    const message = lines.join("\n");
+    return {
+      decision: "allow",
+      systemMessage: message,
+      additionalContext: message,
+    };
   }
+
+  return { decision: "allow" };
 }
 
-runHook();
+let inputBuffer = "";
+const timer = setTimeout(() => {
+  const envInput = process.env.AGY_TOOL_INPUT || process.env.TOOL_INPUT || "";
+  const result = processPayload(envInput);
+  process.stdout.write(JSON.stringify(result) + "\n");
+  process.exit(0);
+}, 150);
+
+process.stdin.setEncoding("utf-8");
+process.stdin.on("data", (chunk) => {
+  clearTimeout(timer);
+  inputBuffer += chunk;
+});
+process.stdin.on("end", () => {
+  clearTimeout(timer);
+  const result = processPayload(inputBuffer || process.env.AGY_TOOL_INPUT || "");
+  process.stdout.write(JSON.stringify(result) + "\n");
+  process.exit(0);
+});

package/hooks.json

@@ -3,11 +3,11 @@
     "enabled": true,
     "PreToolUse": [
       {
-        "matcher": "replace_file_content|write_to_file",
+        "matcher": "replace_file_content|write_to_file|Edit|Write|MultiEdit|edit_file",
         "hooks": [
           {
             "type": "command",
-            "command": "node -e \"import('fs').then(fs=>{const p=['hooks/kuma-agy-hooks.js','.agents/hooks/kuma-agy-hooks.js','../hooks/kuma-agy-hooks.js'].find(x=>fs.existsSync(x));if(p)import('./'+p);else process.stdout.write(JSON.stringify({decision:'allow'})+'\\n');}).catch(()=>process.stdout.write(JSON.stringify({decision:'allow'})+'\\n'))\"",
+            "command": "node -e \"import('fs').then(fs=>{const p=['hooks/kuma-agy-hooks.js','.agents/hooks/kuma-agy-hooks.js',process.env.HOME+'/.gemini/config/plugins/kuma/hooks/kuma-agy-hooks.js'].find(x=>fs.existsSync(x));if(p)import(p.startsWith('/')?p:'./'+p);else process.stdout.write(JSON.stringify({decision:'allow'})+'\\n');}).catch(()=>process.stdout.write(JSON.stringify({decision:'allow'})+'\\n'))\"",
             "timeout": 15
           }
         ]

package/package.json

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

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