monomind 1.18.15 → 2.0.0

package/packages/@monomind/cli/.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;
 
-  var top = matches[0];
-  return '[INTELLIGENCE] ' + (top.summary || top.content || top.id || 'context match');
+  // 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 = 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,194 @@ 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 (_) {}
+
+  // Load session episodes (written by session-handler.cjs into the same
+  // .monomind dir) so patterns can carry real semantic content — the user's
+  // prompt snippet and commit subjects — instead of just file basenames.
+  var episodes = [];
+  var episodeLines = safeReadLines(path.join(CWD, '.monomind', 'episodic', 'episodes.jsonl'));
+  for (var epi = 0; epi < episodeLines.length; epi++) {
+    try { episodes.push(JSON.parse(episodeLines[epi])); } catch (_) {}
+  }
+
+  // Build-noise artifacts that say nothing about what the task actually was.
+  function isNoisePath(p) {
+    var base = path.basename(p);
+    if (base === 'tsconfig.tsbuildinfo' || base === 'coverage.json') return true;
+    if (/\.map$/.test(base)) return true;
+    if (/(^|\/)dist\//.test(p)) return true;
+    return false;
+  }
+
+  // Nearest episode whose end time is within 30 minutes of the outcome.
+  function findEpisodeNear(ts) {
+    var best = null;
+    var bestDelta = 30 * 60 * 1000;
+    for (var ki = 0; ki < episodes.length; ki++) {
+      var cand = episodes[ki];
+      var delta = Math.abs((cand.endedAt || 0) - ts);
+      if (delta <= bestDelta) { bestDelta = delta; best = cand; }
+    }
+    return best;
+  }
+
+  // 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, dropping build-noise artifacts (tsbuildinfo,
+      // sourcemaps, coverage output, dist/ bundles) so the pattern describes
+      // real source work.
+      var uniquePaths = [];
+      var pathSeen = {};
+      for (var pi = 0; pi < editPaths.length; pi++) {
+        var p = String(editPaths[pi]);
+        if (isNoisePath(p)) continue;
+        if (!pathSeen[p]) { pathSeen[p] = true; uniquePaths.push(p); }
+      }
+      if (uniquePaths.length === 0) continue;
+      var baseNames = uniquePaths.slice(0, 5).map(function(bp) { return path.basename(bp); });
+
+      // Prefer real semantic content for the summary: outcome.context (rare —
+      // only set when getContext matched in the same process), else the
+      // matching episode's prompt snippet + first commit subject.
+      var summary = outcome.context || null;
+      var hasCommits = false;
+      var ep = findEpisodeNear(outcome.ts || Date.now());
+      if (ep && ep.summary) {
+        // Episode summaries are newline-joined parts written by
+        // session-handler: prompt snippet, "Commits: ...", "Modified: ...",
+        // "Outcome: ...".
+        var epParts = String(ep.summary).split('\n');
+        var promptSnippet = '';
+        var commitSubject = '';
+        for (var si = 0; si < epParts.length; si++) {
+          var part = epParts[si].trim();
+          if (!part) continue;
+          if (part.indexOf('Commits: ') === 0) {
+            if (!commitSubject) commitSubject = part.slice(9).split(';')[0].trim();
+          } else if (part.indexOf('Modified: ') !== 0 && part.indexOf('Outcome: ') !== 0 && !promptSnippet) {
+            promptSnippet = part.slice(0, 160);
+          }
+        }
+        hasCommits = commitSubject.length > 0;
+        if (!summary) {
+          var bits = [];
+          if (promptSnippet) bits.push(promptSnippet);
+          if (commitSubject) bits.push('commit: ' + commitSubject);
+          if (bits.length > 0) summary = bits.join(' — ') + ' (files: ' + baseNames.join(', ') + ')';
+        }
+      }
+      if (!summary) summary = 'Successful task editing ' + uniquePaths.length + ' files: ' + baseNames.join(', ');
+
+      // Confidence from evidence rather than a hardcoded constant:
+      //   0.5 base for any successful outcome
+      //   +0.2 when commits back the session (strongest success signal)
+      //   +0.1 when test files were part of the edit set
+      var confidence = 0.5;
+      if (hasCommits) confidence += 0.2;
+      var touchedTests = uniquePaths.some(function(tp) {
+        return /(^|\/)(tests?|__tests__)\//.test(tp) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(tp);
+      });
+      if (touchedTests) confidence += 0.1;
+      confidence = Math.round(confidence * 100) / 100; // avoid FP artifacts like 0.7999…
+
+      newStoreEntries.push({
+        id: 'auto-' + (outcome.ts || Date.now()) + '-' + i,
+        type: 'pattern',
+        content: 'Successful edit pattern: ' + uniquePaths.map(function(cp) { return path.basename(cp); }).join(', '),
+        summary: summary,
+        confidence: confidence,
+        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; }));
+    // Skip near-identical patterns: same summary text or same file set as an
+    // entry already in the store (or one added earlier in this batch).
+    var fileSetKey = function(e) { return (e.files || []).slice().sort().join('|'); };
+    var seenSummaries = new Set(store.map(function(e) { return e && e.summary; }));
+    var seenFileSets = new Set(store.filter(function(e) { return e && Array.isArray(e.files) && e.files.length > 0; }).map(fileSetKey));
+    var addedCount = 0;
+    for (var j = 0; j < newStoreEntries.length; j++) {
+      var ne = newStoreEntries[j];
+      if (existingIds.has(ne.id)) continue;
+      if (seenSummaries.has(ne.summary)) continue;
+      if (ne.files && ne.files.length > 0 && seenFileSets.has(fileSetKey(ne))) continue;
+      store.push(ne);
+      seenSummaries.add(ne.summary);
+      if (ne.files && ne.files.length > 0) seenFileSets.add(fileSetKey(ne));
+      addedCount++;
+    }
+    // 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 += addedCount;
+  }
+
+  // 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: addedCount || 0 };
 }
 
 // ── 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 +363,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 +389,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/packages/@monomind/cli/.claude/helpers/learning-service.mjs

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

package/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.claude/helpers/router.cjs

@@ -159,12 +159,102 @@ 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: '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'] },
 ];
 
+// ── Feedback weight system ────────────────────────────────────────────────────
+// Reads routing-feedback.jsonl (written by session-handler at session-end) and
+// computes per-agent success rates. Adjusts routing confidence by up to +/-0.10
+// so agents with proven track records get a slight boost and poor performers get
+// dampened. Cached with a 60-second TTL to avoid repeated disk reads.
+
+var _feedbackWeightsCache = null;
+var _feedbackWeightsCacheTs = 0;
+var FEEDBACK_TTL_MS = 60000;
+
+function loadFeedbackWeights() {
+  var now = Date.now();
+  if (_feedbackWeightsCache && (now - _feedbackWeightsCacheTs) < FEEDBACK_TTL_MS) {
+    return _feedbackWeightsCache;
+  }
+  var weights = {};
+  try {
+    var fs = require('fs');
+    var path = require('path');
+    var cwd = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    var feedbackPath = path.join(cwd, '.monomind', 'routing-feedback.jsonl');
+    var MAX_SIZE = 512 * 1024;
+    if (!fs.existsSync(feedbackPath)) {
+      _feedbackWeightsCache = weights;
+      _feedbackWeightsCacheTs = now;
+      return weights;
+    }
+    var stat = fs.statSync(feedbackPath);
+    if (stat.size > MAX_SIZE) {
+      _feedbackWeightsCache = weights;
+      _feedbackWeightsCacheTs = now;
+      return weights;
+    }
+    var lines = fs.readFileSync(feedbackPath, 'utf-8').trim().split('\n').filter(Boolean);
+    // Use last 200 entries for weight calculation
+    var recent = lines.slice(-200);
+    var agentStats = {};
+    for (var i = 0; i < recent.length; i++) {
+      try {
+        var entry = JSON.parse(recent[i]);
+        var agent = entry.suggestedAgent;
+        if (!agent) continue;
+        // Skip no-evidence records (sessionSuccess null/missing) — they carry no signal
+        if (typeof entry.intelligenceFeedback !== 'boolean') continue;
+        if (!agentStats[agent]) agentStats[agent] = { total: 0, successes: 0 };
+        agentStats[agent].total++;
+        if (entry.intelligenceFeedback === true) agentStats[agent].successes++;
+      } catch (e) {}
+    }
+    // Compute weight adjustments: agents with >= 5 data points get a weight
+    // successRate > 0.7 → positive boost (up to +0.10)
+    // successRate < 0.4 → negative dampen (down to -0.10)
+    // In between → neutral (0)
+    for (var ag in agentStats) {
+      var s = agentStats[ag];
+      if (s.total < 5) continue;
+      var rate = s.successes / s.total;
+      if (rate > 0.7) {
+        weights[ag] = Math.min(0.10, (rate - 0.7) * 0.33);
+      } else if (rate < 0.4) {
+        weights[ag] = Math.max(-0.10, (rate - 0.4) * 0.25);
+      }
+    }
+  } catch (e) { /* non-fatal */ }
+  _feedbackWeightsCache = weights;
+  _feedbackWeightsCacheTs = now;
+  return weights;
+}
+
+function applyFeedbackWeight(agentSlug, baseConfidence) {
+  var weights = loadFeedbackWeights();
+  var adj = weights[agentSlug] || weights[TASK_AGENTS[agentSlug]] || 0;
+  if (adj === 0) return baseConfidence;
+  return Math.max(0, Math.min(1.0, baseConfidence + adj));
+}
+
 // ── Utilities ─────────────────────────────────────────────────────────────────
 
 var MAX_PROMPT = 2000;
@@ -188,6 +278,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) {
@@ -195,22 +288,29 @@ function routeTask(prompt) {
     return {
       agent: topExtra.name,
       agentSlug: topExtra.slug,
-      confidence: 0.80,
+      confidence: applyFeedbackWeight(topExtra.slug, 0.80),
       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);
+      var confidence = applyFeedbackWeight(slug, TASK_CONFIDENCES[slug] || 0.75);
       return {
         agent: TASK_AGENTS[slug],
         agentSlug: slug,
@@ -232,7 +332,7 @@ function routeTask(prompt) {
     reason: 'Default routing — no strong keyword match',
     semanticRouting: false,
     specificAgents: [],
-    skillMatches: [],
+    skillMatches: skills,
     extrasMatches: [],
   };
 }
@@ -243,13 +343,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; });