@monoes/monomindcli 1.18.15 → 2.0.0

package/.claude/helpers/handlers/agent-start-handler.cjs

@@ -6,7 +6,7 @@ const path = require('path');
 const fs = require('fs');
 
 module.exports = {
-  handle: function(hCtx) {
+  handle: async function(hCtx) {
     var hookInput = hCtx.hookInput;
     var CWD = hCtx.CWD;
     var _openMonographDb = hCtx._openMonographDb;
@@ -65,44 +65,36 @@ module.exports = {
       );
     } catch (e) { /* non-fatal — never block a subagent from starting */ }
 
-    // Subagent context inheritance — inject graph god nodes + parent's last
-    // pre-resolved suggestions so the spawned agent inherits spatial map.
+    // monolean: compact single-line graph context instead of multi-line map.
+    // Subagents get task-relevant files only — god nodes are noise for a focused task.
     try {
-      var subDb = _openMonographDb();
-      if (subDb) {
-        try {
-          var godRows = subDb.prepare(
-            "SELECT n.name, n.label, n.file_path AS file, " +
-            "(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg " +
-            "FROM nodes n " +
-            "WHERE n.label NOT IN ('Concept') AND n.file_path IS NOT NULL AND n.file_path != '' " +
-            "ORDER BY deg DESC LIMIT 5"
-          ).all();
-          if (godRows.length > 0) {
-            console.log('[MONOGRAPH_SUBAGENT_CTX] Graph map inherited from parent:');
-            for (var gi = 0; gi < godRows.length; gi++) {
-              var gr = godRows[gi];
-              console.log('  · ' + gr.name + ' [' + gr.label + '] — ' + (gr.file || '') + ' (deg ' + gr.deg + ')');
-            }
-            try {
-              var subAgentDesc = hookInput.description || hookInput.prompt_description || '';
-              if (subAgentDesc && subAgentDesc.length > 8) {
-                var subHints = getMonographSuggestions(subAgentDesc, 3);
-                if (subHints.length > 0) {
-                  console.log('  Top files for this subagent task:');
-                  for (var si2 = 0; si2 < subHints.length; si2++) {
-                    var sh = subHints[si2];
-                    console.log('    · ' + sh.name + ' [' + sh.label + '] — ' + (sh.file || ''));
-                  }
-                }
-              }
-            } catch (_) {}
-            console.log('  Use mcp__monomind__monograph_suggest / monograph_query in this subagent before grepping.');
-          }
-        } catch (e) { /* non-fatal */ }
+      var subAgentDesc = hookInput.description || hookInput.prompt_description || '';
+      if (subAgentDesc && subAgentDesc.length > 8) {
+        var subHints = getMonographSuggestions(subAgentDesc, 3);
+        if (subHints.length > 0) {
+          var parts = subHints.map(function(s) {
+            return s.name + ' [' + s.label + '] — ' + (s.file || '');
+          });
+          console.log('[MONOGRAPH] Top files: ' + parts.join(' · '));
+        }
       }
     } catch (e) { /* non-fatal */ }
 
-    console.log('[OK] Agent registered');
+    // Bridge to @monomind/hooks registry — fires AgentSpawn hooks (was previously never
+    // wired: HookEvent.AgentSpawn existed but no CJS handler ever fired it).
+    try {
+      var _hooksModule = hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null;
+      if (_hooksModule && _hooksModule.executeHooks && _hooksModule.HookEvent) {
+        var agentTypeBridge = String(hookInput.subagent_type || hookInput.agentType || hookInput.agent_type || hookInput.agentSlug || 'unknown');
+        var agentDescBridge = String(hookInput.description || hookInput.prompt_description || '');
+        _hooksModule.executeHooks(_hooksModule.HookEvent.AgentSpawn, {
+          agent: {
+            id: hookInput.agentId || hookInput.agent_id || (agentTypeBridge + '-' + Date.now()),
+            type: agentTypeBridge,
+            description: agentDescBridge.slice(0, 500),
+          },
+        }, { continueOnError: true, timeout: 1500 }).catch(function() {});
+      }
+    } catch (e) { /* non-fatal */ }
   },
 };

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

@@ -370,6 +370,84 @@ async function handleSubagentStop(hookInput) {
       ts: Date.now(),
     }) + '\n');
   }
+
+  // ── Wire captured interaction into EpisodicStore ────
+  try {
+    var episodicPath = path.join(CWD, '.monomind', 'episodic', 'episodes.jsonl');
+    var episodicDir = path.dirname(episodicPath);
+    if (!fs.existsSync(episodicDir)) fs.mkdirSync(episodicDir, { recursive: true });
+
+    // Append a lightweight episode entry directly (avoid importing @monomind/memory)
+    var episodeEntry = {
+      episodeId: require('crypto').randomUUID(),
+      sessionId: session || '',
+      runIds: [runId || 'unknown'],
+      summary: [
+        '[agent:' + (agentType || 'unknown') + ']',
+        summary ? summary.slice(0, 500) : '',
+        totalTin ? '[memory:write] tokens_in=' + totalTin : '',
+        totalTout ? '[memory:write] tokens_out=' + totalTout : ''
+      ].filter(Boolean).join('\n'),
+      startedAt: snap.ts || Date.now(),
+      endedAt: Date.now(),
+      agentSlugs: [agentType || 'unknown'],
+      taskTypes: [agentType || 'unknown'],
+      tokenEstimate: Math.ceil(((summary || '').length) / 4)
+    };
+    fs.appendFileSync(episodicPath, JSON.stringify(episodeEntry) + '\n', 'utf-8');
+  } catch (e) { /* non-fatal */ }
+
+  // ── Record agent interaction in Monograph SQLite ────────────────────────────
+  try {
+    var mgDbPath = path.join(CWD, '.monomind', 'monograph.db');
+    if (fs.existsSync(mgDbPath)) {
+      var monographMod = null;
+      var mgCandidates = [
+        path.join(CWD, 'node_modules/.pnpm/node_modules/@monoes/monograph'),
+        path.join(CWD, 'packages/node_modules/.pnpm/node_modules/@monoes/monograph'),
+        path.join(CWD, 'node_modules/@monoes/monograph'),
+      ];
+      for (var mi = 0; mi < mgCandidates.length; mi++) {
+        try { if (fs.existsSync(mgCandidates[mi])) { monographMod = require(mgCandidates[mi]); break; } } catch (e2) {}
+      }
+      if (!monographMod) { try { monographMod = require('@monoes/monograph'); } catch (e2) {} }
+      if (monographMod && monographMod.openDb) {
+        var mgDb = monographMod.openDb(mgDbPath);
+        try {
+          mgDb.prepare(
+            'INSERT OR IGNORE INTO agent_interactions ' +
+            '(id, session_id, org_name, agent_type, parent_agent, prompt_summary, result_summary, tokens_in, tokens_out, cost_usd, success, duration_ms, timestamp) ' +
+            'VALUES (@id, @session_id, @org_name, @agent_type, @parent_agent, @prompt_summary, @result_summary, @tokens_in, @tokens_out, @cost_usd, @success, @duration_ms, @timestamp)'
+          ).run({
+            id: require('crypto').randomUUID(),
+            session_id: session || '',
+            org_name: org || null,
+            agent_type: agentType || 'unknown',
+            parent_agent: null,
+            prompt_summary: agentDesc ? agentDesc.slice(0, 500) : null,
+            result_summary: summary ? summary.slice(0, 1000) : null,
+            tokens_in: totalTin || 0,
+            tokens_out: totalTout || 0,
+            cost_usd: costUsd || 0,
+            success: (function() {
+              // Determine success from result summary — errors/failures/exceptions indicate failure
+              if (summary) {
+                var sumLower = summary.toLowerCase();
+                if (sumLower.includes('error') || sumLower.includes('failed') || sumLower.includes('exception') || sumLower.includes('fatal')) {
+                  return 0;
+                }
+              }
+              return 1;
+            })(),
+            duration_ms: snap.ts ? (Date.now() - snap.ts) : 0,
+            timestamp: Date.now(),
+          });
+        } finally {
+          if (monographMod.closeDb) monographMod.closeDb(mgDb);
+        }
+      }
+    }
+  } catch (e) { /* non-fatal — monograph may not be available */ }
 }
 
 // ─── Phase 3: PreToolUse accumulator (Issue 9) ────────────────────────────────
@@ -424,6 +502,38 @@ async function handlePostTool(hookInput) {
 
   const isBash = toolName === 'bash' || toolName === 'shell';
   const isEdit = toolName === 'edit' || toolName === 'write' || toolName === 'multiedit';
+  const isMemoryStore = toolName.includes('memory_store') || toolName.includes('memory_pattern');
+  const isMemorySearch = toolName.includes('memory_search') || toolName.includes('memory_retrieve');
+
+  // Track real memory ops (writes stats to session file)
+  if (isMemoryStore || isMemorySearch) {
+    try {
+      var sessionId = process.env.CLAUDE_SESSION_ID || '';
+      var statsPath = path.join(CWD, '.monomind', 'memory-ops-' + sessionId.slice(0, 16) + '.json');
+      var stats = { writes: 0, searches: 0, redundantWrites: 0, emptySearches: 0 };
+      try { stats = JSON.parse(fs.readFileSync(statsPath, 'utf-8')); } catch {}
+      if (isMemoryStore) {
+        stats.writes++;
+        // Detect duplicate: response contains "already exists" or "duplicate"
+        var respStr = JSON.stringify(toolResponse).toLowerCase();
+        if (respStr.includes('duplicate') || respStr.includes('already exists') || respStr.includes('skip')) {
+          stats.redundantWrites++;
+        }
+      }
+      if (isMemorySearch) {
+        stats.searches++;
+        // Detect empty results
+        var results = toolResponse.results || toolResponse.entries || toolResponse.data;
+        if (Array.isArray(results) && results.length === 0) {
+          stats.emptySearches++;
+        } else if (toolResponse.count === 0 || toolResponse.total === 0) {
+          stats.emptySearches++;
+        }
+      }
+      fs.mkdirSync(path.dirname(statsPath), { recursive: true });
+      fs.writeFileSync(statsPath, JSON.stringify(stats), 'utf-8');
+    } catch (e) { /* non-fatal */ }
+  }
 
   if (!isBash && !isEdit) return;
 

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

@@ -140,6 +140,21 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
+    // Bridge to @monomind/hooks registry — fires PostEdit hooks (observability bus, guidance provider).
+    // 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 {
+        var editFileBridge = hookInput.file_path || toolInput.file_path
+          || process.env.TOOL_INPUT_file_path || args[0] || '';
+        _hooksModule.executeHooks(_hooksModule.HookEvent.PostEdit, {
+          file: { path: editFileBridge, operation: 'modify' },
+          duration: 0,
+        }, { continueOnError: true, timeout: 1500 }).catch(function() {});
+      } catch (e) { /* non-fatal */ }
+    }
+
     console.log('[OK] Edit recorded');
   }
 };

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

@@ -2,14 +2,8 @@
  * Enforcement Gates Handler
  *
  * Inline gate logic for PreToolUse hooks — no ESM/package dependency.
- *
- * Patterns are an INTENTIONAL SUPERSET of @monomind/guidance/src/gates.ts defaults:
- *   - All categories from DEFAULT_GATE_CONFIG are covered here
- *   - Many patterns are enhanced (e.g. --force-with-lease, -fr reversed flags, broader kubectl)
- *   - Key thresholds MUST stay aligned: password/secret min length = 8 chars (both files)
- *
- * When updating patterns in gates.ts, check whether the corresponding pattern here
- * also needs updating — and vice versa.
+ * This regex table is the canonical (and only) gate definition; the former
+ * @monomind/guidance package it mirrored has been removed.
  *
  * Gates enforced at runtime:
  *   pre-bash  → destructive-ops  (require-confirmation → block)