monomind 1.18.15 → 1.19.0

package/.claude/helpers/hook-handler.cjs

@@ -2,6 +2,24 @@
 /**
  * Monomind Hook Handler (Cross-Platform)
  * Dispatches hook events to the appropriate helper modules.
+ *
+ * ARCHITECTURE NOTE — Two Hook Systems
+ * =====================================
+ * There are two independent hook systems in this project:
+ *
+ * 1. .claude/helpers/ CJS handlers (THIS FILE and ./handlers/*.cjs)
+ *    These are the handlers that actually run via settings.json hook
+ *    configuration. They are plain CommonJS scripts invoked directly
+ *    by Claude Code's hook runtime. This is the "live" system.
+ *
+ * 2. @monomind/hooks TypeScript package (packages/@monomind/hooks/)
+ *    A full TypeScript package with workers, learning services, and
+ *    a WorkerManager. It compiles to dist/ but is only loaded
+ *    optionally — currently at session-restore (to bridge pre-task /
+ *    post-task into the hook registry) and at session-restore for a
+ *    non-blocking security scan. The CJS handlers in system (1) are
+ *    the authoritative dispatch path; system (2) provides optional
+ *    enrichment when the package is installed and built.
  */
 
 const path = require('path');
@@ -435,6 +453,44 @@ const handlers = {
                     }
                   }
                 }
+
+                // --- Strategy 9: alternation patterns (TODO\|FIXME, mock\|fake\|stub) ---
+                if (!graphAssisted && pattern.indexOf('|') !== -1) {
+                  var altParts = pattern.split(/\\?\|/).map(function(p) {
+                    return p.replace(/[^a-zA-Z0-9_$]/g, '');
+                  }).filter(function(p) {
+                    return p.length >= 4 && /^[a-zA-Z_$]/.test(p) && !_grepStop[p.toLowerCase()];
+                  });
+                  for (var ai = 0; ai < altParts.length && !graphAssisted; ai++) {
+                    var arow = db.prepare(
+                      'SELECT n.name, n.file_path, n.start_line FROM nodes n WHERE n.name = ? COLLATE NOCASE AND n.label NOT IN (\'Concept\',\'Community\',\'Folder\') AND n.file_path IS NOT NULL AND n.file_path NOT LIKE \'%.md\' LIMIT 1'
+                    ).get(altParts[ai]);
+                    if (arow) {
+                      graphAssisted = true;
+                      var ahint = arow.file_path + (arow.start_line != null ? ':' + arow.start_line : '');
+                      console.log('[MONOGRAPH_HINT] ' + arow.name + ' → ' + ahint);
+                    }
+                  }
+                }
+
+              }
+            }
+            // --- Strategy 10: grep targeting a known source directory ---
+            // Runs outside `if (pattern)` so it works even when pattern extraction fails
+            if (!graphAssisted) {
+              var db10 = _openMonographDb();
+              if (db10) {
+                var dirMatch10 = cmdAfterTool.match(/\b(src|packages(?:\/[a-zA-Z0-9_@/-]*)?)\//);
+                if (dirMatch10) {
+                  var dirPath10 = dirMatch10[1].replace(/\/$/, '');
+                  var drow10 = db10.prepare(
+                    'SELECT COUNT(*) AS c FROM nodes WHERE label = \'File\' AND file_path LIKE ? LIMIT 1'
+                  ).get('%' + dirPath10 + '/%');
+                  if (drow10 && drow10.c > 0) {
+                    graphAssisted = true;
+                    console.log('[MONOGRAPH_HINT] grep scope ' + dirPath10 + ' has ' + drow10.c + ' indexed files');
+                  }
+                }
               }
             }
           } else {
@@ -452,6 +508,38 @@ const handlers = {
                 }
               }
             }
+            // find -name "*worker*" — extract core word from wildcard patterns
+            if (!graphAssisted) {
+              var wm = cmd.match(/-name\s+["'][*]?([a-zA-Z][a-zA-Z0-9_-]{3,})[*]?(?:\.[a-z]+)?["']/);
+              if (wm && wm[1]) {
+                var db = _openMonographDb();
+                if (db) {
+                  var wrow = db.prepare(
+                    'SELECT n.name, n.file_path FROM nodes n WHERE n.name LIKE ? AND n.label = \'File\' AND n.file_path NOT LIKE \'%.md\' LIMIT 1'
+                  ).get('%' + wm[1] + '%');
+                  if (wrow) {
+                    graphAssisted = true;
+                    console.log('[MONOGRAPH_HINT] file *' + wm[1] + '* → ' + wrow.file_path);
+                  }
+                }
+              }
+            }
+            // find with -type f in a known directory scope
+            if (!graphAssisted) {
+              var fdm = cmd.match(/\bfind\s+(\S*(?:src|packages|lib|app)[a-zA-Z0-9_@/-]*)/);
+              if (fdm && fdm[1]) {
+                var db = _openMonographDb();
+                if (db) {
+                  var fdrow = db.prepare(
+                    'SELECT COUNT(*) AS c FROM nodes WHERE label = \'File\' AND file_path LIKE ? LIMIT 1'
+                  ).get(fdm[1].replace(/\/$/, '') + '/%');
+                  if (fdrow && fdrow.c > 0) {
+                    graphAssisted = true;
+                    console.log('[MONOGRAPH_HINT] find scope ' + fdm[1] + ' has ' + fdrow.c + ' indexed files');
+                  }
+                }
+              }
+            }
           }
         } catch (e) { /* non-fatal */ }
       }
@@ -647,10 +735,6 @@ const handlers = {
     h.handle(hCtx);
   },
 
-  'status': () => {
-    console.log('[OK] Status check');
-  },
-
   'stats': async () => {
     const h = require('./handlers/stats-handler.cjs');
     await h.handle(hCtx);
@@ -669,7 +753,7 @@ if (command && handlers[command]) {
   } else if (command) {
     console.log('[OK] Hook: ' + command);
   } else {
-    console.log('Usage: hook-handler.cjs <route|pre-bash|pre-search|post-edit|post-read|post-graph-tool|session-restore|session-end|pre-task|post-task|compact-manual|compact-auto|status|stats>');
+    console.log('Usage: hook-handler.cjs <route|pre-bash|pre-search|post-edit|post-graph-tool|session-restore|session-end|pre-task|post-task|compact-manual|compact-auto|stats>');
   }
 }
 

package/.claude/helpers/intelligence.cjs

@@ -22,12 +22,14 @@ const STORE_FILE = path.join(DATA_DIR, 'auto-memory-store.json');
 const RANKED_FILE = path.join(DATA_DIR, 'ranked-context.json');
 const PENDING_FILE = path.join(DATA_DIR, 'pending-insights.jsonl');
 const OUTCOMES_FILE = path.join(DATA_DIR, 'intelligence-outcomes.jsonl');
+const RECENT_EDITS_FILE = path.join(DATA_DIR, 'recent-edits.jsonl');
 
 const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MiB guard
 const RING_BUFFER_MAX = 50;
 
 var _entries = [];        // deduplicated memory entries loaded from store
-var _recentEdits = [];    // ring buffer of recently edited paths
+var _recentEdits = [];    // ring buffer of recently edited paths (in-memory, may be empty across subprocesses)
+var _lastContext = null;  // last non-null context returned by getContext()
 
 function ensureDataDir() {
   try { fs.mkdirSync(DATA_DIR, { recursive: true }); } catch (_) {}
@@ -70,6 +72,8 @@ function init() {
     return true;
   });
 
+  // Bootstrap from monograph when store is sparse — called externally via bootstrapFromDb(db)
+
   // Write ranked-context.json (sorted by confidence desc) with version envelope
   var ranked = _entries.slice().sort(function(a, b) {
     return (b.confidence || 0) - (a.confidence || 0);
@@ -87,28 +91,50 @@ function getContext(prompt) {
   if (!prompt || typeof prompt !== 'string' || prompt.trim() === '') return null;
   if (_entries.length === 0) return null;
 
-  var promptWords = prompt.toLowerCase().split(/\W+/).filter(Boolean);
+  var promptWords = prompt.toLowerCase().split(/\W+/).filter(function(w) { return w.length >= 3; });
   var promptSet = new Set(promptWords);
+  if (promptSet.size < 2) return null; // need at least 2 meaningful words
 
-  var matches = _entries.filter(function(e) {
+  var scored = [];
+  for (var i = 0; i < _entries.length; i++) {
+    var e = _entries[i];
     var content = ((e.content || '') + ' ' + (e.summary || '')).toLowerCase();
-    var words = content.split(/\W+/).filter(Boolean);
-    return words.some(function(w) { return promptSet.has(w); });
-  });
+    var words = content.split(/\W+/).filter(function(w) { return w.length >= 3; });
+    var hits = 0;
+    for (var j = 0; j < words.length; j++) {
+      if (promptSet.has(words[j])) hits++;
+    }
+    // Require at least 2 distinct word matches to reduce false positives
+    if (hits >= 2) {
+      scored.push({ entry: e, hits: hits });
+    }
+  }
 
-  if (matches.length === 0) return null;
+  if (scored.length === 0) return null;
+
+  // Sort by hit count descending, then by confidence
+  scored.sort(function(a, b) {
+    if (b.hits !== a.hits) return b.hits - a.hits;
+    return (b.entry.confidence || 0) - (a.entry.confidence || 0);
+  });
 
-  var top = matches[0];
-  return '[INTELLIGENCE] ' + (top.summary || top.content || top.id || 'context match');
+  var top = scored[0].entry;
+  var result = '[INTELLIGENCE] ' + (top.summary || top.content || top.id || 'context match');
+  _lastContext = result;
+  return result;
 }
 
 // ── recordEdit ────────────────────────────────────────────────────────────────
 
 function recordEdit(filePath) {
-  _recentEdits.push({ path: String(filePath || ''), ts: Date.now() });
+  var entry = { path: String(filePath || ''), ts: Date.now() };
+  _recentEdits.push(entry);
   if (_recentEdits.length > RING_BUFFER_MAX) {
     _recentEdits = _recentEdits.slice(-RING_BUFFER_MAX);
   }
+  // Persist to disk so other subprocesses (e.g. feedback()) can read edits
+  ensureDataDir();
+  try { fs.appendFileSync(RECENT_EDITS_FILE, JSON.stringify(entry) + '\n', 'utf-8'); } catch (_) {}
 }
 
 // ── consolidate ───────────────────────────────────────────────────────────────
@@ -121,18 +147,103 @@ function consolidate() {
   // Clear the pending file
   try { fs.writeFileSync(PENDING_FILE, '', 'utf-8'); } catch (_) {}
 
-  return { entries: count, edges: 0, newEntries: count };
+  // Read accumulated session edits (not yet consumed by feedback)
+  var sessionEdits = [];
+  var editLines = safeReadLines(RECENT_EDITS_FILE);
+  for (var ei = 0; ei < editLines.length; ei++) {
+    try { sessionEdits.push(JSON.parse(editLines[ei])); } catch (_) {}
+  }
+  // Clear recent-edits after consolidation (session boundary)
+  try { fs.writeFileSync(RECENT_EDITS_FILE, '', 'utf-8'); } catch (_) {}
+
+  // Synthesize successful patterns from outcomes into auto-memory-store.json
+  var outcomeLines = safeReadLines(OUTCOMES_FILE);
+  var newStoreEntries = [];
+  for (var i = 0; i < outcomeLines.length; i++) {
+    try {
+      var outcome = JSON.parse(outcomeLines[i]);
+      if (!outcome.success) continue;
+      // Use outcome's own edits if present, otherwise use session-level edits
+      var edits = (Array.isArray(outcome.recentEdits) && outcome.recentEdits.length > 0)
+        ? outcome.recentEdits
+        : sessionEdits;
+      if (edits.length === 0) continue;
+      var editPaths = edits.map(function(e) {
+        // e is either { path: '...', ts: ... } or a raw string
+        if (typeof e === 'string') return e;
+        // Use e.path if it's a non-empty string; skip objects without a valid path
+        return (e && typeof e.path === 'string' && e.path.length > 0) ? e.path : null;
+      }).filter(function(p) { return p !== null; });
+      // Deduplicate paths
+      var uniquePaths = [];
+      var pathSeen = {};
+      for (var pi = 0; pi < editPaths.length; pi++) {
+        var p = String(editPaths[pi]);
+        if (!pathSeen[p]) { pathSeen[p] = true; uniquePaths.push(p); }
+      }
+      newStoreEntries.push({
+        id: 'auto-' + (outcome.ts || Date.now()) + '-' + i,
+        type: 'pattern',
+        content: 'Successful edit pattern: ' + uniquePaths.map(function(p) { return path.basename(p); }).join(', '),
+        summary: outcome.context || 'Successful task editing ' + uniquePaths.length + ' files: ' + uniquePaths.slice(0, 5).map(function(p) { return path.basename(p); }).join(', '),
+        confidence: 0.6,
+        files: uniquePaths,
+        ts: outcome.ts || Date.now(),
+      });
+    } catch (_) {}
+  }
+
+  if (newStoreEntries.length > 0) {
+    // Merge with existing store entries
+    var existing = safeReadJson(STORE_FILE);
+    var store = Array.isArray(existing) ? existing : [];
+    var existingIds = new Set(store.map(function(e) { return e && e.id; }));
+    for (var j = 0; j < newStoreEntries.length; j++) {
+      if (!existingIds.has(newStoreEntries[j].id)) {
+        store.push(newStoreEntries[j]);
+      }
+    }
+    // Cap store at 200 entries to prevent unbounded growth
+    if (store.length > 200) {
+      store.sort(function(a, b) { return (b.ts || 0) - (a.ts || 0); });
+      store = store.slice(0, 200);
+    }
+    try {
+      fs.writeFileSync(STORE_FILE, JSON.stringify(store, null, 2), 'utf-8');
+    } catch (_) {}
+    count += newStoreEntries.length;
+  }
+
+  // Rotate outcomes: keep last 500 lines to prevent unbounded growth
+  if (outcomeLines.length > 500) {
+    try {
+      fs.writeFileSync(OUTCOMES_FILE, outcomeLines.slice(-500).join('\n') + '\n', 'utf-8');
+    } catch (_) {}
+  }
+
+  return { entries: count, edges: 0, newEntries: newStoreEntries.length };
 }
 
 // ── feedback ──────────────────────────────────────────────────────────────────
 
 function feedback(success) {
   ensureDataDir();
+  // Read persisted edits from disk (survives subprocess boundaries).
+  // We intentionally do NOT clear recent-edits.jsonl here — that is done by
+  // consolidate() at session-end. This prevents post-task (subagent completion)
+  // from clearing edits that belong to the broader session's work.
+  var diskEdits = [];
+  var diskLines = safeReadLines(RECENT_EDITS_FILE);
+  for (var i = 0; i < diskLines.length; i++) {
+    try { diskEdits.push(JSON.parse(diskLines[i])); } catch (_) {}
+  }
+  // Use disk edits if available, fall back to in-memory buffer
+  var edits = diskEdits.length > 0 ? diskEdits.slice(-RING_BUFFER_MAX) : _recentEdits.slice();
   var record = JSON.stringify({
     ts: Date.now(),
     success: !!success,
-    context: null,
-    recentEdits: _recentEdits.slice(),
+    context: _lastContext,
+    recentEdits: edits,
   }) + '\n';
   try { fs.appendFileSync(OUTCOMES_FILE, record, 'utf-8'); } catch (_) {}
 }
@@ -161,7 +272,8 @@ function storePattern(pattern) {
   void pattern;
 }
 
-// ── AutoMem bridges (arXiv:2607.01224) ───────────────────────────────────────
+// ── AutoMem bridges — lazy-load the compiled intelligence module and expose ──
+// ── its pattern-recall/decision-recording helpers to the .cjs hook handlers ──
 
 var _intelligenceMod = null;
 
@@ -186,4 +298,41 @@ async function recordMemoryDecision(input) {
   if (mod && mod.recordMemoryDecision) return mod.recordMemoryDecision(input);
 }
 
-module.exports = { init, getContext, recordEdit, consolidate, feedback, stats, logTrajectory, storePattern, findSimilarPatterns, recordMemoryDecision };
+// Bootstrap intelligence store from an already-open monograph DB handle.
+// Called from route-handler on first prompt when store is sparse.
+function bootstrapFromDb(db) {
+  if (!db || _entries.length >= 5) return 0;
+  try {
+    var hubs = db.prepare(
+      "SELECT n.name, n.label, n.file, COUNT(e.id) AS deg " +
+      "FROM nodes n JOIN edges e ON (e.source = n.id OR e.target = n.id) " +
+      "WHERE n.label IN ('File','Function','Class') AND n.file NOT LIKE '%node_modules%' AND n.file NOT LIKE '%dist/%' " +
+      "GROUP BY n.id ORDER BY deg DESC LIMIT 10"
+    ).all();
+    if (hubs.length === 0) return 0;
+    var existingIds = new Set(_entries.map(function(e) { return e.id; }));
+    var added = 0;
+    for (var hi = 0; hi < hubs.length; hi++) {
+      var h = hubs[hi];
+      var bId = 'bootstrap-hub-' + hi;
+      if (existingIds.has(bId)) continue;
+      _entries.push({
+        id: bId,
+        type: 'hub',
+        content: h.name + ' (' + h.label + ') — ' + (h.file || '').replace(CWD + '/', '') + ' (' + h.deg + ' connections)',
+        summary: 'Key codebase hub: ' + h.name + ' with ' + h.deg + ' dependencies',
+        confidence: 0.4,
+        files: h.file ? [h.file] : [],
+        ts: Date.now(),
+      });
+      added++;
+    }
+    if (added > 0) {
+      ensureDataDir();
+      try { fs.writeFileSync(STORE_FILE, JSON.stringify(_entries, null, 2), 'utf-8'); } catch (_) {}
+    }
+    return added;
+  } catch (_) { return 0; }
+}
+
+module.exports = { init, getContext, recordEdit, consolidate, feedback, stats, logTrajectory, storePattern, findSimilarPatterns, recordMemoryDecision, bootstrapFromDb };

package/.claude/helpers/learning-service.mjs

@@ -33,6 +33,7 @@ export class LearningService {
     } catch (_) {
       this._entries = [];
     }
+
     this._initialized = true;
   }
 

package/.claude/helpers/mastermind-activate.cjs

@@ -1,53 +1,35 @@
 'use strict';
-const fs = require('fs');
-const path = require('path');
+// monolean: 207-line protocol replaced with compact routing table.
+// The enforcement prose, anti-drift guards, iron laws, and mandatory patterns
+// are redundant with using-superpowers skill and add ~4K tokens per session.
+// The routing table is the unique value — tells Claude which skill for which task.
+// Full protocol loads on-demand via /mastermind.
 
-// Walk up from cwd to find the project root containing master.md
-function findMasterPath() {
-  const candidates = [];
-  if (process.env.CLAUDE_PROJECT_DIR) candidates.push(process.env.CLAUDE_PROJECT_DIR);
-  let dir = process.cwd();
-  for (let i = 0; i < 12; i++) {
-    candidates.push(dir);
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  for (const base of candidates) {
-    const p = path.join(base, '.claude', 'commands', 'mastermind', 'master.md');
-    if (fs.existsSync(p)) return p;
-  }
-  return null;
-}
-
-// Extract only the MASTERMIND PROTOCOL section (before the capability menu / execution flow).
-// The protocol section ends at the separator before "**If $ARGUMENTS is empty:**"
-function extractProtocol(content) {
-  const marker = '\n---\n\n**If $ARGUMENTS is empty:**';
-  const idx = content.indexOf(marker);
-  if (idx !== -1) return content.slice(0, idx).trim();
-  // Fallback: everything before the capability menu header
-  const fallback = content.indexOf('\n**MASTERMIND** —');
-  if (fallback !== -1) return content.slice(0, fallback).trim();
-  return content.trim();
-}
-
-const masterPath = findMasterPath();
-if (!masterPath) {
-  process.stderr.write('[mastermind-activate] master.md not found — skipping injection\n');
-  process.exit(0);
-}
-
-let raw;
-try {
-  raw = fs.readFileSync(masterPath, 'utf8');
-} catch (e) {
-  process.stderr.write('[mastermind-activate] Could not read master.md: ' + e.message + '\n');
-  process.exit(0);
-}
-
-// Strip YAML frontmatter
-const body = raw.replace(/^---[\s\S]*?---\s*/, '');
-const protocol = extractProtocol(body);
-
-process.stdout.write(protocol + '\n');
+process.stdout.write(
+  '## Mastermind Skill Router\n\n' +
+  'Invoke the matching skill BEFORE responding. If unsure, check — invoking and finding it irrelevant costs less than skipping it.\n\n' +
+  '| Task | Skill |\n|---|---|\n' +
+  '| Debug/fix bug | `mastermind:debug` |\n' +
+  '| Verify claim/test/fix | `mastermind:verify` |\n' +
+  '| TDD (red-green-refactor) | `mastermind:tdd` |\n' +
+  '| Write implementation plan | `mastermind:plan` |\n' +
+  '| Execute a plan | `mastermind:execute` |\n' +
+  '| Subagent-driven plan execution | `mastermind:taskdev` |\n' +
+  '| Ingest spec → agent tasks | `mastermind:createtask` |\n' +
+  '| Execute task file/board | `mastermind:do` |\n' +
+  '| Design before code | `mastermind:design` |\n' +
+  '| Build feature/fix | `mastermind:build` |\n' +
+  '| Code/content review | `mastermind:review` |\n' +
+  '| Apply received review | `mastermind:receive-review` |\n' +
+  '| Architecture/DDD | `mastermind:architect` |\n' +
+  '| Research/analysis | `mastermind:research` |\n' +
+  '| Ideation | `mastermind:idea` / `mastermind:ideate` |\n' +
+  '| Improvement analysis | `mastermind:improve` |\n' +
+  '| Marketing/sales/content | `mastermind:marketing` / `mastermind:sales` / `mastermind:content` |\n' +
+  '| Release/finish branch | `mastermind:release` / `mastermind:finish` |\n' +
+  '| Autonomous build+review | `mastermind:autodev` |\n' +
+  '| Isolated work | `mastermind:worktree` |\n' +
+  '| Brain/memory inspect | `mastermind:brain` |\n\n' +
+  'Process skills (debug, idea, architect, research) set the approach. Execution skills (build, review, release) carry it out.\n' +
+  'Subagents with `<SUBAGENT-STOP>` gate skip this routing.\n'
+);

package/.claude/helpers/monolean-activate.cjs

@@ -1,6 +1,5 @@
 'use strict';
 const { getDefaultMode, setMode, clearMode } = require('./monolean-config.cjs');
-const { getMonoleanInstructions } = require('./monolean-instructions.cjs');
 const fs = require('fs');
 const path = require('path');
 
@@ -16,5 +15,16 @@ try {
   fs.writeFileSync(path.join(metricsDir, 'monolean-mode.json'), JSON.stringify({ mode, ts: Date.now() }));
 } catch {}
 
-const instructions = getMonoleanInstructions(mode);
-process.stdout.write(instructions);
+// monolean: compact session-start directive. The full SKILL.md loads on-demand
+// via /monolean — session context just needs the core rules.
+process.stdout.write(
+  'MONOLEAN MODE ACTIVE — level: ' + mode + '\n\n' +
+  'Lazy senior dev mode. Lazy = efficient. Best code = code never written.\n' +
+  'The ladder (stop at first rung that holds): ' +
+  '1) YAGNI 2) Already in codebase? Reuse 3) Stdlib 4) Native platform 5) Installed dep 6) One line 7) Minimum code.\n' +
+  'Read the code first, trace the real flow, THEN climb the ladder.\n' +
+  'Bug fix = root cause fix. No unrequested abstractions. Deletion > addition. Fewest files. Code first, 3 lines max explanation.\n' +
+  'Never lean away: trust-boundary validation, data-loss prevention, security, accessibility, explicit user requests.\n' +
+  'Mark deliberate simplifications: `// monolean: [ceiling] — [upgrade path]`\n' +
+  'Off: "stop monolean". Switch: `/monolean lite|full|ultra`.\n'
+);

package/.claude/helpers/monolean-propagate.cjs

@@ -1,9 +1,13 @@
 'use strict';
 const { readMode } = require('./monolean-config.cjs');
-const { getMonoleanInstructions } = require('./monolean-instructions.cjs');
 
 const mode = readMode();
 if (!mode || mode === 'off') process.exit(0);
 
-const instructions = getMonoleanInstructions(mode);
-process.stdout.write(instructions);
+// monolean: full manifesto replaced with compact directive. Subagents get a
+// focused task — they don't need 100 lines of philosophy to write lean code.
+process.stdout.write(
+  'MONOLEAN MODE ACTIVE — level: ' + mode + '. ' +
+  'Write the minimum code that works. Stdlib over deps. Delete over add. ' +
+  'No unrequested abstractions, no scaffolding, no boilerplate.\n'
+);

package/.claude/helpers/router.cjs

@@ -159,10 +159,27 @@ var MARKETING_OPTIN = /\b(marketing|seo|social media|advertising|campaign|conten
 // ── Skills registry ────────────────────────────────────────────────────────────
 
 var SKILLS = [
-  { skill: 'mastermind', invoke: '/mastermind', description: 'Select swarm topology', keywords: /\b(swarm|topology|hive|mastermind|multi.agent)\b/i },
-  { skill: 'monodesign', invoke: '/monodesign', description: 'Frontend design and UI', keywords: /\b(design|ui|ux|component|visual|layout|css|theme)\b/i },
-  { skill: 'monomotion', invoke: '/monomotion', description: 'Web animations and motion', keywords: /\b(animate|animation|motion|gsap|transition|scroll)\b/i },
-  { skill: 'graphify', invoke: '/graphify', description: 'Input to knowledge graph', keywords: /\b(graph|knowledge|monograph|node|edge|visualize)\b/i },
+  { skill: 'mastermind', invoke: '/mastermind', description: 'Select swarm topology',
+    keywords: /\b(swarm|topology|hive|mastermind|multi.agent)\b/ig,
+    _terms: ['swarm','topology','hive','mastermind','multi-agent','multi agent'] },
+  { skill: 'monodesign', invoke: '/monodesign', description: 'Frontend design and UI',
+    keywords: /\b(design|ui|ux|component|visual|layout|css|theme)\b/ig,
+    _terms: ['design','ui','ux','component','visual','layout','css','theme'] },
+  { skill: 'monomotion', invoke: '/monomotion', description: 'Web animations and motion',
+    keywords: /\b(animate|animation|motion|gsap|transition|scroll)\b/ig,
+    _terms: ['animate','animation','motion','gsap','transition','scroll'] },
+  { skill: 'graphify', invoke: '/graphify', description: 'Input to knowledge graph',
+    keywords: /\b(graph|knowledge|monograph|node|edge|visualize)\b/ig,
+    _terms: ['graph','knowledge','monograph','node','edge','visualize'] },
+  { skill: 'sparc', invoke: '/sparc', description: 'SPARC methodology',
+    keywords: /\b(sparc|specification|pseudocode|refinement|methodology)\b/ig,
+    _terms: ['sparc','specification','pseudocode','refinement','methodology'] },
+  { skill: 'monobrowse', invoke: '/monobrowse', description: 'Browser automation via CDP',
+    keywords: /\b(browse|browser|webpage|screenshot|navigate|selenium|puppeteer|cdp)\b/ig,
+    _terms: ['browse','browser','webpage','screenshot','navigate','selenium','puppeteer','cdp'] },
+  { skill: 'tokens', invoke: '/tokens', description: 'Token usage and cost tracking',
+    keywords: /\b(tokens|token.usage|cost|spending|budget)\b/ig,
+    _terms: ['tokens','token-usage','cost','spending','budget'] },
 ];
 
 // ── Utilities ─────────────────────────────────────────────────────────────────
@@ -188,6 +205,9 @@ function routeTask(prompt) {
 
   var safePrompt = prompt.slice(0, MAX_PROMPT);
 
+  // Skills are always checked — they're the primary value of routing now.
+  var skills = matchSkills(safePrompt);
+
   // Check non-dev domain agents first (only if opt-in keywords match)
   var extras = matchExtras(safePrompt);
   if (extras.length > 0) {
@@ -199,18 +219,25 @@ function routeTask(prompt) {
       reason: 'Domain: ' + topExtra.category,
       semanticRouting: false,
       specificAgents: extras,
-      skillMatches: [],
+      skillMatches: skills,
       extrasMatches: extras,
     };
   }
 
+  // Check if a skill matched strongly (score >= 2) — if so, skip broad catch-all agents
+  var hasStrongSkill = false;
+  for (var si = 0; si < skills.length; si++) {
+    if (skills[si].score >= 2) { hasStrongSkill = true; break; }
+  }
+
   // Check dev patterns in priority order
   for (var i = 0; i < DEV_PRIORITY.length; i++) {
     var slug = DEV_PRIORITY[i];
+    // Skip the broad "coder" catch-all when a specialized skill matched strongly
+    if (slug === 'coder' && hasStrongSkill) continue;
     var pattern = _ROUTING_PATTERNS[slug];
     if (pattern && pattern.test(safePrompt)) {
       var confidence = TASK_CONFIDENCES[slug] || 0.75;
-      var skills = matchSkills(safePrompt);
       return {
         agent: TASK_AGENTS[slug],
         agentSlug: slug,
@@ -232,7 +259,7 @@ function routeTask(prompt) {
     reason: 'Default routing — no strong keyword match',
     semanticRouting: false,
     specificAgents: [],
-    skillMatches: [],
+    skillMatches: skills,
     extrasMatches: [],
   };
 }
@@ -243,13 +270,24 @@ function matchSkills(prompt, topN) {
   if (!prompt || typeof prompt !== 'string') return [];
   topN = topN || 5;
   var safePrompt = prompt.slice(0, MAX_PROMPT);
+  var promptLower = safePrompt.toLowerCase();
 
   var scored = [];
   for (var i = 0; i < SKILLS.length; i++) {
     var s = SKILLS[i];
-    if (s.keywords.test(safePrompt)) {
-      scored.push({ skill: s.skill, invoke: s.invoke, description: s.description, score: 1.0 });
+    // Reset regex lastIndex (global flag) before testing
+    s.keywords.lastIndex = 0;
+    if (!s.keywords.test(safePrompt)) continue;
+
+    // Count distinct keyword hits for scoring
+    var hits = 0;
+    var terms = s._terms || [];
+    for (var t = 0; t < terms.length; t++) {
+      if (promptLower.indexOf(terms[t]) !== -1) hits++;
     }
+    // Score: 1 base + 1 per additional keyword hit (min 1, max = term count)
+    var score = Math.max(1, hits);
+    scored.push({ skill: s.skill, invoke: s.invoke, description: s.description, score: score });
   }
 
   scored.sort(function(a, b) { return b.score - a.score; });

package/.claude/settings.json

@@ -108,16 +108,6 @@
           }
         ]
       },
-      {
-        "matcher": "Read",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs\" post-read",
-            "timeout": 4000
-          }
-        ]
-      },
       {
         "matcher": "mcp__monomind__monograph_.*",
         "hooks": [
@@ -200,11 +190,6 @@
             "command": "node \"$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs\" session-restore",
             "timeout": 15000
           },
-          {
-            "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/helpers/auto-memory-hook.mjs\" import",
-            "timeout": 8000
-          },
           {
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR/.claude/helpers/graphify-freshen.cjs\"",
@@ -242,11 +227,6 @@
     "Stop": [
       {
         "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/helpers/auto-memory-hook.mjs\" sync",
-            "timeout": 10000
-          },
           {
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR/.claude/helpers/event-logger.cjs\" stop",