@monoes/monomindcli 2.7.17 → 2.8.1

package/.claude/helpers/auto-memory-hook.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * Auto Memory Bridge Hook (ADR-048/049) — Minimal Fallback
+ * Full version is copied from package source when available.
+ *
+ * Usage:
+ *   node auto-memory-hook.mjs import   # SessionStart
+ *   node auto-memory-hook.mjs sync     # SessionEnd / Stop
+ *   node auto-memory-hook.mjs status   # Show bridge status
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = join(__dirname, '../..');
+const DATA_DIR = join(PROJECT_ROOT, '.monomind', 'data');
+const STORE_PATH = join(DATA_DIR, 'auto-memory-store.json');
+
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+const dim = (msg) => console.log(`  ${DIM}${msg}${RESET}`);
+
+// Ensure data dir
+if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+
+async function loadMemoryPackage() {
+  // Strategy 1: Use createRequire for CJS-style resolution (handles nested node_modules
+  // when installed as a transitive dependency via npx monomind / npx monomind)
+  try {
+    const { createRequire } = await import('module');
+    const require = createRequire(join(PROJECT_ROOT, 'package.json'));
+    return require('@monoes/memory');
+  } catch { /* fall through */ }
+
+  // Strategy 2: ESM import (works when @monomind/memory is a direct dependency)
+  try { return await import('@monoes/memory'); } catch { /* fall through */ }
+
+  // Strategy 3: Walk up from PROJECT_ROOT looking for the package in any node_modules
+  let searchDir = PROJECT_ROOT;
+  const { parse } = await import('path');
+  while (searchDir !== parse(searchDir).root) {
+    const candidate = join(searchDir, 'node_modules', '@monoes', 'memory', 'dist', 'index.js');
+    if (existsSync(candidate)) {
+      try { return await import(`file://${candidate}`); } catch { /* fall through */ }
+    }
+    searchDir = dirname(searchDir);
+  }
+
+  return null;
+}
+
+async function doImport() {
+  dim('Auto memory import skipped — AutoMemoryBridge removed');
+}
+
+async function doSync() {
+  dim('Auto memory sync skipped — AutoMemoryBridge removed');
+}
+
+function doStatus() {
+  console.log('\n=== Auto Memory Bridge Status ===\n');
+  console.log('  Package:        Fallback mode (run init --upgrade for full)');
+  console.log(`  Store:          ${existsSync(STORE_PATH) ? 'Initialized' : 'Not initialized'}`);
+  console.log('');
+}
+
+// Suppress unhandled rejection warnings ONLY for genuine module-not-found from
+// optional dynamic imports. Previously this swallowed any error whose message
+// contained "Cannot find" (e.g. "Cannot find user with id ..."), masking real
+// failures and security regressions.
+process.on('unhandledRejection', (reason) => {
+  const code = reason && typeof reason === 'object' ? reason.code : undefined;
+  if (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') return;
+  if (reason instanceof Error) throw reason;
+  throw new Error(String(reason));
+});
+
+const command = process.argv[2] || 'status';
+
+try {
+  switch (command) {
+    case 'import': await doImport(); break;
+    case 'sync': await doSync(); break;
+    case 'status': doStatus(); break;
+    default:
+      console.log('Usage: auto-memory-hook.mjs <import|sync|status>');
+      process.exit(1);
+  }
+} catch (err) {
+  // Hooks must never crash Claude Code - fail silently
+  dim(`Error (non-critical): ${err.message}`);
+}
+// Ensure clean exit for Claude Code hooks (exit 0 = success)
+process.exit(0);

package/.claude/helpers/control-start.cjs

@@ -9,6 +9,8 @@
  */
 
 /* eslint-disable @typescript-eslint/no-var-requires */
+// SDK-spawned org agents skip control-server startup — they don't need the dashboard
+if (String(process.env.MONOMIND_SDK_AGENT || '') === '1') process.exit(0);
 const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
@@ -147,7 +149,7 @@ async function main() {
     const { isMemoryPressureCritical, getMemoryInfo } = require('./utils/system-pressure.cjs');
     if (isMemoryPressureCritical()) {
       const info = getMemoryInfo();
-      process.stdout.write(`[control] skipping — memory pressure ${info.level} (${info.usedMB}/${info.totalMB} MB used)\n`);
+      if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") process.stdout.write(`[control] skipping — memory pressure ${info.level} (${info.usedMB}/${info.totalMB} MB used)\n`);
       process.exit(0);
     }
   } catch { /* non-critical — proceed without check */ }
@@ -163,12 +165,12 @@ async function main() {
       const reason = staleProject
         ? `rooted in ${live.dir}, not ${CWD}`
         : `started ${Math.round(startedMs / 86400_000)}d ago`;
-      process.stdout.write(`[control] restarting stale server (${reason})\n`);
+      if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") process.stdout.write(`[control] restarting stale server (${reason})\n`);
       try { process.kill(status.pid, 'SIGTERM'); } catch { /* already gone */ }
       // Give it a moment to release the port
       await new Promise(r => setTimeout(r, 1000));
     } else {
-      process.stdout.write(`[control] already running on port ${status.port} (pid ${status.pid})\n`);
+      if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") process.stdout.write(`[control] already running on port ${status.port} (pid ${status.pid})\n`);
       process.exit(0);
     }
   }
@@ -180,7 +182,7 @@ async function main() {
     const live = await probeStatus(p);
     if (live) {
       writeStatus(live.pid || 0, p);
-      process.stdout.write(`[control] adopted running server on port ${p} (pid ${live.pid || 'unknown'})\n`);
+      if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") process.stdout.write(`[control] adopted running server on port ${p} (pid ${live.pid || 'unknown'})\n`);
       process.exit(0);
     }
   }
@@ -195,7 +197,7 @@ async function main() {
   // spawns leaked hundreds of orphan servers on isolated ports).
   if (process.env.MONOMIND_CONTROL_NO_SPAWN === '1') {
     writeStatus(process.pid, DEFAULT_PORT);
-    process.stdout.write(`[control] started Neural Control Room on port ${DEFAULT_PORT} (pid ${process.pid}) [no-spawn]\n`);
+    if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") process.stdout.write(`[control] started Neural Control Room on port ${DEFAULT_PORT} (pid ${process.pid}) [no-spawn]\n`);
     releaseSpawnLock();
     process.exit(0);
   }
@@ -223,7 +225,7 @@ async function main() {
   // Write optimistic status with DEFAULT_PORT immediately so dependent scripts
   // (hooks, boss agents) have something to read while the server starts up.
   writeStatus(child.pid, DEFAULT_PORT);
-  process.stdout.write(`[control] started Neural Control Room on port ${DEFAULT_PORT} (pid ${child.pid})\n`);
+  if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") process.stdout.write(`[control] started Neural Control Room on port ${DEFAULT_PORT} (pid ${child.pid})\n`);
 
   // If port 4242 was in use, server.mjs auto-increments (up to +10).
   // Poll a few ports to find where it actually bound and update control.json.
@@ -265,7 +267,7 @@ async function main() {
           try { fs.unlinkSync(BOUND_REPORT); } catch { /* ignore */ }
           if (rep.port !== DEFAULT_PORT) {
             writeStatus(child.pid, rep.port);
-            process.stdout.write(`[control] server bound to port ${rep.port} (updated control.json)\n`);
+            if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") process.stdout.write(`[control] server bound to port ${rep.port} (updated control.json)\n`);
           }
           return;
         }
@@ -278,7 +280,7 @@ async function main() {
         if (responderPid === child.pid) {
           if (p !== DEFAULT_PORT) {
             writeStatus(child.pid, p);
-            process.stdout.write(`[control] server bound to port ${p} (updated control.json)\n`);
+            if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") process.stdout.write(`[control] server bound to port ${p} (updated control.json)\n`);
           }
           return;
         }
@@ -292,7 +294,7 @@ async function main() {
       // its own port — point control.json at the live server instead of lying,
       // and kill our redundant child.
       try { process.kill(child.pid, 'SIGTERM'); } catch { /* already gone */ }
-      process.stdout.write(`[control] port ${DEFAULT_PORT} is served by another project's control server — reusing it (killed redundant child)\n`);
+      if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") process.stdout.write(`[control] port ${DEFAULT_PORT} is served by another project's control server — reusing it (killed redundant child)\n`);
       const foreignPid = await probePort(DEFAULT_PORT);
       writeStatus(typeof foreignPid === 'number' ? foreignPid : 0, DEFAULT_PORT);
       // Pair with the foreign server: resolve its project dir from its pid,

package/.claude/helpers/graphify-freshen.cjs

@@ -1,6 +1,8 @@
 'use strict';
 // Runs at SessionStart — rebuilds the knowledge graph using @monoes/monograph in the background.
 // Fire-and-forget: spawns detached child, logs start, exits immediately without blocking session.
+// SDK-spawned org agents skip this — no need to rebuild the graph for each agent session.
+if (String(process.env.MONOMIND_SDK_AGENT || '') === '1') process.exit(0);
 const path = require('path');
 const fs = require('fs');
 const { spawn } = require('child_process');
@@ -82,7 +84,7 @@ if (fs.existsSync(dbPath)) {
         }).trim();
         const behind = parseInt(out, 10);
         if (behind === 0) {
-          console.log('[graph] index is fresh — skipping rebuild');
+          if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') console.log('[graph] index is fresh — skipping rebuild');
           db.close();
           process.exit(0);
         }
@@ -101,7 +103,7 @@ if (fs.existsSync(dbPath)) {
 // is treated as abandoned and safely reclaimed.
 const lockPath = path.join(graphDir, 'build.lock');
 if (!claimLock(lockPath, 5 * 60 * 1000)) {
-  console.log('[graph] build already in progress — skipping');
+  if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') console.log('[graph] build already in progress — skipping');
   process.exit(0);
 }
 
@@ -145,4 +147,4 @@ try {
   fs.writeFileSync(path.join(graphDir, 'build.pid'), String(child.pid), 'utf-8');
 } catch { /* best-effort */ }
 
-console.log('[graph] background build started for ' + projectDir);
+if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') console.log('[graph] background build started for ' + projectDir);

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

@@ -25,6 +25,7 @@ const crypto = require('crypto');
 const { appendJsonlWithRotation } = require('../utils/fs-helpers.cjs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+var _QUIET = String(process.env.MONOMIND_HOOK_QUIET || '').toLowerCase() === '1';
 const CAPTURE_DIR = path.join(CWD, '.monomind', 'capture');
 const SNAP_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour — orphaned snapshots are cleaned up this old
 
@@ -281,7 +282,7 @@ async function handleSubagentStart(hookInput) {
     leanMode: leanMode || 'off',
   }));
 
-  console.log('[CAPTURE:start] ' + agentType + ' · snapped ' + snapshot.length + ' files'
+  _QUIET || console.log('[CAPTURE:start] ' + agentType + ' · snapped ' + snapshot.length + ' files'
     + (activeSess ? ' · sess=' + activeSess.sessionId : '')
     + (activeRun ? ' · run=' + activeRun.runId : ' · no active run'));
 
@@ -324,11 +325,11 @@ async function handleSubagentStop(hookInput) {
       .filter(f => f.startsWith('snap-') && f.endsWith('.json') && !f.startsWith('._'))
       .sort(); // lexicographic = timestamp order (FIFO fallback)
     if (snapFiles.length === 0) {
-      console.log('[CAPTURE:stop] No snapshot to diff — skipping');
+      _QUIET || console.log('[CAPTURE:stop] No snapshot to diff — skipping');
       return;
     }
     snapPath = path.join(CAPTURE_DIR, snapFiles[0]);
-    console.log('[CAPTURE:stop] no transcript_path/keyed snapshot — falling back to FIFO match');
+    _QUIET || console.log('[CAPTURE:stop] no transcript_path/keyed snapshot — falling back to FIFO match');
   }
 
   let snap;
@@ -389,7 +390,7 @@ async function handleSubagentStop(hookInput) {
   const { agentType, agentDesc } = snap;
   toolCalls = [...new Set(toolCalls)].slice(0, 20);
 
-  console.log('[CAPTURE:stop] ' + agentType + ' · ' + totalTin + '+' + totalTout
+  _QUIET || console.log('[CAPTURE:stop] ' + agentType + ' · ' + totalTin + '+' + totalTout
     + ' tok · $' + costUsd.toFixed(4) + ' · ' + capturedFiles.length + ' new files'
     + (session ? ' · sess=' + session : '')
     + (org ? ' · ' + org + '/' + runId : ''));
@@ -729,7 +730,7 @@ if (require.main === module) {
     if (eventType === 'subagent-stop')  return handleSubagentStop(hookInput);
     if (eventType === 'pretool')        return handlePreTool(hookInput);
     if (eventType === 'posttool')       return handlePostTool(hookInput);
-    console.log('[CAPTURE] unknown event type: ' + eventType);
+    _QUIET || console.log('[CAPTURE] unknown event type: ' + eventType);
   }).catch(() => process.exit(0));
 }
 

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

@@ -121,6 +121,26 @@ module.exports = {
       const routeFn = router.routeTaskSemantic || router.routeTask;
       var result = await Promise.resolve(routeFn(prompt));
 
+      // When QUIET: the advisory output is suppressed anyway, so skip ALL the
+      // expensive enrichment below (embedding search, second-brain HTTP, monograph
+      // DB queries, metrics reads, episodes search). Just persist the keyword
+      // route for the statusline and exit — this makes the hook nearly instant.
+      if (_HOOK_QUIET) {
+        try {
+          var routeDir = path.join(CWD, '.monomind');
+          fs.mkdirSync(routeDir, { recursive: true });
+          fs.writeFileSync(path.join(routeDir, 'last-route.json'), JSON.stringify({
+            agent: result.agent || 'coder',
+            agentSlug: result.agentSlug || null,
+            confidence: result.confidence,
+            reason: result.reason,
+            prompt: (prompt || '').slice(0, 500),
+            updatedAt: new Date().toISOString(),
+          }), 'utf-8');
+        } catch (e) { /* non-fatal */ }
+        return;
+      }
+
       // ── Enrichment: when router.cjs falls to the broad "coder" catch-all,
       //    try @monoes/routing's richer keyword pre-filter (30+ specialized
       //    rules for Solidity, game engines, DevOps, embedded, etc.) for a

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

@@ -6,6 +6,12 @@ const path = require('path');
 const fs = require('fs');
 const { injectGodNodesContext } = require('../utils/monograph.cjs');
 
+// QUIET gate — when MONOMIND_HOOK_QUIET=1, suppress ALL session-restore stdout.
+// Session-start output gets cached by Claude Code and re-read on every subsequent
+// message, so even small per-session injections compound into major token costs.
+var _QUIET = String(process.env.MONOMIND_HOOK_QUIET || '').toLowerCase() === '1';
+function log() { if (!_QUIET) console.log.apply(console, arguments); }
+
 module.exports = {
   handleRestore: async function(hCtx) {
     var hookInput = hCtx.hookInput;
@@ -26,9 +32,9 @@ module.exports = {
           session.start && session.start();
         }
       } else {
-        console.log('[OK] Session restored: session-' + Date.now());
+        log('[OK] Session restored: session-' + Date.now());
       }
-    } catch (e) { console.log('[WARN] Session restore failed: ' + e.message); }
+    } catch (e) { log('[WARN] Session restore failed: ' + e.message); }
 
     // ── Non-blocking security scan via @monoes/hooks worker ─────────────
     // The hooks package ships a security worker (worker-security.ts) that scans
@@ -152,7 +158,7 @@ module.exports = {
             }
           }
           if (healed.length > 0) {
-            console.log('[STALE_HELPERS] Refreshed ' + healed.length + ' helper(s) from bundled version: ' + healed.join(', '));
+            log('[STALE_HELPERS] Refreshed ' + healed.length + ' helper(s) from bundled version: ' + healed.join(', '));
           }
         }
 
@@ -215,14 +221,14 @@ module.exports = {
         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');
+          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');
+        log('[INTELLIGENCE] Loaded ' + initResult.nodes + ' patterns, ' + initResult.edges + ' edges');
       }
     }
 
@@ -235,7 +241,7 @@ module.exports = {
       var hooksModule = hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : await import('@monoes/hooks');
       if (hooksModule) {
         hCtx._hooksModule = hooksModule;
-        console.log('[INFO] @monoes/hooks workers initialized');
+        log('[INFO] @monoes/hooks workers initialized');
 
         // Gate enforcement lives entirely in gates-handler.cjs (its own regex
         // table, run on every PreToolUse). The @monomind/guidance package that
@@ -317,7 +323,7 @@ module.exports = {
       var knowledgeDir = path.join(CWD, '.monomind', 'knowledge');
       var indexed = _autoIndexKnowledge(knowledgeDir);
       if (indexed > 0) {
-        console.log('[KNOWLEDGE_INDEXED] ' + indexed + ' chunks written from project sources');
+        log('[KNOWLEDGE_INDEXED] ' + indexed + ' chunks written from project sources');
       }
 
       var kSearchFn = _buildKnowledgeSearchFn(knowledgeDir);
@@ -333,12 +339,12 @@ module.exports = {
         var kRetriever = new memoryMod.KnowledgeRetriever(kSearchFn, kStore);
         var kResult = await kRetriever.retrieveForTask('shared', sessionCtx, 5);
         if (kResult.excerpts.length > 0) {
-          if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') console.log('[KNOWLEDGE_PRELOADED] ' + kResult.excerpts.length + ' excerpts (KnowledgeRetriever)');
+          if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') 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) {
-          if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') console.log('[KNOWLEDGE_PRELOADED] ' + directResults.length + ' excerpts (direct keyword search)');
+          if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') log('[KNOWLEDGE_PRELOADED] ' + directResults.length + ' excerpts (direct keyword search)');
         }
       }
     } catch (e) { /* non-fatal */ }
@@ -422,7 +428,7 @@ module.exports = {
             // unhandled 'error' event and crashes the whole session-start hook.
             _kbChild.on('error', function () { /* npx unavailable — reindex on a later session */ });
             _kbChild.unref();
-            console.log('[KNOWLEDGE_REINDEX] changed documents detected — re-ingesting in background');
+            log('[KNOWLEDGE_REINDEX] changed documents detected — re-ingesting in background');
           }
         }
       }
@@ -448,7 +454,9 @@ module.exports = {
         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');
+          log('[SHARED_INSTRUCTIONS] Loaded ' + sharedInstrSafe.length + ' chars from .agents/shared_instructions.md');
+          // Content injection — NOT gated by QUIET. This is the only path for
+          // shared agent instructions to reach the LLM (no MCP tool exposes it).
           console.log(sharedInstrSafe);
         }
       }
@@ -458,7 +466,8 @@ module.exports = {
         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');
+          log('[SHARED_INSTRUCTIONS] Loaded ' + siContentSafe.length + ' chars from .agents/shared_instructions.md');
+          // Content injection — NOT gated by QUIET (see above).
           console.log(siContentSafe);
         }
       } catch (e2) { /* non-fatal */ }
@@ -469,6 +478,8 @@ module.exports = {
       var palace = require(path.join(helpersDir, 'memory-palace.cjs'));
       var palaceContext = palace.wakeUp(CWD);
       if (palaceContext) {
+        // Content injection — NOT gated by QUIET. wakeUp() is called only here;
+        // no other hook or MCP tool exposes L0/L1 palace context to the LLM.
         console.log(palaceContext);
       }
     } catch (e) { /* non-fatal — palace not available */ }
@@ -525,7 +536,7 @@ module.exports = {
         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)');
+            log('[UPDATE_AVAILABLE] @monomind/cli ' + upd.from + ' → ' + upd.to + ' (run: npx monomind update)');
           }
         }
       } catch (e) {}
@@ -536,7 +547,7 @@ module.exports = {
       var tokenTracker = require(path.join(helpersDir, 'token-tracker.cjs'));
       var tokenSummary = tokenTracker.quickSummary();
       if (tokenSummary) {
-        if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') console.log(tokenSummary);
+        if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') log(tokenSummary);
       }
       try {
         var tokenData = tokenTracker.quickSummaryData();
@@ -557,7 +568,7 @@ module.exports = {
         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');
+          log('[REGISTRY] ' + agentCount + ' agents available in registry');
         }
       }
     } catch (e) { /* non-fatal */ }
@@ -575,13 +586,13 @@ module.exports = {
         var controlPort = 4242;
         var req = http.get('http://localhost:' + controlPort + '/', function(res) {
           if (res.statusCode === 200) {
-            console.log('[CONTROL_UI] UP — http://localhost:' + controlPort);
+            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');
+          log('[CONTROL_UI] offline — restart with: npx monomind mcp start');
         });
         req.setTimeout(800, function() { req.destroy(); });
       } catch (e) { /* non-fatal */ }

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

@@ -282,6 +282,17 @@ async function main() {
     || (typeof toolInput === 'string' ? toolInput : (toolInput.command || toolInput.prompt || ''))
     || process.env.PROMPT || process.env.TOOL_INPUT_command || '';
 
+  // SDK-spawned org agent sessions: skip ALL non-security hooks to eliminate
+  // the #1 token-burn source. Each org agent fires UserPromptSubmit/PreToolUse/
+  // PostToolUse hooks per message, re-reading massive cached context on every
+  // turn. Org agents have their own role prompt + tools — they don't need
+  // routing, intelligence injection, monograph suggestions, or skill matching.
+  // Security gates (pre-bash destructive-ops, pre-write secrets) still run.
+  if (String(process.env.MONOMIND_SDK_AGENT || '') === '1'
+      && command !== 'pre-bash' && command !== 'pre-write') {
+    process.exit(0);
+  }
+
   // Detect prompts that are predefined single-action commands that don't
   // need agent routing or skill suggestions — invoking those adds token
   // overhead without any benefit.

package/.claude/helpers/monolean-activate.cjs

@@ -3,6 +3,9 @@ const { getDefaultMode, setMode, clearMode } = require('./monolean-config.cjs');
 const fs = require('fs');
 const path = require('path');
 
+// SDK-spawned org agents don't need monolean mode injection
+if (String(process.env.MONOMIND_SDK_AGENT || '') === '1') process.exit(0);
+
 const mode = getDefaultMode();
 if (!mode || mode === 'off') { clearMode(); process.exit(0); }
 
@@ -17,14 +20,19 @@ try {
 
 // monolean: compact session-start directive. The full SKILL.md loads on-demand
 // via /monolean — session context just needs the core rules.
-process.stdout.write(
-  'MONOLEAN MODE ACTIVE — level: ' + mode + '\n\n' +
-  'Lazy senior dev mode. Lazy = efficient. Best code = code never written.\n' +
-  'The ladder (stop at first rung that holds): ' +
-  '1) YAGNI 2) Already in codebase? Reuse 3) Stdlib 4) Native platform 5) Installed dep 6) One line 7) Minimum code.\n' +
-  'Read the code first, trace the real flow, THEN climb the ladder.\n' +
-  'Bug fix = root cause fix. No unrequested abstractions. Deletion > addition. Fewest files. Code first, 3 lines max explanation.\n' +
-  'Never lean away: trust-boundary validation, data-loss prevention, security, accessibility, explicit user requests.\n' +
-  'Mark deliberate simplifications: `// monolean: [ceiling] — [upgrade path]`\n' +
-  'Off: "stop monolean". Switch: `/monolean lite|full|ultra`.\n'
-);
+// Respect QUIET — when set, output a single-line tag instead of the full directive.
+if (String(process.env.MONOMIND_HOOK_QUIET || '').toLowerCase() === '1') {
+  process.stdout.write('monolean:' + mode + '\n');
+} else {
+  process.stdout.write(
+    'MONOLEAN MODE ACTIVE — level: ' + mode + '\n\n' +
+    'Lazy senior dev mode. Lazy = efficient. Best code = code never written.\n' +
+    'The ladder (stop at first rung that holds): ' +
+    '1) YAGNI 2) Already in codebase? Reuse 3) Stdlib 4) Native platform 5) Installed dep 6) One line 7) Minimum code.\n' +
+    'Read the code first, trace the real flow, THEN climb the ladder.\n' +
+    'Bug fix = root cause fix. No unrequested abstractions. Deletion > addition. Fewest files. Code first, 3 lines max explanation.\n' +
+    'Never lean away: trust-boundary validation, data-loss prevention, security, accessibility, explicit user requests.\n' +
+    'Mark deliberate simplifications: `// monolean: [ceiling] — [upgrade path]`\n' +
+    'Off: "stop monolean". Switch: `/monolean lite|full|ultra`.\n'
+  );
+}