@monoes/monomindcli 1.19.0 → 2.0.0

package/.claude/helpers/handlers/session-restore-handler.cjs

@@ -120,15 +120,92 @@ module.exports = {
     }
 
     // Bridge to @monomind/hooks compiled workers (GAP-001).
+    // Uses the shared hCtx._ensureHooksModule() (defined in hook-handler.cjs) so worker
+    // registration happens exactly once per process instead of being duplicated here —
+    // every other bridging handler (agent-start, pre-task, post-task, post-edit,
+    // session-end) calls the same lazy loader since each hook event is its own process.
     try {
-      var hooksModule = await import('@monomind/hooks');
-      if (hooksModule && hooksModule.initDefaultWorkers) {
-        await runWithTimeout(function() { return hooksModule.initDefaultWorkers(); }, '@monomind/hooks.initDefaultWorkers()');
+      var hooksModule = hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : await import('@monomind/hooks');
+      if (hooksModule) {
         hCtx._hooksModule = hooksModule;
         console.log('[INFO] @monomind/hooks workers initialized');
+
+        // Gate enforcement lives entirely in gates-handler.cjs (its own regex
+        // table, run on every PreToolUse). The @monomind/guidance package that
+        // used to compile gate configs here was removed.
+
+        // Fire SessionStart event so observability bus and other SessionStart hooks activate
+        if (hooksModule.executeHooks && hooksModule.HookEvent) {
+          try {
+            await runWithTimeout(function() {
+              return hooksModule.executeHooks(hooksModule.HookEvent.SessionStart, {
+                session: {
+                  id: String(hookInput.sessionId || hookInput.session_id || ''),
+                  startedAt: new Date(),
+                },
+              }, { continueOnError: true, timeout: 1500 });
+            }, '@monomind/hooks.SessionStart');
+          } catch (e2) { /* non-fatal */ }
+        }
       }
     } catch (e) { /* @monomind/hooks not compiled yet — skip */ }
 
+    // Refresh worker metrics once per session start — the statusline
+    // (.claude/helpers/statusline.cjs) reads .monomind/metrics/ddd-progress.json,
+    // route-handler.cjs and doctor read codebase-map/security-audit/performance/
+    // consolidation.json; the @monomind/hooks workers are never otherwise
+    // scheduled on the live hook path (the worker daemon that used to produce
+    // these files was deleted).
+    //
+    // Staleness gating keeps session start fast: the metrics-producing workers
+    // only run when their output file is missing or older than 6 hours (ddd is
+    // refreshed every session, as before). Each run is capped by runWithTimeout
+    // (1.5s) — on timeout the awaiting stops but the worker keeps running and
+    // flushes atomically via tmp+rename, so a slow worker never blocks session
+    // start and never leaves a partial file.
+    try {
+      var _metricsDir = path.join(CWD, '.monomind', 'metrics');
+      fs.mkdirSync(_metricsDir, { recursive: true });
+      var STALE_MS = 6 * 60 * 60 * 1000; // 6 hours
+      var _isStale = function(outFile) {
+        try {
+          var st = fs.statSync(path.join(_metricsDir, outFile));
+          return (Date.now() - st.mtimeMs) > STALE_MS;
+        } catch (e) { return true; } // missing → run
+      };
+      var _hooksWorkers = [
+        { factory: 'createDDDWorker',         file: 'worker-ddd.js',         out: 'ddd-progress.json',    always: true },
+        { factory: 'createMapWorker',         file: 'worker-map.js',         out: 'codebase-map.json' },
+        { factory: 'createAuditWorker',       file: 'worker-audit.js',       out: 'security-audit.json' },
+        { factory: 'createOptimizeWorker',    file: 'worker-optimize.js',    out: 'performance.json' },
+        { factory: 'createConsolidateWorker', file: 'worker-consolidate.js', out: 'consolidation.json' },
+      ];
+      var _hooksDistDir = path.join(CWD, 'packages', '@monomind', 'hooks', 'dist', 'workers');
+      for (var wi = 0; wi < _hooksWorkers.length; wi++) {
+        var _w = _hooksWorkers[wi];
+        if (!_w.always && !_isStale(_w.out)) continue;
+        try {
+          var _create = (hooksModule && typeof hooksModule[_w.factory] === 'function')
+            ? hooksModule[_w.factory] : null;
+          if (!_create) {
+            // Dev-repo fallback: bare '@monomind/hooks' does not resolve from .claude/helpers
+            // in the monorepo (pnpm workspace link lives under packages/@monomind/cli), so
+            // import the compiled worker directly by path.
+            var _wDist = path.join(_hooksDistDir, _w.file);
+            if (fs.existsSync(_wDist)) {
+              var _wMod = await import('file://' + _wDist);
+              if (_wMod && typeof _wMod[_w.factory] === 'function') _create = _wMod[_w.factory];
+            }
+          }
+          if (_create) {
+            var _wRun = _create(CWD);
+            // runWithTimeout caps each at 1.5s so a slow worker can never block session start.
+            await runWithTimeout(function() { return _wRun(); }, '@monomind/hooks.' + _w.factory);
+          }
+        } catch (e) { /* non-fatal — worker unavailable */ }
+      }
+    } catch (e) { /* non-fatal — hooks workers unavailable */ }
+
     // Context Persistence Auto-Restore
     try {
       var cpHook = await import('file://' + path.join(helpersDir, 'context-persistence-hook.mjs'));
@@ -275,46 +352,6 @@ module.exports = {
       } catch (e) {}
     } catch (e) { /* non-fatal */ }
 
-    // Daemon Auto-Start Check.
-    try {
-      var daemonPid = path.join(CWD, '.monomind', 'daemon.pid');
-      var daemonRunning = false;
-      if (fs.existsSync(daemonPid)) {
-        try {
-          var MAX_PID = 32; // 32 bytes — enough for any pid
-          if (fs.statSync(daemonPid).size <= MAX_PID) {
-            var pid = parseInt(fs.readFileSync(daemonPid, 'utf-8').trim(), 10);
-            if (Number.isInteger(pid) && pid > 0 && pid < 4194304) {
-              process.kill(pid, 0);
-              daemonRunning = true;
-            }
-          }
-        } catch (e) { /* pid stale */ }
-      }
-      if (!daemonRunning) {
-        var daemonCfg = {};
-        try {
-          var cfgPath = path.join(CWD, 'monomind.config.json');
-          var MAX_CFG = 256 * 1024; // 256 KiB
-          if (fs.existsSync(cfgPath) && fs.statSync(cfgPath).size <= MAX_CFG) daemonCfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8')).daemon || {};
-        } catch (e) {}
-        if (daemonCfg.autoStart) {
-          var spawn = require('child_process').spawn;
-          var daemonChild = spawn('npx', ['monomind', 'daemon', 'start'], {
-            cwd: CWD, detached: true, stdio: 'ignore'
-          });
-          daemonChild.on('error', function() {});
-          daemonChild.unref();
-          console.log('[DAEMON_AUTOSTART] Background daemon started (pid ' + daemonChild.pid + ')');
-        }
-        // Daemon not running + no autoStart: emit only if this project has a config
-        // (i.e. daemon was intentionally set up). Avoids noisy output in daemon-less projects.
-        else if (fs.existsSync(path.join(CWD, 'monomind.config.json'))) {
-          console.log('[DAEMON_STOPPED] Run `npx monomind daemon start` to enable background workers');
-        }
-      }
-    } catch (e) { /* non-fatal */ }
-
     // Token Usage — inject daily/monthly cost summary.
     try {
       var tokenTracker = require(path.join(helpersDir, 'token-tracker.cjs'));

package/.claude/helpers/handlers/task-handler.cjs

@@ -24,8 +24,10 @@ module.exports = {
     // - PromptVersioning experiments (unused feature)
     // - Monograph blast radius (already shown by post-edit hook on actual changes)
 
-    // Bridge to @monomind/hooks registry — fires Tasks 26 (PromptAssembler) and any other PreTask hooks
-    var _hooksModule = hCtx._hooksModule;
+    // Bridge to @monomind/hooks registry — fires Tasks 26 (PromptAssembler) and any other PreTask hooks.
+    // Each hook event runs in a fresh process, so hCtx._hooksModule set by session-restore in an
+    // earlier invocation is never visible here — must (re)load lazily via _ensureHooksModule().
+    var _hooksModule = hCtx._hooksModule || (hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null);
     if (_hooksModule && _hooksModule.executeHooks && _hooksModule.HookEvent) {
       try {
         await _hooksModule.executeHooks(_hooksModule.HookEvent.PreTask, {
@@ -81,8 +83,10 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    // Bridge to @monomind/hooks registry — fires Tasks 39 (SpecializationScorer) and any other PostTask hooks
-    var _hooksModule = hCtx._hooksModule;
+    // Bridge to @monomind/hooks registry — fires Tasks 39 (SpecializationScorer) and any other PostTask hooks.
+    // Each hook event runs in a fresh process, so hCtx._hooksModule set by session-restore in an
+    // earlier invocation is never visible here — must (re)load lazily via _ensureHooksModule().
+    var _hooksModule = hCtx._hooksModule || (hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null);
     if (_hooksModule && _hooksModule.executeHooks && _hooksModule.HookEvent) {
       try {
         await _hooksModule.executeHooks(_hooksModule.HookEvent.PostTask, {

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

@@ -15,11 +15,24 @@
  * 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.
+ *    optionally, bridged at six lifecycle events: SessionStart (restore),
+ *    PreTask, PostTask, PostEdit, SessionEnd, and AgentSpawn (agent-start).
+ *    The CJS handlers in system (1) are the authoritative dispatch path;
+ *    system (2) provides optional enrichment when the package is
+ *    installed and built.
+ *
+ *    IMPORTANT: each hook event is dispatched as its OWN fresh `node`
+ *    process (Claude Code spawns one invocation per event — this file
+ *    does not stay resident across events). So the @monomind/hooks
+ *    module, and anything it registers (trace collector spans, episode
+ *    binner, etc.), cannot be set up once and reused across events —
+ *    every bridging handler must call hCtx._ensureHooksModule() itself,
+ *    which lazily imports the package AND calls initDefaultWorkers() in
+ *    that process before firing executeHooks(). Cross-event state (e.g.
+ *    correlating a PreTask span to its matching PostTask) is NOT
+ *    possible via in-memory maps for this reason; only handlers/hooks
+ *    that persist state to disk (like the daemon workers under
+ *    .monomind/metrics/) can meaningfully bridge across separate events.
  */
 
 const path = require('path');
@@ -88,9 +101,43 @@ const session = safeRequire(path.join(helpersDir, 'session.cjs'));
 const memory = safeRequire(path.join(helpersDir, 'memory.cjs'));
 const intelligence = safeRequire(path.join(helpersDir, 'intelligence.cjs'));
 
-// Module-level reference to @monomind/hooks — populated at session-restore,
-// then used by pre-task / post-task to bridge into the hook registry (Tasks 26, 39).
+// Module-level reference to @monomind/hooks — populated lazily via
+// _ensureHooksModule(). NOTE: hook-handler.cjs runs as a fresh `node` process
+// per hook event (Claude Code spawns one invocation per event, it does not
+// keep the process alive across events), so a value set during one event
+// (e.g. session-restore) is NOT visible to a later event's process (e.g.
+// pre-task). Each handler that needs the bridge MUST call
+// hCtx._ensureHooksModule() itself rather than reading hCtx._hooksModule
+// directly, or the bridge silently no-ops.
 let _hooksModule = null;
+let _hooksModuleLoadAttempted = false;
+async function _ensureHooksModule() {
+  if (_hooksModule) return _hooksModule;
+  if (_hooksModuleLoadAttempted) return null; // already tried+failed this process
+  _hooksModuleLoadAttempted = true;
+  // 1) Bare specifier — works when @monomind/hooks is installed/linked in a
+  //    node_modules reachable from this file (e.g. an end-user install).
+  try {
+    _hooksModule = await import('@monomind/hooks');
+  } catch (e) {
+    _hooksModule = null;
+  }
+  // 2) Dev-repo fallback — in the monorepo the pnpm workspace link lives under
+  //    packages/@monomind/cli/node_modules, NOT at the repo root, so the bare
+  //    specifier never resolves from .claude/helpers. Import the compiled dist
+  //    entry directly by path (same pattern as session-restore-handler.cjs).
+  if (!_hooksModule) {
+    try {
+      const _distIndex = path.join(CWD, 'packages', '@monomind', 'hooks', 'dist', 'index.js');
+      if (fs.existsSync(_distIndex)) {
+        _hooksModule = await import('file://' + _distIndex);
+      }
+    } catch (e) {
+      _hooksModule = null; // not built — bridge stays a fail-soft no-op
+    }
+  }
+  return _hooksModule;
+}
 
 // ── Intelligence timeout protection (fixes #1530, #1531) ───────────────────
 var INTELLIGENCE_TIMEOUT_MS = 1500;
@@ -212,9 +259,11 @@ var hCtx = {
   intelligence: intelligence,
   getLearningService: getLearningService,
   isSimpleCommand: isSimpleCommand,
-  // Module-level singleton (populated by session-restore handler)
+  // Module-level singleton (populated by session-restore handler, or lazily
+  // via _ensureHooksModule() — required since each hook event is a fresh process).
   get _hooksModule() { return _hooksModule; },
   set _hooksModule(v) { _hooksModule = v; },
+  _ensureHooksModule: _ensureHooksModule,
   // Utility functions
   _recordRecentEdit: _recordRecentEdit,
   _getRecentEdits: _getRecentEdits,
@@ -292,9 +341,9 @@ const handlers = {
     await h.handle(hCtx, 'auto');
   },
 
-  'agent-start': () => {
+  'agent-start': async () => {
     const h = require('./handlers/agent-start-handler.cjs');
-    h.handle(hCtx);
+    await h.handle(hCtx);
   },
 
   'adr-draft': () => {
@@ -757,9 +806,13 @@ if (command && handlers[command]) {
   }
 }
 
-main().catch(function(e) {
-  console.log('[WARN] Hook handler error: ' + e.message);
-}).finally(function() {
-  // Use process.exitCode if a gate set it (exit 2 = block), otherwise clean exit
-  process.exit(process.exitCode || 0);
-});
+// Only run when executed directly (every real hook event spawns this file as a
+// process). A require() — e.g. from tests verifying it loads — must not exit.
+if (require.main === module) {
+  main().catch(function(e) {
+    console.log('[WARN] Hook handler error: ' + e.message);
+  }).finally(function() {
+    // Use process.exitCode if a gate set it (exit 2 = block), otherwise clean exit
+    process.exit(process.exitCode || 0);
+  });
+}

package/.claude/helpers/intelligence.cjs

@@ -156,6 +156,36 @@ function consolidate() {
   // 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 = [];
@@ -174,19 +204,69 @@ function consolidate() {
         // 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
+      // 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(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,
+        content: 'Successful edit pattern: ' + uniquePaths.map(function(cp) { return path.basename(cp); }).join(', '),
+        summary: summary,
+        confidence: confidence,
         files: uniquePaths,
         ts: outcome.ts || Date.now(),
       });
@@ -198,10 +278,21 @@ function consolidate() {
     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++) {
-      if (!existingIds.has(newStoreEntries[j].id)) {
-        store.push(newStoreEntries[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) {
@@ -211,7 +302,7 @@ function consolidate() {
     try {
       fs.writeFileSync(STORE_FILE, JSON.stringify(store, null, 2), 'utf-8');
     } catch (_) {}
-    count += newStoreEntries.length;
+    count += addedCount;
   }
 
   // Rotate outcomes: keep last 500 lines to prevent unbounded growth
@@ -221,7 +312,7 @@ function consolidate() {
     } catch (_) {}
   }
 
-  return { entries: count, edges: 0, newEntries: newStoreEntries.length };
+  return { entries: count, edges: 0, newEntries: addedCount || 0 };
 }
 
 // ── feedback ──────────────────────────────────────────────────────────────────

package/.claude/helpers/router.cjs

@@ -171,9 +171,6 @@ var SKILLS = [
   { 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'] },
@@ -182,6 +179,82 @@ var SKILLS = [
     _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;
@@ -215,7 +288,7 @@ 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,
@@ -237,7 +310,7 @@ function routeTask(prompt) {
     if (slug === 'coder' && hasStrongSkill) continue;
     var pattern = _ROUTING_PATTERNS[slug];
     if (pattern && pattern.test(safePrompt)) {
-      var confidence = TASK_CONFIDENCES[slug] || 0.75;
+      var confidence = applyFeedbackWeight(slug, TASK_CONFIDENCES[slug] || 0.75);
       return {
         agent: TASK_AGENTS[slug],
         agentSlug: slug,