monomind 1.19.0 → 2.0.1

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

@@ -1,375 +0,0 @@
-'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); }
-
-    // ── Non-blocking security scan via @monomind/hooks worker ─────────────
-    // The hooks package ships a security worker (worker-security.ts) that scans
-    // for hardcoded secrets and vulnerability patterns. We run it at session
-    // start as a fire-and-forget check — failures are silently ignored since
-    // the package may not be installed or built.
-    try {
-      var hooksWorkersMod = require('@monomind/hooks/dist/workers/worker-security.js');
-      var _createSecurityWorker = hooksWorkersMod.createSecurityWorker;
-      if (typeof _createSecurityWorker === 'function') {
-        var _securityScan = _createSecurityWorker(CWD);
-        // Fire-and-forget: do not await — must not delay session restore
-        Promise.resolve(_securityScan()).catch(function() {});
-      }
-    } catch (e) { /* @monomind/hooks not available or not built — skip */ }
-
-    // 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');
-      var MAX_SETTINGS = 256 * 1024; // 256 KiB
-      if (fs.existsSync(settingsPath) && (function() { try { return fs.statSync(settingsPath).size <= MAX_SETTINGS; } catch(_) { return false; } }())) {
-        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');
-          var MAX_PKG = 64 * 1024; // 64 KiB
-          if (fs.existsSync(localPkg) && (function() { try { return fs.statSync(localPkg).size <= MAX_PKG; } catch(_) { return false; } }())) {
-            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) { if (out.length < 256) out += d; });
-              child.on('close', function() {
-                var current = out.trim().slice(0, 64);
-                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');
-        var MAX_UPD = 4096; // 4 KiB
-        if (fs.existsSync(pendingUpdate) && (function() { try { return fs.statSync(pendingUpdate).size <= MAX_UPD; } catch(_) { return false; } }())) {
-          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 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'));
-      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');
-      var MAX_REG = 512 * 1024; // 512 KiB
-      if (fs.existsSync(regPath) && (function() { try { return fs.statSync(regPath).size <= MAX_REG; } catch(_) { return false; } }())) {
-        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 — only probe when a daemon.pid file exists,
-    // meaning the daemon was intentionally started in this project. This avoids
-    // printing "[CONTROL_UI] offline" noise on every session in projects that
-    // never run the daemon.  The broader "monomind.config.json" check is dropped
-    // because that file is present in the dev repo itself and in any initialized
-    // project, making the old condition nearly always true.
-    var _controlUiShouldProbe = fs.existsSync(path.join(CWD, '.monomind', 'daemon.pid'));
-    if (_controlUiShouldProbe) {
-      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() {
-          // Only warn when daemon was previously running (pid file exists but server is gone)
-          console.log('[CONTROL_UI] offline — restart with: npx monomind mcp start');
-        });
-        req.setTimeout(800, function() { req.destroy(); });
-      } catch (e) { /* non-fatal */ }
-    }
-
-  },
-};

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

@@ -1,14 +0,0 @@
-'use strict';
-// Extracted from hook-handler.cjs — handles 'stats' command.
-
-module.exports = {
-  handle: async function(hCtx) {
-    var intelligence = hCtx.intelligence;
-    var args = hCtx.args;
-    if (intelligence && intelligence.stats) {
-      try { await Promise.resolve(intelligence.stats(args.includes('--json'))); } catch (e) { /* non-fatal */ }
-    } else {
-      console.log('[WARN] Intelligence module not available. Run session-restore first.');
-    }
-  },
-};

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

@@ -1,206 +0,0 @@
-'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 */ }
-    }
-
-    // monolean: removed per-subagent redundancies:
-    // - Re-routing (already done by route handler on parent prompt)
-    // - AUTOMEM pattern recall (marginal value, 2 similarity searches per spawn)
-    // - 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;
-    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(taskSuccess);
-      } 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 { var _actSt = fs.statSync(_actPath); if (_actSt.size < 65536) { _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 haltSt = fs.statSync(haltFile);
-          var haltLines = haltSt.size < 1048576 ? 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 */ }
-
-    // Record whether this task's outcome matched a recalled memory pattern,
-    // so future pattern recall can be scored for usefulness.
-    try {
-      var intelligence = hCtx.intelligence;
-      if (intelligence && intelligence.recordMemoryDecision) {
-        var agentSlug = hookInput.agentSlug || hookInput.agent_slug || 'unknown';
-        var taskDesc = typeof prompt === 'string' ? prompt : hookInput.description || '';
-        await Promise.resolve(intelligence.recordMemoryDecision({
-          taskDescription: taskDesc.substring(0, 200),
-          agent: agentSlug,
-          success: taskSuccess,
-          latencyMs: hookInput.latencyMs || hookInput.latency_ms || 0,
-        }));
-      }
-    } catch (e) { /* non-fatal — LOG is advisory */ }
-
-    // ── 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 settingsSt = fs.statSync(settingsPath);
-        if (settingsSt.size < 524288) {
-          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) {
-          // Guard adrCfg.directory against path traversal outside CWD
-          var rawAdrDir = typeof adrCfg.directory === 'string' ? adrCfg.directory : 'docs/adrs';
-          var resolvedAdrDir = path.resolve(CWD, rawAdrDir);
-          if (!resolvedAdrDir.startsWith(CWD + path.sep) && resolvedAdrDir !== CWD) { throw new Error('adr.directory outside project'); }
-          var adrDir = resolvedAdrDir;
-          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');
-  }
-};