@plumpslabs/kuma 2.3.15 → 2.3.17

package/dist/{chunk-3AN4RSN5.js → chunk-AJ7HHUDW.js}

@@ -76,13 +76,16 @@ var BOOTSTRAP_LINES = [
   '  2. `kuma_safety({ action: "guard" })`                     \u2014 Safety check before work',
   '  3. `kuma_context({ action: "research", scope: "<area>" })` \u2014 Research before editing',
   "  4. *(edit/read using native tools)*",
-  '  5. `kuma_memory({ action: "research_save", ... })`        \u2014 Save all findings',
-  '  6. `kuma_memory({ action: "gotcha" })`                    \u2014 Record bugs/quirks found',
-  '  7. `kuma_memory({ action: "arch_flow" })`                 \u2014 Record data flow if mapped',
-  '  8. `kuma_memory({ action: "decision" })`                  \u2014 Record key findings/decisions',
+  '  5. `kuma_memory({ action: "research_save", ... })`        \u2014 IMMEDIATELY after every read/grep (inline)',
+  '  6. `kuma_memory({ action: "gotcha" })`                    \u2014 IMMEDIATELY when bug/quirks found (inline)',
+  '  7. `kuma_memory({ action: "arch_flow" })`                 \u2014 IMMEDIATELY after tracing each flow hop (inline)',
+  '  8. `kuma_memory({ action: "decision" })`                  \u2014 IMMEDIATELY when choosing between options (inline)',
   '  9. `kuma_safety({ action: "verify", ... })`               \u2014 Run tests / confirm nothing broken',
   ' 10. `kuma_context({ action: "changes" })`                  \u2014 Review session activity',
   "",
+  "\u{1F504} Record findings INLINE as you work \u2014 not just at steps 5-8. Every read/grep = mini research_save.",
+  "\u{1F9E0} Knowledge graph is persistent \u2014 nodes/edges accumulate across sessions, getting richer over time.",
+  "",
   "\u26D4 Do NOT skip steps 5-10 after research \u2014 even if no code was changed.",
   "\u{1F4D6} Full rules: `.kuma/init.md`",
   "\u{1F9E0} Tools: `kuma_context` | `kuma_memory` | `kuma_safety`"
@@ -305,38 +308,49 @@ function generateInitMdContent() {
     "",
     "> \u26A0\uFE0F **Research-only sessions included.** Workflow ini wajib meskipun session hanya membaca/riset tanpa code changes.",
     "",
+    "> \u{1F9E0} **Graph Philosophy:** Record findings INLINE as you work, not just at the end. Every time you read a",
+    "> file, grep a pattern, or trace a flow \u2014 call `research_save` immediately to persist file/func/import nodes.",
+    "> The knowledge graph accumulates across sessions. The more you use it, the richer it becomes.",
+    "",
     "**AUTO-RECORDED nodes/edges** (Kuma scanner detects these automatically):",
     "- Files, Functions, Classes \u2192 created as graph nodes",
     "- Imports, Calls, Extends \u2192 created as graph edges",
     "- Variables, Components, Routes \u2192 created when detected",
     "",
-    "### STEP 5: Save Research (MANDATORY \u2014 After Research/Editing)",
+    "**RECORD INLINE \u2014 Don't wait for steps 5-8:**",
+    "- After EVERY `read` that finds new files \u2192 call `research_save` mini (persist file nodes)",
+    "- After EVERY `grep` that discovers new functions \u2192 call `research_save` (persist function nodes)",
+    "- When you discover a bug/quirk \u2192 call `gotcha` IMMEDIATELY (not at step 6)",
+    "- When you trace a data flow hop \u2192 call `arch_flow` IMMEDIATELY (not at step 7)",
+    "- When you choose between options \u2192 call `decision` IMMEDIATELY (not at step 8)",
+    "",
+    "### STEP 5: Save Research (RECORD INLINE \u2014 After Every Read/Grep)",
     "```",
-    'kuma_memory({ action: "research_save", scope: "<area>", confidence: 0.8 })',
+    'kuma_memory({ action: "research_save", scope: "<file or area>", confidence: 0.8 })',
     "```",
-    "**When:** IMMEDIATELY after exploring code or finishing edits. Jangan tunda.",
-    "**Why:** Persist findings into knowledge graph + research cache",
+    "**When:** After EVERY read/grep that discovers new files, functions, imports, or patterns. Don't wait \u2014 record inline!",
+    "**Why:** Persist findings into knowledge graph + research cache. Graph grows richer across sessions.",
     "",
-    "### STEP 6: Record Gotchas (MANDATORY \u2014 After Research)",
+    "### STEP 6: Record Gotchas (RECORD INLINE \u2014 When Bug Found)",
     "```",
     'kuma_memory({ action: "gotcha", filePath: "<file>", description: "...", severity: "medium" })',
     "```",
-    "**When:** IMMEDIATELY after discovering bugs, quirks, unexpected behavior, or workarounds.",
-    "**Why:** Prevents future agents from hitting the same issues. Every bug = a gotcha.",
+    "**When:** IMMEDIATELY when you discover bugs, quirks, unexpected behavior, or workarounds. Record INLINE, don't save for later.",
+    "**Why:** Prevents future agents from hitting the same issues. Every bug = a gotcha. Skip now = lost forever.",
     "",
-    "### STEP 7: Record Arch Flow (MANDATORY \u2014 After Tracing Data/Code Flow)",
+    "### STEP 7: Record Arch Flow (RECORD INLINE \u2014 When Tracing Flow)",
     "```",
     'kuma_memory({ action: "arch_flow", content: "..." })',
     "```",
-    "**When:** IMMEDIATELY after mapping out how data flows between components.",
-    "**Why:** Architecture knowledge dissipates fast. Record it before moving to next task.",
+    "**When:** IMMEDIATELY after tracing EACH hop in a data/control flow. Record INLINE, then continue tracing the next hop.",
+    "**Why:** Architecture knowledge dissipates fast. Record each hop before moving to the next file/task.",
     "",
-    "### STEP 8: Record Decision (MANDATORY \u2014 After Research/Findings)",
+    "### STEP 8: Record Decision (RECORD INLINE \u2014 When Choosing)",
     "```",
     'kuma_memory({ action: "decision", decisionAction: "record", title: "...", outcome: "..." })',
     "```",
-    "**When:** Setelah setiap session riset. Bukan cuma code changes \u2014 temuan, bug analysis, design tradeoffs juga.",
-    "**Why:** Saves ADR (Architecture Decision Record) \u2014 future agents need context from your discoveries.",
+    "**When:** IMMEDIATELY when you choose between 2+ options, uncover an architecture pattern, or identify a root cause.",
+    "**Why:** Saves ADR (Architecture Decision Record). Bukan cuma code changes \u2014 temuan, tradeoffs, root causes juga.",
     "",
     "### STEP 9: Verify (MANDATORY \u2014 After Research/Editing)",
     "```",
@@ -373,10 +387,10 @@ function generateInitMdContent() {
     "",
     "| Action | Description | When to Call |",
     "|--------|-------------|--------------|",
-    "| `research_save` | Save research results | STEP 5 \u2014 IMMEDIATELY after exploring |",
-    "| `gotcha` | Record bugs/quirks/workarounds | STEP 6 \u2014 IMMEDIATELY after finding bug |",
-    "| `arch_flow` | Document architecture flow | STEP 7 \u2014 IMMEDIATELY after tracing flow |",
-    "| `decision` | ADR-style decision record | STEP 8 \u2014 After every research session |",
+    "| `research_save` | Save research results | STEP 5 \u2014 IMMEDIATELY after every read/grep (inline) |",
+    "| `gotcha` | Record bugs/quirks/workarounds | STEP 6 \u2014 IMMEDIATELY when bug found (inline) |",
+    "| `arch_flow` | Document architecture flow | STEP 7 \u2014 IMMEDIATELY after each flow hop (inline) |",
+    "| `decision` | ADR-style decision record | STEP 8 \u2014 IMMEDIATELY when choosing (inline) |",
     "| `mine` | Mine decisions from git log | When need historical context |",
     "| `session` | Session summary | End of session |",
     "| `heal` | Self-heal knowledge graph | When graph has errors |",
@@ -443,13 +457,16 @@ function generateInitMdContent() {
     "  2. kuma_safety    \u2192 guard               \u2014 Safety check",
     "  3. kuma_context   \u2192 research            \u2014 Research target area",
     "  --- EDIT/READ (use native tools) ---",
-    "  5. kuma_memory    \u2192 research_save       \u2014 Save ALL findings",
-    "  6. kuma_memory    \u2192 gotcha              \u2014 Record bugs/quirks found",
-    "  7. kuma_memory    \u2192 arch_flow           \u2014 Record data flow if mapped",
-    "  8. kuma_memory    \u2192 decision            \u2014 Record key findings/decisions",
+    "  5. kuma_memory    \u2192 research_save       \u2014 Save findings (inline after every read/grep)",
+    "  6. kuma_memory    \u2192 gotcha              \u2014 Record bugs/quirks (inline when found)",
+    "  7. kuma_memory    \u2192 arch_flow           \u2014 Record data flow (inline after each hop)",
+    "  8. kuma_memory    \u2192 decision            \u2014 Record key decisions (inline when choosing)",
     "  9. kuma_safety    \u2192 verify              \u2014 Run tests / confirm nothing broken",
     " 10. kuma_context   \u2192 changes             \u2014 Review session activity",
     "",
+    "\u{1F504} Record INLINE as you work \u2014 not just at steps 5-8. Every read/grep = mini research_save.",
+    "\u{1F9E0} Graph is persistent \u2014 nodes/edges accumulate across sessions.",
+    "",
     "ON DISCOVERY (When needed):",
     "  kuma_memory \u2192 domain_rules   \u2014 Business rules (Layer 1)",
     "  kuma_memory \u2192 context        \u2014 Additional notes",
@@ -457,6 +474,78 @@ function generateInitMdContent() {
     "  kuma_memory \u2192 mine           \u2014 Historical context",
     "```",
     "",
+    "## \u{1F9E0} How the Scanner Works",
+    "",
+    "Kuma's code scanner (`kumaCodeScanner.ts`) uses **regex-based pattern matching**",
+    "to detect code structure. It is NOT a full AST parser (no Babel/TypeScript compiler dependency).",
+    "",
+    "**What it detects (line-by-line regex):**",
+    "- `function` declarations (named + async + generator)",
+    "- Arrow function assignments (`const foo = (...) => ...`)",
+    "- Typed arrow functions (`const foo: Type = (...) => ...`)",
+    "- Class declarations (includes extends/implements)",
+    "- React/Vue components (functions returning JSX)",
+    "- API route handlers (Express + Hono patterns)",
+    "- Import statements (local file imports only)",
+    "- Function calls cross-file (`calls` edges)",
+    "- Test files (`.test.`, `.spec.`, `__tests__/`)",
+    "",
+    "**Known limitations:**",
+    "- Regex-based = can miss multi-line constructs or non-standard patterns",
+    "- Complex generics or deeply nested syntax may not match",
+    "- TypeScript advanced types may be partially parsed",
+    "- Scanner runs automatically during `kuma_context research` step 3",
+    "- If scanner returns 0 structural nodes, the regex patterns didn't match your code style",
+    "",
+    "**For richer code analysis:**",
+    "- Record findings INLINE as you read/grep \u2014 this builds the graph manually",
+    "- Call `research_save` after exploring files to persist function/class/import nodes",
+    "- The more you use Kuma, the richer the graph becomes (persistent across sessions)",
+    "",
+    "---",
+    "",
+    "## \u{1F4BE} How to Read Memory & Search the Graph",
+    "",
+    "Kuma stores knowledge in two places:",
+    "",
+    "**1. Knowledge Graph (SQLite - `.kuma/kuma.db`)**",
+    "- Nodes: files, functions, classes, components, routes, tests, gotchas, decisions",
+    "- Edges: imports, calls, extends, contains, composes, routes",
+    '- Query: `kuma_memory({ action: "search", query: "<term>" })`',
+    "- Falls back to codebase grep if graph is empty",
+    "",
+    "**2. Research Cache (SQLite - `.kuma/kuma.db`)**",
+    '- Saved via `kuma_memory({ action: "research_save", scope: "<area>", confidence: 0.8 })`',
+    '- List: `kuma_context({ action: "researches" })`',
+    '- Auto-loaded during `kuma_context({ action: "research", scope: "<area>" })`',
+    "",
+    "**Quick memory reading tips:**",
+    '- `kuma_context({ action: "init" })` \u2014 shows graph stats + recent research + health score',
+    '- `kuma_context({ action: "research", scope: "<area>" })` \u2014 deep research with graph query',
+    '- `kuma_memory({ action: "search", query: "<term>" })` \u2014 search all memories + graph',
+    '- `kuma_context({ action: "visualize" })` \u2014 Mermaid diagram of the graph',
+    '- `kuma_context({ action: "drift" })` \u2014 check if memories are stale vs actual code',
+    '- `kuma_context({ action: "changes" })` \u2014 view session activity log',
+    "",
+    "---",
+    "",
+    "## \u{1F52C} How Verification Works",
+    "",
+    '`kuma_safety({ action: "verify", scope: "<area>" })` \u2014 STEP 9',
+    "",
+    "**Auto-detection logic:**",
+    "1. Checks `package.json` \u2192 `scripts.test` \u2192 uses npm/pnpm/yarn test",
+    "2. If no test script, checks for Makefile with `test:` target",
+    "3. Falls back to Python (pytest), Rust (cargo test), Go (go test)",
+    "4. Last resort: `npx tsc --noEmit` (TypeScript syntax check) or `node -c`",
+    "5. If nothing found: returns informative message instead of failing",
+    "",
+    "**Important:** Verification is NEVER auto-triggered. You must call it explicitly.",
+    "The 5-layer safety guard (concurrency lock, rate limiting, staleness cache,",
+    "runaway detection, hard timeout) prevents resource exhaustion.",
+    "",
+    "---",
+    "",
     "## \u{1F6AB} What Kuma Does NOT Do (Use Agent Native Tools)",
     "",
     "| Function | Correct Tool |",
@@ -509,13 +598,16 @@ function handleOpencodeSecondary(root, results) {
       '  2. `kuma_kuma_safety({ action: "guard" })`                            \u2014 Safety check before work',
       '  3. `kuma_kuma_context({ action: "research", scope: "<area>" })`        \u2014 Research before editing',
       "  4. *(edit/read using native tools)*",
-      '  5. `kuma_kuma_memory({ action: "research_save", ... })`               \u2014 Save all findings',
-      '  6. `kuma_kuma_memory({ action: "gotcha" })`                           \u2014 Record bugs/quirks found',
-      '  7. `kuma_kuma_memory({ action: "arch_flow" })`                        \u2014 Record data flow if mapped',
-      '  8. `kuma_kuma_memory({ action: "decision" })`                         \u2014 Record key findings/decisions',
+      '  5. `kuma_kuma_memory({ action: "research_save", ... })`               \u2014 Save findings (inline after every read/grep)',
+      '  6. `kuma_kuma_memory({ action: "gotcha" })`                           \u2014 Record bugs/quirks (inline when found)',
+      '  7. `kuma_kuma_memory({ action: "arch_flow" })`                        \u2014 Record data flow (inline after each hop)',
+      '  8. `kuma_kuma_memory({ action: "decision" })`                         \u2014 Record key decisions (inline when choosing)',
       '  9. `kuma_kuma_safety({ action: "verify", ... })`                      \u2014 Run tests / confirm nothing broken',
       ' 10. `kuma_kuma_context({ action: "changes" })`                         \u2014 Review session activity',
       "",
+      "\u{1F504} Record findings INLINE as you work \u2014 Every read/grep = mini research_save.",
+      "\u{1F9E0} Graph is persistent \u2014 nodes/edges accumulate across sessions.",
+      "",
       "\u26A0\uFE0F **OpenCode platform note:** Tool names are prefixed with `kuma_kuma_*`",
       "   (server name `kuma` + already-prefixed tool name `kuma_context`).",
       "",
@@ -644,6 +736,9 @@ function getCombinedAgentsMd(selectedTypes) {
     '  9. `[kuma_]safety({ action: "verify", ... })`               \u2014 Run tests / confirm nothing broken',
     ' 10. `[kuma_]context({ action: "changes" })`                  \u2014 Review session activity',
     "",
+    "\u{1F504} Record findings INLINE as you work \u2014 Every read/grep = mini research_save.",
+    "\u{1F9E0} Graph is persistent \u2014 nodes/edges accumulate across sessions.",
+    "",
     "\u26D4 Do NOT skip steps 5-10 after research \u2014 even if no code was changed.",
     "",
     "Replace `[kuma_]` with the correct prefix for your platform (see below).",
@@ -851,13 +946,16 @@ function handleQuickrefGeneration(root, results) {
     '  2. `kuma_safety({ action: "guard" })`                             \u2014 Safety check',
     '  3. `kuma_context({ action: "research", scope: "<area>" })`         \u2014 Research',
     "  4. *(edit/read using native tools)*",
-    '  5. `kuma_memory({ action: "research_save", ... })`                \u2014 Save findings',
-    '  6. `kuma_memory({ action: "gotcha" })`                            \u2014 Gotchas!',
-    '  7. `kuma_memory({ action: "arch_flow" })`                         \u2014 Arch flow',
-    '  8. `kuma_memory({ action: "decision" })`                          \u2014 Decision',
+    '  5. `kuma_memory({ action: "research_save", ... })`                \u2014 Save findings (inline after every read)',
+    '  6. `kuma_memory({ action: "gotcha" })`                            \u2014 Gotchas (inline when found)',
+    '  7. `kuma_memory({ action: "arch_flow" })`                         \u2014 Arch flow (inline after each hop)',
+    '  8. `kuma_memory({ action: "decision" })`                          \u2014 Decision (inline when choosing)',
     '  9. `kuma_safety({ action: "verify", ... })`                       \u2014 Verify',
     ' 10. `kuma_context({ action: "changes" })`                          \u2014 Review changes',
     "",
+    "\u{1F504} Record INLINE as you work \u2014 Every read/grep = mini research_save.",
+    "\u{1F9E0} Graph is persistent \u2014 accumulates across sessions.",
+    "",
     "\u26D4 Steps 5-10 are mandatory even for research-only sessions!",
     "",
     "## Platform Tool Names",

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   ALL_CONFIG_TYPES,
   formatInitResults,
   runInit
-} from "./chunk-3AN4RSN5.js";
+} from "./chunk-AJ7HHUDW.js";
 import {
   formatDecisionTemplate,
   getProactiveMemories,
@@ -336,7 +336,7 @@ async function handleResearch(params) {
     lines.push("  \u26A0\uFE0F Graph query failed");
   }
   try {
-    const { scanCodebase } = await import("./kumaCodeScanner-LFJGPJNH.js");
+    const { scanCodebase } = await import("./kumaCodeScanner-QYQUL4W6.js");
     const scanResult = await scanCodebase({ scope, maxFiles: 100 });
     if (scanResult.nodeCount > 0 || scanResult.edgeCount > 0) {
       lines.push(`  \u{1F52C} Auto-scanned ${scanResult.filesScanned} files \u2192 ${scanResult.nodeCount} nodes, ${scanResult.edgeCount} edges`);
@@ -2149,7 +2149,7 @@ async function handleVerify(params) {
   }
   _lastVerifyCall = now;
   sessionMemory.recordToolCall("kuma_safety_verify", { scope: params.scope || params.filePath });
-  const { runAutoVerification } = await import("./kumaVerifier-KAYJHR5K.js");
+  const { runAutoVerification } = await import("./kumaVerifier-6NTJQU7B.js");
   return await runAutoVerification({
     scope: params.scope || params.filePath,
     force: params.force,
@@ -2190,7 +2190,7 @@ function registerAllTools(server) {
   );
   server.tool(
     "kuma_memory",
-    "**Call AFTER research/editing every session** (including research-only).\n\nMANDATORY (call AFTER every research session):\n\u2022 STEP 5: `research_save` \u2014 IMMEDIATELY after exploring/editing. Save ALL findings.\n\u2022 STEP 6: `gotcha` \u2014 IMMEDIATELY after finding bugs/quirks. Every bug = a gotcha!\n\u2022 STEP 7: `arch_flow` \u2014 IMMEDIATELY after tracing data/code flow. Record before next task.\n\u2022 STEP 8: `decision` \u2014 IMMEDIATELY after each research session. Bukan cuma code changes \u2014 temuan juga.\n\nON DISCOVERY (when you encounter something):\n\u2022 `domain_rules` \u2014 uncovered business rules? Save them!\n\u2022 `context` \u2014 need to inject extra notes? Use this!\n\u2022 `todo` \u2014 create persistent task items\n\u2022 `mine` \u2014 extract historical context from git log\n\nOther actions: session, heal, search, changes, benchmark, layers.",
+    "**Call AFTER research/editing every session** (including research-only). Record INLINE as you work.\n\nRECORD INLINE (call IMMEDIATELY during research):\n\u2022 STEP 5: `research_save` \u2014 every read/grep that finds new files/functions. Don't wait!\n\u2022 STEP 6: `gotcha` \u2014 IMMEDIATELY when you discover bugs/quirks. Record INLINE, not at the end.\n\u2022 STEP 7: `arch_flow` \u2014 IMMEDIATELY after EACH flow hop trace. Record before next task.\n\u2022 STEP 8: `decision` \u2014 IMMEDIATELY when choosing between options or finding architecture patterns.\n\nON DISCOVERY (when you encounter something):\n\u2022 `domain_rules` \u2014 uncovered business rules? Save them!\n\u2022 `context` \u2014 need to inject extra notes? Use this!\n\u2022 `todo` \u2014 create persistent task items\n\u2022 `mine` \u2014 extract historical context from git log\n\nOther actions: session, heal, search, changes, benchmark, layers.",
     {
       action: z.enum(["decision", "mine", "research_save", "session", "heal", "search", "changes", "todo", "context", "benchmark", "decision_log", "domain_rules", "arch_flow", "gotcha", "layers", "federated", "gen_test", "trajectory", "skills"]).describe("Memory action: decision=ADR, mine=mine git log & comments, research_save=save, session=summary, heal=repair, search=search, changes=log, todo=manage todos, context=inject notes, benchmark=capture/diff, decision_log=manage decisions, domain_rules=Layer 1 business rules (Issue #17), arch_flow=Layer 2 architecture flow (Issue #17), gotcha=Layer 3 known gotchas (Issue #17/#21), layers=all 3 layers summary, federated=resolve federated kuma:// URI (Issue #27), gen_test=generate test from trajectory (Issue #28), trajectory=list trajectories, skills=list distilled skills"),
       scope: z.string().optional().describe("Scope for research_save/search/todo/context/mine/federated"),
@@ -2362,7 +2362,7 @@ async function main() {
     console.error("");
     let killedCount = 0;
     try {
-      const { getRunningVerificationPid } = await import("./kumaVerifier-KAYJHR5K.js");
+      const { getRunningVerificationPid } = await import("./kumaVerifier-6NTJQU7B.js");
       const pid = getRunningVerificationPid();
       if (pid) {
         try {
@@ -2571,7 +2571,7 @@ async function main() {
   });
   (async () => {
     try {
-      const { generateInitMdContent } = await import("./init-RLILMGIK.js");
+      const { generateInitMdContent } = await import("./init-BC7FG4C2.js");
       const fs7 = await import("fs");
       const path7 = await import("path");
       const initMdPath = path7.resolve(process.cwd(), ".kuma/init.md");
@@ -2588,7 +2588,7 @@ async function main() {
   (async () => {
     try {
       const { detectAgent, getSkillPath, getAgentLabel } = await import("./agentDetector-YOWQVJFR.js");
-      const { generateSkill, getSecondaryFiles } = await import("./skillGenerator-G4RS74CB.js");
+      const { generateSkill, getSecondaryFiles } = await import("./skillGenerator-GYEDLFZP.js");
       const fs7 = await import("fs");
       const path7 = await import("path");
       const detection = detectAgent();

package/dist/{init-RLILMGIK.js → init-BC7FG4C2.js}

@@ -4,7 +4,7 @@ import {
   formatInitResults,
   generateInitMdContent,
   runInit
-} from "./chunk-3AN4RSN5.js";
+} from "./chunk-AJ7HHUDW.js";
 import "./chunk-E2KFPEBT.js";
 export {
   ALL_CONFIG_TYPES,

package/dist/{kumaCodeScanner-LFJGPJNH.js → kumaCodeScanner-QYQUL4W6.js}

@@ -21,8 +21,8 @@ function getRoot() {
   return _cachedRoot;
 }
 var FUNCTION_DECL_RE = /(?:export\s+)?(?:async\s+)?function\s*(?:\*\s*)?(\w+)\s*\(/g;
-var ARROW_FN_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*(?::\s*\w+(?:<[^>]*>)?)?\s*=>/g;
-var TYPED_ARROW_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*:\s*(?:\w+(?:<[^>]*>)?)?\s*=\s*(?:async\s*)?\(/g;
+var ARROW_FN_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[=:]\s*(?:async\s*)?(?:<[^>]+>\s*)?(?:\([\s\S]*?\)|\w+)\s*(?::\s*\w+(?:<[^>]*>)?)?\s*=>/g;
+var TYPED_ARROW_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*:\s*(?:\w+(?:<[^>]*>)?)?\s*=\s*(?:async\s*)?(?:<[^>]+>\s*)?\(/g;
 var CLASS_RE = /(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?/g;
 var IMPORT_RE = /import\s+(?:\{([^}]*)\}\s+from\s+)?(?:\w+\s+from\s+)?(?:\*\s+as\s+\w+\s+from\s+)?['"]([^'"]+)['"]/g;
 var JSX_RETURN_RE = /return\s*\(?\s*</;

package/dist/{kumaVerifier-KAYJHR5K.js → kumaVerifier-6NTJQU7B.js}

@@ -93,7 +93,14 @@ function detectTestRunner(root = process.cwd()) {
   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, "Makefile"))) {
+    try {
+      const makefileContent = fs.readFileSync(path.join(root, "Makefile"), "utf-8");
+      const hasTestTarget = /^test:/m.test(makefileContent) || /^\s+test:/.test(makefileContent);
+      if (hasTestTarget) return { runner: "make", baseCommand: "make test" };
+    } catch {
+    }
+  }
   if (fs.existsSync(path.join(root, "package.json"))) {
     try {
       const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));

package/dist/{skillGenerator-G4RS74CB.js → skillGenerator-GYEDLFZP.js}

@@ -10,13 +10,16 @@ var BOOTSTRAP = [
   '  2. `kuma_safety({ action: "guard" })`                     \u2014 Safety check before work',
   '  3. `kuma_context({ action: "research", scope: "<area>" })` \u2014 Research before editing',
   "  4. *(edit/read using native tools)*",
-  '  5. `kuma_memory({ action: "research_save", ... })`        \u2014 Save all findings',
-  '  6. `kuma_memory({ action: "gotcha" })`                    \u2014 Record bugs/quirks found',
-  '  7. `kuma_memory({ action: "arch_flow" })`                 \u2014 Record data flow if mapped',
-  '  8. `kuma_memory({ action: "decision" })`                  \u2014 Record key findings/decisions',
+  '  5. `kuma_memory({ action: "research_save", ... })`        \u2014 Save findings (inline after every read/grep)',
+  '  6. `kuma_memory({ action: "gotcha" })`                    \u2014 Record bugs/quirks (inline when found)',
+  '  7. `kuma_memory({ action: "arch_flow" })`                 \u2014 Record data flow (inline after each hop)',
+  '  8. `kuma_memory({ action: "decision" })`                  \u2014 Record key decisions (inline when choosing)',
   '  9. `kuma_safety({ action: "verify", ... })`               \u2014 Run tests / confirm nothing broken',
   ' 10. `kuma_context({ action: "changes" })`                  \u2014 Review session activity',
   "",
+  "\u{1F504} Record findings INLINE as you work \u2014 Every read/grep = mini research_save.",
+  "\u{1F9E0} Knowledge graph is persistent \u2014 nodes/edges accumulate across sessions, getting richer over time.",
+  "",
   "\u26D4 Do NOT skip steps 5-10 after research \u2014 even if no code was changed.",
   "\u{1F4D6} Full rules: `.kuma/init.md`",
   "\u{1F9E0} Tools: `kuma_context` | `kuma_memory` | `kuma_safety`"

package/package.json

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