@monoes/monomindcli 1.10.29 → 1.10.31

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

@@ -0,0 +1,348 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'session-restore' hook event.
+// Receives hCtx from dispatcher. See route-handler.cjs for hCtx field docs.
+
+const path = require('path');
+const fs = require('fs');
+const { injectGodNodesContext } = require('../utils/monograph.cjs');
+
+module.exports = {
+  handleRestore: async function(hCtx) {
+    var hookInput = hCtx.hookInput;
+    var session = hCtx.session;
+    var intelligence = hCtx.intelligence;
+    var CWD = hCtx.CWD;
+    var helpersDir = hCtx.helpersDir;
+    var runWithTimeout = hCtx.runWithTimeout;
+    var _autoIndexKnowledge = hCtx._autoIndexKnowledge;
+    var _buildKnowledgeSearchFn = hCtx._buildKnowledgeSearchFn;
+    var getMonographSuggestions = hCtx.getMonographSuggestions;
+
+    // Session restore / start
+    try {
+      if (session) {
+        var existing = session.restore && session.restore();
+        if (!existing) {
+          session.start && session.start();
+        }
+      } else {
+        console.log('[OK] Session restored: session-' + Date.now());
+      }
+    } catch (e) { console.log('[WARN] Session restore failed: ' + e.message); }
+
+    // Stale helper detection — warn when project helpers drift from the bundled npm copy.
+    // Skip when running inside the monomind dev repo itself: local helpers ARE the
+    // source of truth there, so any diff vs. the npm global install is expected.
+    try {
+      var _isDevRepo = fs.existsSync(path.join(CWD, 'packages', '@monomind', 'cli', 'package.json'));
+      if (!_isDevRepo) {
+        var crypto = require('crypto');
+        function _findBundledHelpers() {
+          var helperPaths = [
+            path.join(helpersDir),
+            path.join(CWD, 'node_modules', 'monomind', '.claude', 'helpers'),
+            path.join(CWD, 'node_modules', '@monoes', 'monomindcli', '.claude', 'helpers'),
+          ];
+          try {
+            var globalRoot = require('child_process')
+              .execSync('npm root -g 2>/dev/null', { encoding: 'utf-8', timeout: 2000 })
+              .trim();
+            if (globalRoot) {
+              helperPaths.push(path.join(globalRoot, 'monomind', '.claude', 'helpers'));
+              helperPaths.push(path.join(globalRoot, '@monoes', 'monomindcli', '.claude', 'helpers'));
+            }
+          } catch (_) {}
+          for (var i = 0; i < helperPaths.length; i++) {
+            if (fs.existsSync(path.join(helperPaths[i], 'hook-handler.cjs')) &&
+                helperPaths[i] !== path.join(CWD, '.claude', 'helpers')) {
+              return helperPaths[i];
+            }
+          }
+          return null;
+        }
+
+        var bundledDir = _findBundledHelpers();
+        if (bundledDir) {
+          var helpersToCheck = ['hook-handler.cjs', 'statusline.cjs'];
+          var stale = [];
+          for (var hi = 0; hi < helpersToCheck.length; hi++) {
+            var hName = helpersToCheck[hi];
+            var localF   = path.join(CWD, '.claude', 'helpers', hName);
+            var bundledF = path.join(bundledDir, hName);
+            if (!fs.existsSync(localF) || !fs.existsSync(bundledF)) continue;
+            try {
+              var hashL = crypto.createHash('sha256').update(fs.readFileSync(localF)).digest('hex');
+              var hashB = crypto.createHash('sha256').update(fs.readFileSync(bundledF)).digest('hex');
+              if (hashL !== hashB) stale.push(hName);
+            } catch (_) {}
+          }
+          if (stale.length > 0) {
+            console.log('[STALE_HELPERS] Project helpers differ from bundled version: ' + stale.join(', '));
+            console.log('  Run `npx monomind@latest init upgrade` to refresh and pick up the latest features.');
+          }
+        }
+      }
+    } catch (e) { /* non-fatal */ }
+
+    // Initialize intelligence — respects monomind.neural.enabled kill switch.
+    var neuralEnabled = true;
+    try {
+      var settingsPath = path.join(CWD, '.claude', 'settings.json');
+      if (fs.existsSync(settingsPath)) {
+        var settingsData = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        if (settingsData.monomind && settingsData.monomind.neural && settingsData.monomind.neural.enabled === false) {
+          neuralEnabled = false;
+          console.log('[NEURAL] Disabled via monomind.neural.enabled=false');
+        }
+      }
+    } catch (e) { /* non-fatal */ }
+    if (neuralEnabled && intelligence && intelligence.init) {
+      var initResult = await runWithTimeout(function() { return intelligence.init(); }, 'intelligence.init()');
+      if (initResult && initResult.nodes > 0) {
+        console.log('[INTELLIGENCE] Loaded ' + initResult.nodes + ' patterns, ' + initResult.edges + ' edges');
+      }
+    }
+
+    // Bridge to @monomind/hooks compiled workers (GAP-001).
+    try {
+      var hooksModule = await import('@monomind/hooks');
+      if (hooksModule && hooksModule.initDefaultWorkers) {
+        await runWithTimeout(function() { return hooksModule.initDefaultWorkers(); }, '@monomind/hooks.initDefaultWorkers()');
+        hCtx._hooksModule = hooksModule;
+        console.log('[INFO] @monomind/hooks workers initialized');
+      }
+    } catch (e) { /* @monomind/hooks not compiled yet — skip */ }
+
+    // Context Persistence Auto-Restore
+    try {
+      var cpHook = await import('file://' + path.join(helpersDir, 'context-persistence-hook.mjs'));
+      var restoreFn = (cpHook && cpHook.restore) || (cpHook && cpHook.default && cpHook.default.restore);
+      if (restoreFn) {
+        var restored = await runWithTimeout(function() { return restoreFn(); }, 'context-persistence.restore()');
+        if (restored && restored.turns > 0) {
+          console.log('[CONTEXT_RESTORED] ' + restored.turns + ' turns from previous session');
+        }
+      }
+    } catch (e) { /* non-fatal */ }
+
+    // AgentKnowledgeBase — preload shared knowledge context on session restore.
+    try {
+      var knowledgeDir = path.join(CWD, '.monomind', 'knowledge');
+      var indexed = _autoIndexKnowledge(knowledgeDir);
+      if (indexed > 0) {
+        console.log('[KNOWLEDGE_INDEXED] ' + indexed + ' chunks written from project sources');
+      }
+
+      var kSearchFn = _buildKnowledgeSearchFn(knowledgeDir);
+      var sessionCtx = (hookInput && (hookInput.sessionId || hookInput.session_id))
+        ? 'session context: ' + (hookInput.sessionId || hookInput.session_id)
+        : 'project context general';
+
+      var memoryMod = null;
+      try { memoryMod = await import('@monomind/memory'); } catch (e) {}
+
+      if (memoryMod && memoryMod.KnowledgeStore && memoryMod.KnowledgeRetriever) {
+        var kStore = new memoryMod.KnowledgeStore(knowledgeDir);
+        var kRetriever = new memoryMod.KnowledgeRetriever(kSearchFn, kStore);
+        var kResult = await kRetriever.retrieveForTask('shared', sessionCtx, 5);
+        if (kResult.excerpts.length > 0) {
+          console.log('[KNOWLEDGE_PRELOADED] ' + kResult.excerpts.length + ' excerpts (KnowledgeRetriever)');
+        }
+      } else {
+        var directResults = await kSearchFn(sessionCtx, { namespace: 'knowledge:shared', limit: 5, minScore: 0.3 });
+        if (directResults.length > 0) {
+          console.log('[KNOWLEDGE_PRELOADED] ' + directResults.length + ' excerpts (direct keyword search)');
+        }
+      }
+    } catch (e) { /* non-fatal */ }
+
+    // Monograph Context Injection — delegates to shared helper in utils/monograph.cjs.
+    injectGodNodesContext(CWD);
+
+    // SharedInstructions — auto-load .agents/shared_instructions.md (hard limit: 1500 chars).
+    var SI_CHAR_LIMIT = 1500;
+    var applySharedInstrLimit = function(content, source) {
+      if (content.length > SI_CHAR_LIMIT) {
+        console.warn('[SHARED_INSTRUCTIONS_OVERLIMIT] ' + content.length + ' chars exceeds limit of ' + SI_CHAR_LIMIT +
+          ' — truncating. Edit ' + source + ' to stay under limit.');
+        return content.slice(0, SI_CHAR_LIMIT) + '\n… [truncated — file exceeds ' + SI_CHAR_LIMIT + ' char limit]';
+      }
+      return content;
+    };
+    try {
+      var siMod = await import('file://' + path.join(CWD, 'packages/@monomind/cli/dist/src/agents/shared-instructions-loader.js'));
+      var loader = siMod.sharedInstructionsLoader || (siMod.SharedInstructionsLoader ? new siMod.SharedInstructionsLoader() : null);
+      if (loader) {
+        var sharedInstr = loader.getSharedInstructions(CWD);
+        if (sharedInstr) {
+          var sharedInstrSafe = applySharedInstrLimit(sharedInstr, '.agents/shared_instructions.md');
+          console.log('[SHARED_INSTRUCTIONS] Loaded ' + sharedInstrSafe.length + ' chars from .agents/shared_instructions.md');
+          console.log(sharedInstrSafe);
+        }
+      }
+    } catch (e) {
+      try {
+        var siPath = path.join(CWD, '.agents', 'shared_instructions.md');
+        if (fs.existsSync(siPath)) {
+          var siContent = fs.readFileSync(siPath, 'utf-8');
+          var siContentSafe = applySharedInstrLimit(siContent, siPath);
+          console.log('[SHARED_INSTRUCTIONS] Loaded ' + siContentSafe.length + ' chars from .agents/shared_instructions.md');
+          console.log(siContentSafe);
+        }
+      } catch (e2) { /* non-fatal */ }
+    }
+
+    // Memory Palace — inject L0 (identity) + L1 (essential story) into session context.
+    try {
+      var palace = require(path.join(helpersDir, 'memory-palace.cjs'));
+      var palaceContext = palace.wakeUp(CWD);
+      if (palaceContext) {
+        console.log(palaceContext);
+      }
+    } catch (e) { /* non-fatal — palace not available */ }
+
+    // Periodic Update Check (once per day).
+    try {
+      var updateCheckFile = path.join(CWD, '.monomind', 'last-update-check.json');
+      var shouldCheck = true;
+      if (fs.existsSync(updateCheckFile)) {
+        var lastCheck = JSON.parse(fs.readFileSync(updateCheckFile, 'utf-8'));
+        var hoursSince = (Date.now() - new Date(lastCheck.timestamp).getTime()) / (1000 * 60 * 60);
+        if (hoursSince < 24) shouldCheck = false;
+      }
+      if (shouldCheck) {
+        fs.mkdirSync(path.join(CWD, '.monomind'), { recursive: true });
+        fs.writeFileSync(updateCheckFile, JSON.stringify({ timestamp: new Date().toISOString() }), 'utf-8');
+        try {
+          var localPkg = path.join(CWD, 'packages/@monomind/cli/package.json');
+          if (fs.existsSync(localPkg)) {
+            var localVer = JSON.parse(fs.readFileSync(localPkg, 'utf-8')).version;
+            if (localVer) {
+              var spawnFn = require('child_process').spawn;
+              var child = spawnFn('npm', ['view', '@monomind/cli', 'version'], {
+                stdio: ['ignore', 'pipe', 'ignore'],
+                shell: false,
+              });
+              child.on('error', function() {});
+              var out = '';
+              child.stdout.on('data', function(d) { out += d; });
+              child.on('close', function() {
+                var current = out.trim();
+                var pendingUpdatePath = path.join(CWD, '.monomind', 'pending-update.json');
+                if (current && current !== localVer) {
+                  try {
+                    fs.writeFileSync(
+                      pendingUpdatePath,
+                      JSON.stringify({ from: localVer, to: current, checkedAt: new Date().toISOString() }),
+                      'utf-8'
+                    );
+                  } catch (e2) {}
+                } else if (current) {
+                  try { fs.unlinkSync(pendingUpdatePath); } catch (e2) {}
+                }
+              });
+              child.unref();
+            }
+          }
+        } catch (e) { /* npm not available */ }
+      }
+      try {
+        var pendingUpdate = path.join(CWD, '.monomind', 'pending-update.json');
+        if (fs.existsSync(pendingUpdate)) {
+          var upd = JSON.parse(fs.readFileSync(pendingUpdate, 'utf-8'));
+          if (upd && upd.from && upd.to && upd.from !== upd.to) {
+            console.log('[UPDATE_AVAILABLE] @monomind/cli ' + upd.from + ' → ' + upd.to + ' (run: npx monomind update)');
+          }
+        }
+      } 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 pid = parseInt(fs.readFileSync(daemonPid, 'utf-8').trim(), 10);
+          process.kill(pid, 0);
+          daemonRunning = true;
+        } catch (e) { /* pid stale */ }
+      }
+      if (!daemonRunning) {
+        var daemonCfg = {};
+        try {
+          var cfgPath = path.join(CWD, 'monomind.config.json');
+          if (fs.existsSync(cfgPath)) 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 + ')');
+        } else {
+          console.log('[DAEMON_STOPPED] Background daemon is not running. To auto-start, set daemon.autoStart=true in monomind.config.json or run: npx monomind daemon start');
+        }
+      }
+    } catch (e) { /* non-fatal */ }
+
+    // Token Usage — inject daily/monthly cost summary.
+    try {
+      var tokenTracker = require(path.join(helpersDir, 'token-tracker.cjs'));
+      var tokenSummary = tokenTracker.quickSummary();
+      if (tokenSummary) {
+        console.log(tokenSummary);
+      }
+      try {
+        var tokenData = tokenTracker.quickSummaryData();
+        if (tokenData) {
+          var metricsDir = path.join(CWD, '.monomind', 'metrics');
+          if (!fs.existsSync(metricsDir)) fs.mkdirSync(metricsDir, { recursive: true });
+          tokenData.cachedAt = new Date().toISOString();
+          fs.writeFileSync(path.join(metricsDir, 'token-summary.json'), JSON.stringify(tokenData), 'utf-8');
+        }
+      } catch (_) { /* ignore cache write failure */ }
+    } catch (e) { /* non-fatal — token tracker not available */ }
+
+    // Registry Surfacing (SR-001) — show agent count.
+    try {
+      var regPath = path.join(CWD, '.monomind', 'registry.json');
+      if (fs.existsSync(regPath)) {
+        var reg = JSON.parse(fs.readFileSync(regPath, 'utf-8'));
+        var agentCount = (reg.agents || []).length;
+        if (agentCount > 0) {
+          console.log('[REGISTRY] ' + agentCount + ' agents available in registry');
+        }
+      }
+    } catch (e) { /* non-fatal */ }
+
+    // Monomind Control UI Status.
+    try {
+      var http = require('http');
+      var controlPort = 4242;
+      var req = http.get('http://localhost:' + controlPort + '/', function(res) {
+        if (res.statusCode === 200) {
+          console.log('[CONTROL_UI] UP — http://localhost:' + controlPort);
+        }
+        res.resume();
+      });
+      req.on('error', function() {
+        console.log('[CONTROL_UI] offline — run: npx monomind mcp start');
+      });
+      req.setTimeout(800, function() { req.destroy(); });
+    } catch (e) { /* non-fatal */ }
+
+    // Worker Queue Resume (SR-003).
+    try {
+      var dispatchDir = path.join(CWD, '.monomind', 'worker-dispatch');
+      if (fs.existsSync(dispatchDir)) {
+        var pendingFiles = fs.readdirSync(dispatchDir).filter(function(f) { return f.startsWith('pending-'); });
+        if (pendingFiles.length > 0) {
+          console.log('[WORKER_RESUME] ' + pendingFiles.length + ' worker dispatch(es) pending from prior session');
+        }
+      }
+    } catch (e) { /* non-fatal */ }
+  },
+};

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

@@ -0,0 +1,329 @@
+'use strict';
+// Extracted from hook-handler.cjs — receives hCtx from dispatcher.
+// Handles 'pre-task' and 'post-task' hook events.
+// See route-handler.cjs for full hCtx field documentation.
+
+const path = require('path');
+const fs = require('fs');
+
+module.exports = {
+  handlePreTask: async function(hCtx) {
+    var hookInput = hCtx.hookInput;
+    var prompt = hCtx.prompt;
+    var router = hCtx.router;
+    var session = hCtx.session;
+    var CWD = hCtx.CWD;
+
+    if (session && session.metric) {
+      try { session.metric('tasks'); } catch (e) { /* no active session */ }
+    }
+
+    // ── Task 27: PerRunModelTier — inline complexity scoring ───────────────
+    var taskStr = typeof prompt === 'string' ? prompt : '';
+    if (taskStr) {
+      var score = 50;
+      var lower = taskStr.toLowerCase();
+      var words = taskStr.trim().split(/\s+/).length;
+      if (words < 20) score -= 20;
+      if (words > 100) score += 20;
+      if (words > 200) score += 10;
+      var highKw = ['architecture','distributed','security audit','cve','consensus','fault-tolerant','migrate','refactor across','orchestrat','design system','database schema','performance optim','threat model','encryption','zero-knowledge'];
+      var lowKwRe = /\b(format|list|rename|sort|typo|lint|log|comment|print|echo|delete unused|remove import)\b/i;
+      if (highKw.some(function(k) { return lower.includes(k); })) score += 10;
+      if (lowKwRe.test(lower)) score -= 10;
+      if (/(?:step\s*\d|first[\s,].*then[\s,]|phase\s*\d)/i.test(taskStr)) score += 10;
+      if (/```[\s\S]*?```/.test(taskStr) || /\b[\w.-]+\/[\w./-]+\b/.test(taskStr)) score += 5;
+      score = Math.max(0, Math.min(100, score));
+      var tier = score < 30 ? 'haiku' : score > 70 ? 'opus' : 'sonnet';
+      console.log('[TASK_MODEL_RECOMMENDATION] Use model="' + tier + '" (complexity=' + score + ')');
+    }
+    // Task 06: AutoRetry — signal retry policy only if coordinator path is active
+    if (hookInput.swarmCoordinator || hookInput.coordinator || hookInput.useRetry) {
+      console.log('[AUTO_RETRY_ENABLED] maxAttempts=3 strategy=exponential-backoff backoffMs=1000');
+    }
+
+    if (router && prompt) {
+      var routeFn = router.routeTaskSemantic || router.routeTask;
+      var result = await Promise.resolve(routeFn(prompt));
+      console.log('[INFO] Task routed to: ' + result.agent + ' (confidence: ' + result.confidence + ')');
+    } else {
+      console.log('[OK] Task started');
+    }
+
+    // Task 24: PromptVersioning — resolve prompt variant before agent spawn
+    try {
+      var memMod = await import('@monomind/memory');
+      if (memMod && memMod.PromptVersionStore) {
+        var pvStore = new memMod.PromptVersionStore(path.join(CWD, '.monomind', 'prompt-versions'));
+        var pvMod = await import('file://' + path.join(CWD, 'packages/@monomind/cli/dist/src/agents/prompt-experiment.js'));
+        if (pvMod && pvMod.PromptExperimentRouter) {
+          var pvRouter = new pvMod.PromptExperimentRouter(pvStore);
+          var agentSlug24 = hookInput.agentSlug || hookInput.agentType || hookInput.agent_type || 'unknown';
+          if (agentSlug24 !== 'unknown') {
+            var resolved = pvRouter.resolvePromptForSpawn(agentSlug24);
+            if (resolved.version) {
+              console.log('[PROMPT_VERSION] ' + agentSlug24 + ' v' + resolved.version + (resolved.isCandidate ? ' (experiment candidate)' : ''));
+            }
+          }
+        }
+      }
+    } catch (e) { /* not available or no experiment */ }
+
+    // Monograph impact — detect changed files and surface their dependents
+    try {
+      var mgDbPath1 = path.join(CWD, '.monomind', 'monograph.db');
+      if (fs.existsSync(mgDbPath1)) {
+        var execSync1 = require('child_process').execSync;
+        var changedFiles1 = '';
+        try { changedFiles1 = execSync1('git diff --name-only HEAD 2>/dev/null || git diff --name-only 2>/dev/null', { cwd: CWD, timeout: 3000, shell: true }).toString().trim(); } catch(e) {}
+        if (changedFiles1) {
+          var mgMod1 = null;
+          mgMod1 = hCtx._requireMonograph();
+          if (mgMod1 && mgMod1.openDb) {
+            var db1 = mgMod1.openDb(mgDbPath1);
+            try {
+              var fileList1 = changedFiles1.split('\n').filter(Boolean).slice(0, 8);
+              var impacted1 = [];
+              for (var fi = 0; fi < fileList1.length; fi++) {
+                var fBase = path.basename(fileList1[fi]);
+                var fNode = db1.prepare("SELECT id, name, label FROM nodes WHERE file_path LIKE ? LIMIT 1").get('%' + fBase);
+                if (fNode) {
+                  var fImporters = db1.prepare(
+                    'SELECT n2.name FROM edges e JOIN nodes n2 ON n2.id = e.source_id WHERE e.target_id = ? LIMIT 5'
+                  ).all(fNode.id);
+                  var entry = fNode.name + ' (' + fNode.label + ')';
+                  if (fImporters.length) entry += ' ← ' + fImporters.map(function(i){ return i.name; }).join(', ');
+                  impacted1.push(entry);
+                }
+              }
+              if (impacted1.length > 0) {
+                console.log('[MONOGRAPH_IMPACT] Changed files and their dependents: ' + impacted1.join(' | '));
+              }
+
+              // Effective blast radius — second pass using first impacted node
+              try {
+                if (fileList1.length > 0 && mgMod1.effectiveBlastRadius) {
+                  var firstFile1 = path.basename(fileList1[0]);
+                  var firstNode1 = db1.prepare("SELECT id, name, label FROM nodes WHERE file_path LIKE ? LIMIT 1").get('%' + firstFile1);
+                  if (firstNode1) {
+                    var blastResults1 = mgMod1.effectiveBlastRadius(db1, firstNode1.id, { maxDepth: 4 });
+                    if (blastResults1 && blastResults1.length > 0) {
+                      var bwdCount1 = blastResults1.filter(function(r){ return r.direction === 'backward' || r.direction === 'both'; }).length;
+                      var fwdCount1 = blastResults1.filter(function(r){ return r.direction === 'forward' || r.direction === 'both'; }).length;
+                      var topBlast1 = blastResults1.slice(0, 8).map(function(r){
+                        return '[' + r.direction + ':' + r.hops + '] ' + r.nodeName + ' (' + r.nodeLabel + ')';
+                      });
+                      console.log('[MONOGRAPH_BLAST_RADIUS] Node: ' + firstNode1.name + ' | forward=' + fwdCount1 + ' backward=' + bwdCount1 + ' | ' + topBlast1.join(', '));
+                    }
+                  }
+                }
+              } catch(blastErr) { /* non-fatal */ }
+            } finally { if (mgMod1.closeDb) mgMod1.closeDb(db1); }
+          }
+        }
+      }
+    } catch(e) { /* non-fatal */ }
+
+    // Bridge to @monomind/hooks registry — fires Tasks 26 (PromptAssembler) and any other PreTask hooks
+    var _hooksModule = hCtx._hooksModule;
+    if (_hooksModule && _hooksModule.executeHooks && _hooksModule.HookEvent) {
+      try {
+        await _hooksModule.executeHooks(_hooksModule.HookEvent.PreTask, {
+          task: typeof prompt === 'string' ? { description: prompt, id: hookInput.taskId || '' } : null,
+          sessionId: hookInput.sessionId || hookInput.session_id || 'default',
+        }, { continueOnError: true, timeout: 2000 });
+      } catch (e) { /* non-fatal */ }
+    }
+  },
+
+  handlePostTask: async function(hCtx) {
+    var hookInput = hCtx.hookInput;
+    var prompt = hCtx.prompt;
+    var intelligence = hCtx.intelligence;
+    var CWD = hCtx.CWD;
+
+    var taskSuccess = hookInput.success !== false && hookInput.status !== 'failed';
+    if (intelligence && intelligence.feedback) {
+      try {
+        intelligence.feedback(true);
+      } catch (e) { /* non-fatal */ }
+    }
+    // Each TeammateIdle/TaskCompleted = one agent done → remove oldest registration (FIFO)
+    const regDir = path.join(CWD, '.monomind', 'agents', 'registrations');
+    try {
+      if (fs.existsSync(regDir)) {
+        const files = fs.readdirSync(regDir).filter(f => f.endsWith('.json'));
+        if (files.length > 0) {
+          // Sort by mtime ascending (oldest first) and remove the oldest one
+          const sorted = files
+            .map(f => ({ f, mtime: (() => { try { return fs.statSync(path.join(regDir, f)).mtimeMs; } catch { return 0; } })() }))
+            .sort((a, b) => a.mtime - b.mtime);
+          try { fs.unlinkSync(path.join(regDir, sorted[0].f)); } catch { /* ignore */ }
+        }
+        // Also purge any stragglers older than 30 min
+        const now = Date.now();
+        for (const f of fs.readdirSync(regDir).filter(f => f.endsWith('.json'))) {
+          try { if (now - fs.statSync(path.join(regDir, f)).mtimeMs > 30 * 60 * 1000) fs.unlinkSync(path.join(regDir, f)); } catch { /* ignore */ }
+        }
+        const remaining = fs.readdirSync(regDir).filter(f => f.endsWith('.json')).length;
+        const _actPath = path.join(CWD, '.monomind', 'metrics', 'swarm-activity.json');
+        let _prevLastActive = 0;
+        try { _prevLastActive = (JSON.parse(fs.readFileSync(_actPath, 'utf-8'))?.swarm?.lastActive) || 0; } catch { /* ignore */ }
+        fs.writeFileSync(_actPath, JSON.stringify({
+          timestamp: new Date().toISOString(),
+          swarm: {
+            active: remaining > 0,
+            agent_count: remaining,
+            coordination_active: remaining > 0,
+            lastActive: Math.max(remaining, _prevLastActive), // preserve peak across completion
+          },
+        }));
+      }
+    } catch (e) { /* non-fatal */ }
+
+    // Bridge to @monomind/hooks registry — fires Tasks 39 (SpecializationScorer) and any other PostTask hooks
+    var _hooksModule = hCtx._hooksModule;
+    if (_hooksModule && _hooksModule.executeHooks && _hooksModule.HookEvent) {
+      try {
+        await _hooksModule.executeHooks(_hooksModule.HookEvent.PostTask, {
+          task: {
+            id: hookInput.taskId || hookInput.task_id || '',
+            status: taskSuccess ? 'completed' : 'failed',
+            agentSlug: hookInput.agentSlug || hookInput.agent_slug || 'unknown',
+            type: hookInput.taskType || hookInput.task_type || 'general',
+          },
+          success: taskSuccess,
+          latencyMs: hookInput.latencyMs || hookInput.latency_ms || 0,
+          qualityScore: hookInput.qualityScore || hookInput.quality_score,
+        }, { continueOnError: true, timeout: 2000 });
+      } catch (e) { /* non-fatal */ }
+    }
+
+    // Task 35: TerminationConditions — detect halted swarms via halt-signal
+    try {
+      var haltMod = await import('file://' + path.join(CWD, 'packages/@monomind/cli/dist/src/agents/halt-signal.js'));
+      if (haltMod && haltMod.isHalted) {
+        var swarmId35 = hookInput.swarmId || hookInput.swarm_id || 'default';
+        if (haltMod.isHalted(swarmId35)) {
+          console.warn('[HALT_DETECTED] Swarm ' + swarmId35 + ' has an active halt signal — agents should stop');
+        }
+      }
+    } catch (e) {
+      // Try direct file check
+      try {
+        var haltFile = path.join(CWD, 'data', 'halt-signals.jsonl');
+        if (fs.existsSync(haltFile)) {
+          var haltLines = fs.readFileSync(haltFile, 'utf-8').trim().split('\n').filter(Boolean);
+          if (haltLines.length > 0) {
+            console.warn('[HALT_DETECTED] ' + haltLines.length + ' halt signal(s) present');
+          }
+        }
+      } catch (e2) { /* non-fatal */ }
+    }
+
+    // Task 37: DeadLetterQueue — enqueue failed tasks when retries exhausted
+    try {
+      if (!taskSuccess) {
+        var dlqMod = await import('file://' + path.join(CWD, 'packages/@monomind/cli/dist/src/dlq/dlq-writer.js'));
+        if (dlqMod && dlqMod.DLQWriter) {
+          var dlqDir = path.join(CWD, '.monomind', 'dlq');
+          var dlqWriter = new dlqMod.DLQWriter(dlqDir);
+          dlqWriter.enqueue({
+            toolName: 'post-task',
+            originalPayload: { taskId: hookInput.taskId || '', agentSlug: hookInput.agentSlug || 'unknown' },
+            deliveryAttempts: [{ attempt: 1, timestamp: new Date().toISOString(), error: hookInput.error || 'task failed' }],
+            agentId: hookInput.agentSlug || hookInput.agent_slug,
+            swarmId: hookInput.swarmId || hookInput.swarm_id,
+          });
+          console.log('[DLQ_ENQUEUED] Failed task ' + (hookInput.taskId || 'unknown') + ' sent to dead-letter queue');
+        }
+      }
+    } catch (e) { /* non-fatal */ }
+
+    // Memory Palace task drawer writes removed — use auto-memory files for task context
+
+    // ── Worker Auto-Dispatch ──────────────────────────────────────────────
+    // Auto-dispatch background workers based on task outcome
+    try {
+      var taskDesc = (typeof prompt === 'string' ? prompt : hookInput.description || '').toLowerCase();
+      var workersToDispatch = [];
+
+      // Always consolidate memory after any task
+      workersToDispatch.push('consolidate');
+
+      // Security-related task → dispatch audit worker
+      if (/\b(security|auth|vuln|cve|threat|token|permission|crypto)\b/.test(taskDesc)) {
+        workersToDispatch.push('audit');
+      }
+      // Performance-related → dispatch benchmark worker
+      if (/\b(performance|optimiz|benchmark|latency|throughput)\b/.test(taskDesc)) {
+        workersToDispatch.push('benchmark');
+      }
+      // Code changes → dispatch testgaps worker
+      if (/\b(implement|feature|refactor|fix|build|add|create|modify)\b/.test(taskDesc)) {
+        workersToDispatch.push('testgaps');
+      }
+      // Any significant task → dispatch map worker for codebase indexing
+      if (taskDesc.length > 50) {
+        workersToDispatch.push('map');
+      }
+
+      // Dispatch via @monomind/hooks if available, otherwise write dispatch file
+      if (workersToDispatch.length > 0) {
+        var dispatchDir = path.join(CWD, '.monomind', 'worker-dispatch');
+        fs.mkdirSync(dispatchDir, { recursive: true });
+        var dispatchPayload = {
+          workers: workersToDispatch,
+          trigger: 'post-task',
+          taskDesc: taskDesc.substring(0, 100),
+          success: taskSuccess,
+          timestamp: new Date().toISOString(),
+        };
+        fs.writeFileSync(
+          path.join(dispatchDir, 'pending-' + Date.now() + '-' + Math.random().toString(36).slice(2, 7) + '.json'),
+          JSON.stringify(dispatchPayload), 'utf-8'
+        );
+        console.log('[WORKER_DISPATCH] Queued: ' + workersToDispatch.join(', '));
+      }
+    } catch (e) { /* non-fatal */ }
+
+    // ── ADR Auto-Generation ────────────────────────────────────────────────
+    // When adr.autoGenerate is true and task involved architect-level work,
+    // create an ADR stub in the configured directory
+    try {
+      var settingsPath = path.join(CWD, '.claude', 'settings.json');
+      var adrCfg = {};
+      if (fs.existsSync(settingsPath)) {
+        var s = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        adrCfg = (s.monomind && s.monomind.adr) || {};
+      }
+      if (adrCfg.autoGenerate) {
+        var taskAgent = hookInput.agentSlug || hookInput.agent_slug || '';
+        var taskDescAdr = (typeof prompt === 'string' ? prompt : hookInput.description || '').toLowerCase();
+        var isArchitectLevel = ['architect', 'system-architect', 'software-architect'].includes(taskAgent)
+          || /\b(architecture|design decision|adr|trade-?off|migration strategy)\b/.test(taskDescAdr);
+        if (isArchitectLevel && taskDescAdr.length > 30) {
+          var adrDir = path.join(CWD, adrCfg.directory || 'docs/adrs');
+          fs.mkdirSync(adrDir, { recursive: true });
+          var adrNum = (fs.readdirSync(adrDir).filter(function(f) { return f.endsWith('.md'); }).length + 1)
+            .toString().padStart(4, '0');
+          var adrTitle = taskDescAdr.substring(0, 60).replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+          var adrFile = path.join(adrDir, 'ADR-' + adrNum + '-' + adrTitle + '.md');
+          if (!fs.existsSync(adrFile)) {
+            var adrContent = '# ADR-' + adrNum + ': ' + (typeof prompt === 'string' ? prompt.substring(0, 80) : adrTitle) + '\n\n'
+              + '**Date:** ' + new Date().toISOString().slice(0, 10) + '\n'
+              + '**Status:** Accepted\n'
+              + '**Agent:** ' + (taskAgent || 'unknown') + '\n\n'
+              + '## Context\n\nAuto-generated from task completion.\n\n'
+              + '## Decision\n\n_Fill in the decision made._\n\n'
+              + '## Consequences\n\n_Fill in the consequences._\n';
+            fs.writeFileSync(adrFile, adrContent, 'utf-8');
+            console.log('[ADR_GENERATED] ' + path.basename(adrFile));
+          }
+        }
+      }
+    } catch (e) { /* non-fatal */ }
+
+    console.log('[OK] Task completed');
+  }
+};