monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/.claude/helpers/utils/agent-registrations.cjs

@@ -1,41 +0,0 @@
-'use strict';
-// Shared agent-registration purge logic.
-//
-// .monomind/agents/registrations/*.json accumulate one file per subagent
-// spawn. The only purge used to be the FIFO-oldest-removal + stale sweep in
-// task-handler.cjs's handlePostTask, which only fires on TeammateIdle/
-// TaskCompleted — so any session that spawns agents but never emits those
-// events (crashes, single-shot Task calls outside a team, etc.) leaked
-// registrations forever. agent-start-handler.cjs already reads this
-// directory on every subagent start, so it also runs this same stale sweep.
-
-const path = require('path');
-const fs = require('fs');
-const { cleanEntries } = require('./fs-helpers.cjs');
-
-const DEFAULT_MAX_AGE_MS = 30 * 60 * 1000; // 30 minutes
-
-/**
- * Delete registration files older than maxAgeMs. Returns the number of
- * registrations remaining after the purge (or null if regDir doesn't exist
- * or an error occurred).
- */
-function purgeStaleRegistrations(regDir, maxAgeMs) {
-  maxAgeMs = maxAgeMs || DEFAULT_MAX_AGE_MS;
-  try {
-    if (!fs.existsSync(regDir)) return null;
-    const now = Date.now();
-    for (const f of cleanEntries(regDir, f => f.endsWith('.json'))) {
-      try {
-        if (now - fs.statSync(path.join(regDir, f)).mtimeMs > maxAgeMs) {
-          fs.unlinkSync(path.join(regDir, f));
-        }
-      } catch { /* ignore */ }
-    }
-    return cleanEntries(regDir, f => f.endsWith('.json')).length;
-  } catch {
-    return null;
-  }
-}
-
-module.exports = { purgeStaleRegistrations, DEFAULT_MAX_AGE_MS };

package/packages/@monomind/cli/.claude/helpers/utils/fs-helpers.cjs

@@ -1,183 +0,0 @@
-'use strict';
-// Shared fs helpers for hook handlers.
-//
-// exFAT / macOS AppleDouble junk files (`._foo.json`, `.__protocol.md`, etc.)
-// get created whenever files touch an exFAT volume (external drives, some
-// network shares) and then get picked up by naive `readdirSync().filter(...)`
-// calls as if they were real data — corrupting counts, getting parsed as
-// JSON and failing, or (worst case) surfacing as garbage entries in
-// Claude Code's own skill/command list. Every readdir in the hook handlers
-// should route through `cleanEntries()` so this is filtered exactly once.
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Read a directory and filter out exFAT AppleDouble junk (`._*`) before
- * applying the caller's own filter predicate.
- * @param {string} dir - directory to read
- * @param {(name: string) => boolean} [filterFn] - optional additional filter
- * @returns {string[]} entry names (not full paths), junk-free
- */
-function cleanEntries(dir, filterFn) {
-  let entries;
-  try {
-    entries = fs.readdirSync(dir);
-  } catch {
-    return [];
-  }
-  entries = entries.filter(f => !f.startsWith('._'));
-  return filterFn ? entries.filter(filterFn) : entries;
-}
-
-/**
- * Same as cleanEntries but returns full paths.
- */
-function cleanEntryPaths(dir, filterFn) {
-  return cleanEntries(dir, filterFn).map(f => path.join(dir, f));
-}
-
-/**
- * Synchronous sleep (blocks the event loop) — used for tiny lock-retry
- * backoffs where an async setTimeout would require restructuring a
- * short-lived hook script into a promise chain for no real benefit.
- * Falls back to a busy-wait if Atomics.wait is unavailable.
- */
-function sleepSync(ms) {
-  try {
-    const sab = new SharedArrayBuffer(4);
-    Atomics.wait(new Int32Array(sab), 0, 0, ms);
-  } catch {
-    const end = Date.now() + ms;
-    while (Date.now() < end) { /* spin */ }
-  }
-}
-
-/**
- * Write a file atomically: write to a unique temp path then rename into
- * place. `fs.renameSync` is atomic on POSIX and Windows (same volume), so
- * concurrent readers of `filePath` never observe a partially-written file
- * (torn read) — they see either the old complete file or the new complete
- * file, never a half-written one. Does not by itself prevent lost updates
- * from concurrent read-modify-write cycles — pair with `claimLock` when
- * that matters (see hook-latency.json / swarm-activity.json writers).
- */
-function atomicWriteFileSync(filePath, data, encoding) {
-  const dir = path.dirname(filePath);
-  try { fs.mkdirSync(dir, { recursive: true }); } catch { /* ignore */ }
-  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  fs.writeFileSync(tmp, data, encoding);
-  fs.renameSync(tmp, filePath);
-}
-
-/**
- * Claim an exclusive lock file for short-lived critical sections (e.g. a
- * rebuild-cooldown or spawn-once guard). Uses `wx` (exclusive create) so
- * the claim itself is atomic — no read-check-write window.
- *
- * On contention, a lock older than `staleMs` is treated as abandoned (the
- * holder crashed or never released it) and broken via an atomic RENAME
- * (never unlink-then-create): renaming the stale lock path away is only
- * ever won by exactly one racing process, so a concurrent process that
- * also decided the lock was stale cannot delete *this* process's
- * freshly-reclaimed lock out from under it (the TOCTOU race an
- * unlink-then-create approach is vulnerable to). The loser of the rename
- * race backs off and retries the whole claim sequence from the top rather
- * than assuming it owns anything.
- *
- * Returns true if the lock was claimed (caller must eventually call
- * `releaseLock`), false if another live/fresh owner holds it.
- */
-function claimLock(lockPath, staleMs, maxAttempts) {
-  staleMs = staleMs || 30000;
-  maxAttempts = maxAttempts || 3;
-  try { fs.mkdirSync(path.dirname(lockPath), { recursive: true }); } catch { /* ignore */ }
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
-      return true;
-    } catch {
-      let stat;
-      try {
-        stat = fs.statSync(lockPath);
-      } catch {
-        // Lock vanished between our failed wx-create and this stat check —
-        // retry the create immediately.
-        continue;
-      }
-      if (Date.now() - stat.mtimeMs < staleMs) return false; // held by a live/fresh owner
-
-      const claimedName = `${lockPath}.${process.pid}.${Date.now()}.stale`;
-      try {
-        fs.renameSync(lockPath, claimedName);
-      } catch {
-        // Someone else already renamed the stale lock away — they're
-        // claiming it. Back off briefly and retry from the top rather than
-        // proceeding as if we own it.
-        sleepSync(5);
-        continue;
-      }
-      try { fs.unlinkSync(claimedName); } catch { /* ignore */ }
-      // We won the rename race — loop back and attempt the wx-create fresh.
-    }
-  }
-  return false;
-}
-
-/** Release a lock previously claimed by this process via `claimLock`. */
-function releaseLock(lockPath) {
-  try {
-    if (Number(fs.readFileSync(lockPath, 'utf-8')) === process.pid) fs.unlinkSync(lockPath);
-  } catch { /* ignore */ }
-}
-
-/**
- * Run `fn` while holding a lock (see `claimLock`) so a read-modify-write
- * cycle is protected end-to-end, not just the final write. If the lock
- * can't be claimed after retries, `fn` still runs (never block a hook) but
- * without lost-update protection — best-effort, matching this codebase's
- * "hooks must not block the session" rule.
- */
-function withLock(lockPath, fn, staleMs, maxAttempts) {
-  const acquired = claimLock(lockPath, staleMs, maxAttempts);
-  try {
-    return fn();
-  } finally {
-    if (acquired) releaseLock(lockPath);
-  }
-}
-
-/**
- * Append a JSONL line and rotate the file down to `maxLines` (keep the
- * most recent lines) when it exceeds that count — mirrors the size-cap
- * pattern already used for intelligence-outcomes.jsonl (500 lines) and
- * episodes.jsonl. Prevents unbounded JSONL growth. Rotation write is
- * atomic (tmp+rename).
- */
-function appendJsonlWithRotation(filePath, line, maxLines) {
-  maxLines = maxLines || 500;
-  try { fs.mkdirSync(path.dirname(filePath), { recursive: true }); } catch { /* ignore */ }
-  fs.appendFileSync(filePath, line.endsWith('\n') ? line : line + '\n');
-  try {
-    const st = fs.statSync(filePath);
-    // Cheap heuristic to skip reading huge files line-by-line on every
-    // append: only bother counting lines once the file is already
-    // suspiciously large relative to a plausible maxLines * avg-line-size.
-    if (st.size < 4096) return;
-    const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
-    if (lines.length > maxLines) {
-      atomicWriteFileSync(filePath, lines.slice(-maxLines).join('\n') + '\n', 'utf-8');
-    }
-  } catch { /* non-fatal — rotation is best-effort */ }
-}
-
-module.exports = {
-  cleanEntries,
-  cleanEntryPaths,
-  sleepSync,
-  atomicWriteFileSync,
-  claimLock,
-  releaseLock,
-  withLock,
-  appendJsonlWithRotation,
-};

package/packages/@monomind/cli/.claude/helpers/utils/micro-agents.cjs

@@ -1,358 +0,0 @@
-'use strict';
-// Extracted from hook-handler.cjs — micro-agent trigger scanner and knowledge base helpers.
-
-const path = require('path');
-const fs = require('fs');
-
-const { _openMonographDb } = require('./monograph.cjs');
-const { cleanEntries, atomicWriteFileSync } = require('./fs-helpers.cjs');
-
-const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-
-function safeRequire(modulePath) {
-  try {
-    if (fs.existsSync(modulePath)) {
-      const origLog = console.log;
-      const origError = console.error;
-      console.log = () => {};
-      console.error = () => {};
-      try {
-        const mod = require(modulePath);
-        return mod;
-      } finally {
-        console.log = origLog;
-        console.error = origError;
-      }
-    }
-  } catch (e) { /* silently fail */ }
-  return null;
-}
-
-// ── MicroAgent Trigger Scanner ────────────────────────────────────────────────
-
-function _triggerExtractYamlValue(raw) {
-  var v = raw.trim();
-  if (v.startsWith('"') && v.endsWith('"')) {
-    v = v.slice(1, -1).replace(/\\\\/g, '\\');
-  } else if (v.startsWith("'") && v.endsWith("'")) {
-    v = v.slice(1, -1);
-  }
-  return v;
-}
-
-function _triggerFinalize(partial, agentSlug) {
-  return { pattern: partial.pattern, mode: partial.mode || 'inject', priority: partial.priority || 0, agentSlug: agentSlug };
-}
-
-function _triggerExtractFromFrontmatter(content, agentSlug) {
-  var fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!fmMatch) return [];
-  var block = fmMatch[1];
-  var triggers = [];
-  var lines = block.split('\n');
-  var inTriggers = false;
-  var cur = null;
-  for (var i = 0; i < lines.length; i++) {
-    var line = lines[i];
-    var trimmed = line.trim();
-    var indent = line.length - line.trimStart().length;
-    if (trimmed === 'triggers:' || trimmed.startsWith('triggers:')) { inTriggers = true; continue; }
-    if (inTriggers && indent === 0 && /^[a-zA-Z]/.test(trimmed)) {
-      inTriggers = false;
-      if (cur && cur.pattern) triggers.push(_triggerFinalize(cur, agentSlug));
-      cur = null; continue;
-    }
-    if (!inTriggers) continue;
-    if (trimmed.startsWith('- pattern:')) {
-      if (cur && cur.pattern) triggers.push(_triggerFinalize(cur, agentSlug));
-      cur = { pattern: _triggerExtractYamlValue(trimmed.replace(/^- pattern:\s*/, '')), agentSlug: agentSlug };
-    } else if (cur && trimmed.startsWith('mode:')) {
-      var mv = _triggerExtractYamlValue(trimmed.replace(/^mode:\s*/, ''));
-      if (mv === 'inject' || mv === 'takeover') cur.mode = mv;
-    } else if (cur && trimmed.startsWith('priority:')) {
-      var pv = parseInt(trimmed.replace(/^priority:\s*/, ''), 10);
-      if (!isNaN(pv)) cur.priority = pv;
-    }
-  }
-  if (cur && cur.pattern) triggers.push(_triggerFinalize(cur, agentSlug));
-  return triggers;
-}
-
-function _triggerCollectMdFiles(dir, _depth) {
-  var depth = (_depth === undefined) ? 0 : _depth;
-  if (depth > 5) return []; // cap recursion depth to prevent stack overflow DoS
-  var results = [];
-  try {
-    var entries = cleanEntries(dir);
-    for (var i = 0; i < entries.length; i++) {
-      if (results.length >= 200) break; // cap total file count to prevent DoS
-      var full = path.join(dir, entries[i]);
-      try {
-        var st = fs.lstatSync(full);
-        if (st.isDirectory()) results = results.concat(_triggerCollectMdFiles(full, depth + 1));
-        else if (entries[i].endsWith('.md')) results.push(full);
-      } catch (e) {}
-    }
-  } catch (e) {}
-  return results;
-}
-
-function _triggerBuildIndex(agentDir) {
-  var patterns = [];
-  var files = _triggerCollectMdFiles(agentDir);
-  for (var i = 0; i < files.length; i++) {
-    var content;
-    try {
-      var _fst = fs.statSync(files[i]);
-      if (_fst.size > 256 * 1024) continue; // skip files > 256 KiB to prevent OOM
-      content = fs.readFileSync(files[i], 'utf-8');
-    } catch (e) { continue; }
-    var slug = files[i].split('/').pop().replace(/\.md$/i, '').toLowerCase().replace(/[^a-z0-9-]/g, '-');
-    patterns = patterns.concat(_triggerExtractFromFrontmatter(content, slug));
-  }
-  return patterns;
-}
-
-function scanMicroAgentTriggers(prompt) {
-  if (!prompt || typeof prompt !== 'string') return { matches: [], injectAgents: [] };
-  var indexPath = path.join(CWD, '.monomind', 'trigger-index.json');
-  var agentDir = path.join(CWD, '.claude', 'agents');
-  var patterns = [];
-  var cacheLoaded = false;
-
-  try {
-    if (fs.existsSync(indexPath)) {
-      var _idxSt = fs.statSync(indexPath);
-      if (_idxSt.size > 512 * 1024) { throw new Error('trigger-index.json exceeds 512 KiB'); }
-      var idx = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
-      var age = Date.now() - new Date(idx.builtAt || 0).getTime();
-      if (age < 3600000 && Array.isArray(idx.patterns)) {
-        patterns = idx.patterns;
-        cacheLoaded = true;
-      }
-    }
-  } catch (e) {}
-
-  if (!cacheLoaded) {
-    patterns = _triggerBuildIndex(agentDir);
-    try {
-      // P2-21: tmp+rename — multiple concurrent hook processes (route-handler
-      // invocations fire per prompt/subagent) can all miss the cache at once
-      // and rebuild+write trigger-index.json simultaneously; atomic write
-      // prevents a concurrent reader from parsing a half-written file.
-      atomicWriteFileSync(indexPath, JSON.stringify({ patterns: patterns, builtAt: new Date().toISOString(), totalAgentsScanned: patterns.length }));
-    } catch (e) {}
-  }
-
-  patterns.sort(function(a, b) { return (b.priority || 0) - (a.priority || 0); });
-
-  var matches = [];
-  var seen = {};
-  for (var i = 0; i < patterns.length; i++) {
-    var p = patterns[i];
-    if (p.mode !== 'inject' && p.mode !== 'takeover') continue;
-    if (seen[p.agentSlug]) continue;
-    try {
-      if (typeof p.pattern !== 'string' || p.pattern.length > 500) continue; // cap pattern length to prevent ReDoS
-      var re = new RegExp(p.pattern, 'i');
-      var m = re.exec(prompt);
-      if (m) {
-        seen[p.agentSlug] = true;
-        matches.push({ agentSlug: p.agentSlug, mode: p.mode, matchedText: m[0] });
-        if (p.mode === 'takeover') {
-          return { matches: matches, takeoverAgent: p.agentSlug, injectAgents: [] };
-        }
-      }
-    } catch (e) {}
-  }
-  return { matches: matches, injectAgents: matches.map(function(m) { return m.agentSlug; }) };
-}
-
-// ── Knowledge Base ────────────────────────────────────────────────────────────
-
-var _KNOWLEDGE_STOPWORDS = new Set(['the','and','or','but','if','in','on','to','is','it','be','do','of','for','not','at','by','as','we','us','an','a','i']);
-
-function _buildKnowledgeSearchFn(knowledgeDir) {
-  return async function(query, opts) {
-    var chunksFile = path.join(knowledgeDir, 'chunks.jsonl');
-    if (!fs.existsSync(chunksFile)) return [];
-    var lines;
-    try {
-      var _cSt = fs.statSync(chunksFile);
-      if (_cSt.size > 4 * 1024 * 1024) return []; // skip > 4 MiB to prevent OOM
-      lines = fs.readFileSync(chunksFile, 'utf-8').trim().split('\n').filter(Boolean);
-    } catch (e) { return []; }
-
-    var ns = (opts && opts.namespace) || null;
-    var limit = (opts && opts.limit) || 10;
-    var minScore = (opts && opts.minScore != null) ? opts.minScore : 0.3;
-    var queryTerms = query.toLowerCase().split(/\s+/).filter(function(t) { return t.length >= 2 && !_KNOWLEDGE_STOPWORDS.has(t); });
-    if (queryTerms.length === 0) return [];
-
-    var results = [];
-    for (var i = 0; i < lines.length; i++) {
-      try {
-        var chunk = JSON.parse(lines[i]);
-        if (ns && chunk.namespace !== ns) continue;
-        var textLower = (chunk.text || '').toLowerCase();
-        var matchCount = queryTerms.filter(function(t) { return textLower.includes(t); }).length;
-        var score = matchCount / queryTerms.length;
-        if (score >= minScore) {
-          results.push({ key: chunk.chunkId, value: chunk.text, score: score, metadata: chunk.metadata || {} });
-        }
-      } catch (e) {}
-    }
-    results.sort(function(a, b) { return b.score - a.score; });
-    return results.slice(0, limit);
-  };
-}
-
-function _autoIndexKnowledge(knowledgeDir) {
-  var crypto = require('crypto');
-  var sources = [
-    { filePath: path.join(CWD, 'CLAUDE.md'), label: 'project-instructions' },
-    { filePath: path.join(CWD, 'docs/todo.md'), label: 'project-todo' },
-    { filePath: path.join(CWD, 'CLAUDE.local.md'), label: 'local-instructions' },
-  ];
-
-  var hashInput = '';
-  for (var i = 0; i < sources.length; i++) {
-    try {
-      if (fs.existsSync(sources[i].filePath)) {
-        var st = fs.statSync(sources[i].filePath);
-        hashInput += sources[i].filePath + ':' + st.size + ':' + st.mtimeMs + ';';
-      }
-    } catch (e) {}
-  }
-  try {
-    var _sSt = fs.statSync(path.join(CWD, '.monomind', 'graph', 'stats.json'));
-    if (_sSt.size > 256 * 1024) { throw new Error('stats.json exceeds 256 KiB'); }
-    var statsForHash = JSON.parse(fs.readFileSync(path.join(CWD, '.monomind', 'graph', 'stats.json'), 'utf-8'));
-    hashInput += 'monograph:' + (statsForHash.builtAt || 0) + ';';
-  } catch(e) {}
-
-  var contentHash = crypto.createHash('md5').update(hashInput).digest('hex');
-  var chunksFile = path.join(knowledgeDir, 'chunks.jsonl');
-  var hashFile = path.join(knowledgeDir, '.index-hash');
-  var existingHash = '';
-  try { existingHash = fs.readFileSync(hashFile, 'utf-8').trim(); } catch (e) {}
-
-  var existingChunkCount = 0;
-  try { if (fs.existsSync(chunksFile)) { var _ecSt = fs.statSync(chunksFile); if (_ecSt.size <= 4 * 1024 * 1024) { existingChunkCount = fs.readFileSync(chunksFile, 'utf-8').trim().split('\n').filter(Boolean).length; } } } catch (e) {}
-  if (existingHash === contentHash && existingChunkCount > 0) return 0;
-
-  var newLines = [];
-  for (var si = 0; si < sources.length; si++) {
-    var src = sources[si];
-    try {
-      if (!fs.existsSync(src.filePath)) continue;
-      var _srcSt = fs.statSync(src.filePath);
-      if (_srcSt.size > 512 * 1024) continue; // skip > 512 KiB to prevent OOM
-      var content = fs.readFileSync(src.filePath, 'utf-8');
-      var sections = content.split(/\n{2,}|\n(?=#{1,3} )/);
-      for (var ci = 0; ci < sections.length; ci++) {
-        var text = sections[ci].trim();
-        if (text.length < 40 || text.length > 3000) continue;
-        var chunkId = crypto.createHash('md5').update(src.filePath + ':' + ci).digest('hex').slice(0, 16);
-        newLines.push(JSON.stringify({
-          chunkId: chunkId,
-          namespace: 'knowledge:shared',
-          text: text,
-          metadata: { filePath: src.filePath, label: src.label, chunkIndex: ci }
-        }));
-      }
-    } catch (e) {}
-  }
-
-  // Inject monograph graph summary as a knowledge chunk (reads from monograph.db).
-  try {
-    var mgDbPath = path.join(CWD, '.monomind', 'monograph.db');
-    var legacyStats = path.join(CWD, '.monomind', 'graph', 'stats.json');
-    var legacyGraph = path.join(CWD, '.monomind', 'graph', 'graph.json');
-
-    var summaryText = null;
-    var summaryMeta = {};
-
-    if (fs.existsSync(mgDbPath)) {
-      try {
-        var sumDb = _openMonographDb();
-        if (sumDb) {
-          try {
-            var nodeC = sumDb.prepare('SELECT COUNT(*) AS c FROM nodes').get().c;
-            var edgeC = sumDb.prepare('SELECT COUNT(*) AS c FROM edges').get().c;
-            var topNodes = sumDb.prepare(
-              'SELECT n.name, n.label, n.file_path, ' +
-              '(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg ' +
-              'FROM nodes n WHERE n.file_path IS NOT NULL AND n.file_path != "" ORDER BY deg DESC LIMIT 15'
-            ).all();
-            var typeRows = sumDb.prepare(
-              'SELECT label, COUNT(*) AS c FROM nodes GROUP BY label ORDER BY c DESC LIMIT 8'
-            ).all();
-            var typeStr = typeRows.map(function(r) { return r.label + ':' + r.c; }).join(', ');
-            summaryText = [
-              'MONOGRAPH KNOWLEDGE GRAPH SUMMARY',
-              'Source: monograph.db | Nodes: ' + nodeC + ' | Edges: ' + edgeC,
-              '',
-              'TOP GOD NODES (highest connectivity — start exploration here):',
-              topNodes.map(function(n) {
-                return '  ' + n.name + ' [' + n.label + '] — ' + (n.file_path || '') + ' (degree: ' + n.deg + ')';
-              }).join('\n'),
-              '',
-              'NODE TYPE DISTRIBUTION: ' + typeStr,
-              '',
-              'Before grepping or globbing, prefer:',
-              '  mcp__monomind__monograph_suggest({ task: "<your task>" }) — ranked relevant files',
-              '  mcp__monomind__monograph_query({ q: "<symbol|keyword>" }) — BM25 search with file:line',
-              '  mcp__monomind__monograph_impact({ name: "<file>" }) — upstream + downstream blast radius',
-            ].join('\n');
-            summaryMeta = { label: 'monograph-graph-summary', source: 'monograph.db', nodes: nodeC, edges: edgeC };
-          } catch (e) { /* keep summaryText if partial */ }
-        }
-      } catch (e) { /* fall through to legacy */ }
-    }
-
-    if (!summaryText && fs.existsSync(legacyStats) && fs.existsSync(legacyGraph)) {
-      try {
-        var lStats = JSON.parse(fs.readFileSync(legacyStats, 'utf-8'));
-        var lGraphStat = fs.statSync(legacyGraph);
-        if (lGraphStat.size < 10 * 1024 * 1024) {
-          var lGraph = JSON.parse(fs.readFileSync(legacyGraph, 'utf-8'));
-          var lNodes = Array.isArray(lGraph.nodes) ? lGraph.nodes : [];
-          summaryText = 'MONOGRAPH KNOWLEDGE GRAPH SUMMARY (legacy JSON)\n' +
-            'Nodes: ' + (lStats.nodes || lNodes.length) + ' | Edges: ' + (lStats.edges || 0) + '\n' +
-            'Use mcp__monomind__monograph_suggest to find files relevant to your task.';
-          summaryMeta = { label: 'monograph-graph-summary', source: 'legacy-json', builtAt: lStats.builtAt };
-        }
-      } catch (e) { /* ignore */ }
-    }
-
-    if (summaryText) {
-      var chunkId2 = crypto.createHash('md5').update('monograph-graph-summary').digest('hex').slice(0, 16);
-      newLines.push(JSON.stringify({
-        chunkId: chunkId2,
-        namespace: 'knowledge:shared',
-        text: summaryText,
-        metadata: summaryMeta
-      }));
-    }
-  } catch (e) { /* graph not available yet */ }
-
-  try {
-    // Same torn-read hazard as trigger-index.json above — atomic write.
-    atomicWriteFileSync(chunksFile, newLines.length > 0 ? newLines.join('\n') + '\n' : '', 'utf-8');
-    atomicWriteFileSync(hashFile, contentHash, 'utf-8');
-  } catch (e) {}
-  return newLines.length;
-}
-
-module.exports = {
-  safeRequire,
-  _triggerExtractYamlValue,
-  _triggerFinalize,
-  _triggerExtractFromFrontmatter,
-  _triggerCollectMdFiles,
-  _triggerBuildIndex,
-  scanMicroAgentTriggers,
-  _buildKnowledgeSearchFn,
-  _autoIndexKnowledge,
-};