monomind 1.19.0 → 2.0.0

package/packages/@monomind/cli/dist/src/index.js

@@ -413,16 +413,11 @@ export class CLI {
     }
     /**
      * Initialize optional subsystems at startup (non-blocking, all failures are silent).
-     * Wires TierManager, ObservabilityBus + TraceCollector, and SwarmCheckpointer
-     * so that packages/@monomind/* actually contribute to the live runtime.
+     * Starts the @monomind/hooks WorkerManager, wires SwarmCheckpointer, and builds
+     * the unified agent registry so that packages/@monomind/* actually contribute
+     * to the live runtime.
      */
     async initSubsystems() {
-        // GAP-004/005/006: Register background workers (EntityExtractor, EpisodeBinner, TraceCollector)
-        try {
-            const { initDefaultWorkers } = await import('@monomind/hooks');
-            await initDefaultWorkers();
-        }
-        catch { /* optional */ }
         // Start the @monomind/hooks WorkerManager (performance/health/swarm/git/learning/
         // adr/ddd/security/patterns/cache/progress) — previously implemented but never invoked
         try {
@@ -462,10 +457,12 @@ export class CLI {
         // runs it synchronously within its own check pass instead, so it's always
         // visible and itemized when you actually look for it.
         // NOTE: Semantic routing (@monomind/routing) is constructed on-demand by
-        // its consumers — `monomind route` and `monomind agent --task` (see
-        // commands/route.ts and commands/agent.ts). It is intentionally NOT
-        // eagerly initialized here: building all route centroids and probing for
-        // the `claude` CLI on every CLI startup would regress the <500ms startup
+        // its consumers — `monomind route semantic` (commands/route.ts) and the
+        // `hooks_route_semantic` MCP tool (mcp-tools/hooks-routing.ts), both via
+        // routing/route-layer-factory.ts. `monomind agent` has no --task flag —
+        // that routing point does not exist yet. It is intentionally NOT eagerly
+        // initialized here: building all route centroids and probing for the
+        // `claude` CLI on every CLI startup would regress the <500ms startup
         // budget for zero benefit (nothing reads a process-global route layer).
     }
     /**

package/packages/@monomind/cli/dist/src/init/claudemd-generator.js

@@ -194,10 +194,7 @@ function agentTypes() {
 \`hierarchical-coordinator\`, \`mesh-coordinator\`, \`adaptive-coordinator\`
 
 ### GitHub & Repository
-\`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\`
-
-### SPARC Methodology
-\`sparc-coord\`, \`sparc-coder\`, \`specification\`, \`pseudocode\`, \`architecture\``;
+\`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\``;
 }
 function hooksSystem() {
     return `## Hooks System (27 Hooks + 12 Workers)
@@ -213,21 +210,23 @@ function hooksSystem() {
 | \`intelligence\` | Pattern-learning intelligence system |
 | \`worker\` | Background worker management |
 
-### 12 Background Workers
+### Background Workers (@monomind/hooks, run in-process)
 
 | Worker | Priority | Description |
 |--------|----------|-------------|
-| \`optimize\` | high | Performance optimization |
-| \`audit\` | critical | Security analysis |
-| \`testgaps\` | normal | Test coverage analysis |
 | \`map\` | normal | Codebase mapping |
-| \`deepdive\` | normal | Deep code analysis |
-| \`document\` | normal | Auto-documentation |
+| \`audit\` | high | Security audit |
+| \`optimize\` | normal | Performance snapshot |
+| \`consolidate\` | low | Memory consolidation |
+| \`ddd\` | low | DDD progress tracking |
+| \`security\` | high | Secret/vulnerability scan |
+
+Metrics-producing workers refresh at session start when output is >6h old.
 
 \`\`\`bash
 npx monomind@latest hooks pre-task --description "[task]"
 npx monomind@latest hooks post-task --task-id "[id]" --success true
-npx monomind@latest hooks worker dispatch --trigger audit
+npx monomind@latest hooks worker run audit
 \`\`\``;
 }
 function learningProtocol() {
@@ -428,9 +427,6 @@ function setupAndBoundary() {
 # Add MCP server — includes monograph, swarm, memory, hooks, all 200+ tools
 claude mcp add monomind -- npx -y monomind@latest mcp start
 
-# Start background workers
-npx monomind@latest daemon start
-
 # Verify everything works
 npx monomind@latest doctor --fix
 \`\`\`

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -45,15 +45,11 @@ const SKILLS_MAP = {
     core: [
         'swarm-orchestration',
         'swarm-advanced',
-        'swarm-coordination',
-        'sparc-methodology',
         'hooks-automation',
         'pair-programming',
         'verification-quality',
-        'stream-chain',
         'skill-builder',
         'specialagent',
-        'mastermind',
         'monodesign',
         'monomotion',
         'monolean',
@@ -62,35 +58,22 @@ const SKILLS_MAP = {
         'monolean-debt',
         'monolean-help',
         'hive-mind-advanced',
+        // The mastermind command files installed by init invoke
+        // Skill("mastermind-skills:*") at runtime — this directory must ship
+        // with core or those references break in user projects.
+        'mastermind-skills',
     ],
     browser: ['agent-browser-testing'],
-    memory: [
-        'memory-advanced',
-        'memory-learning',
-        'memory-patterns',
-        'memory-optimization',
-        'memory-vector-search',
-        'memory-reasoningbank',
-        'reasoningbank-intelligence',
-    ],
-    github: [
-        'github-code-review',
-        'github-multi-repo',
-        'github-project-management',
-        'github-release-management',
-        'github-workflow-automation',
-    ],
+    // NOTE: memory-toolkit and github-toolkit are single consolidated skills
+    // (not one skill per capability) — see .claude/skills/memory-toolkit and
+    // .claude/skills/github-toolkit. The finer-grained names previously listed
+    // here (memory-advanced, github-code-review, etc.) never had matching
+    // source directories and silently copied nothing.
+    memory: ['memory-toolkit'],
+    github: ['github-toolkit'],
     advanced: [
-        'agentic-integration',
         'agentic-jujutsu',
-        'cli-modernization',
-        'core-implementation',
-        'ddd-architecture',
-        'mcp-optimization',
-        'memory-unification',
         'performance-analysis',
-        'performance-optimization',
-        'security-hardening',
     ],
 };
 /**
@@ -98,7 +81,7 @@ const SKILLS_MAP = {
  */
 const COMMANDS_MAP = {
     core: [
-        'mastermind.md', 'tokens.md', 'monobrowse.md', 'sparc.md', 'ts.md',
+        'mastermind.md', 'tokens.md', 'monobrowse.md', 'ts.md',
     ],
     agents: ['agents'],
     analysis: ['analysis'],
@@ -114,7 +97,6 @@ const COMMANDS_MAP = {
     monomind: ['mastermind'],
     optimization: ['optimization'],
     pair: ['pair'],
-    sparc: ['sparc'],
     streamChain: ['stream-chain'],
     swarm: ['swarm'],
     training: ['training'],
@@ -152,7 +134,6 @@ const AGENTS_MAP = {
     sales: ['sales'],
     schemas: ['schemas'],
     sona: ['sona'],
-    sparc: ['sparc'],
     spatialComputing: ['spatial-computing'],
     specialists: ['specialists'],
     specialized: ['specialized'],
@@ -307,8 +288,6 @@ export async function executeInit(options) {
         else if (options.components.graphify) {
             result.skipped.push('knowledge graph: not a code project (skipping monograph indexing)');
         }
-        // Start daemon with background workers (non-blocking)
-        await startDaemonBackground(targetDir, result);
         // Run doctor auto-fix (non-blocking, best-effort)
         await runDoctorFix(targetDir, result);
         // Register this project in ~/.monomind-projects.json so upgrade --all finds it
@@ -408,36 +387,6 @@ try { await buildAsync(${JSON.stringify(targetDir)}); } finally {
     }
     result.created.files.push('.monomind/graph/ (knowledge graph building in background)');
 }
-/**
- * Start the monomind daemon with background workers.
- * Non-fatal: if daemon fails to start, init continues.
- */
-async function startDaemonBackground(targetDir, result) {
-    try {
-        const { execSync } = await import('child_process');
-        // Check if daemon is already running
-        const pidFile = path.join(targetDir, '.monomind', 'daemon.pid');
-        const { existsSync, readFileSync, statSync: statSyncPid } = await import('fs');
-        if (existsSync(pidFile) && statSyncPid(pidFile).size <= 1024) {
-            const pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
-            try {
-                process.kill(pid, 0);
-                result.skipped.push('daemon: already running (PID ' + pid + ')');
-                return;
-            }
-            catch { /* stale PID, continue */ }
-        }
-        execSync('npx monomind@latest daemon start --background', {
-            cwd: targetDir,
-            stdio: 'ignore',
-            timeout: 15000,
-        });
-        result.created.files.push('monomind daemon (background workers started)');
-    }
-    catch {
-        result.skipped.push('daemon: could not auto-start (run: monomind daemon start)');
-    }
-}
 /**
  * Run doctor --install to auto-fix any remaining issues.
  * Non-fatal: best-effort health check and auto-install.
@@ -1024,6 +973,12 @@ async function copySkills(targetDir, options, result) {
             result.created.files.push(`.claude/skills/${skillName}`);
             result.summary.skillsCount++;
         }
+        else {
+            // A skill referenced in SKILLS_MAP has no matching source directory —
+            // surface this instead of silently copying nothing, so drift between
+            // SKILLS_MAP and the actual .claude/skills/ tree gets caught.
+            result.errors.push(`Skill '${skillName}' listed in SKILLS_MAP has no source directory at ${sourcePath} — skipped`);
+        }
     }
 }
 /**
@@ -1068,8 +1023,6 @@ async function copyCommands(targetDir, options, result) {
             commandsToCopy.push(...COMMANDS_MAP.optimization);
         if (commandsConfig.pair)
             commandsToCopy.push(...(COMMANDS_MAP.pair || []));
-        if (commandsConfig.sparc)
-            commandsToCopy.push(...COMMANDS_MAP.sparc);
         if (commandsConfig.streamChain)
             commandsToCopy.push(...(COMMANDS_MAP.streamChain || []));
         if (commandsConfig.swarm)
@@ -1139,8 +1092,6 @@ async function copyAgents(targetDir, options, result) {
             agentsToCopy.push(...AGENTS_MAP.github);
         if (agentsConfig.hiveMind)
             agentsToCopy.push(...AGENTS_MAP.hiveMind);
-        if (agentsConfig.sparc)
-            agentsToCopy.push(...AGENTS_MAP.sparc);
         if (agentsConfig.swarm)
             agentsToCopy.push(...AGENTS_MAP.swarm);
         if (agentsConfig.optimization)
@@ -1524,7 +1475,7 @@ async function writeInitialMetrics(targetDir, options, result) {
                 patternsLearned: 0,
                 sessionsCompleted: 0
             },
-            _note: 'Metrics will update as you use Monomind. Run: npx monomind@latest daemon start'
+            _note: 'Metrics will update as you use Monomind (workers refresh at session start).'
         };
         atomicWriteFile(progressPath, JSON.stringify(progress, null, 2));
         result.created.files.push('.monomind/metrics/v1-progress.json');
@@ -1690,9 +1641,6 @@ npx monomind@latest swarm monitor
 ### GitHub & Repository (9)
 \`github-modes\`, \`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\`, \`workflow-automation\`, \`project-board-sync\`, \`repo-architect\`, \`multi-repo-swarm\`
 
-### SPARC Methodology (6)
-\`sparc-coord\`, \`sparc-coder\`, \`specification\`, \`pseudocode\`, \`architecture\`, \`refinement\`
-
 ### Specialized Development (8)
 \`backend-dev\`, \`mobile-dev\`, \`ml-developer\`, \`cicd-engineer\`, \`api-docs\`, \`system-architect\`, \`code-analyzer\`, \`base-template-generator\`
 
@@ -1732,7 +1680,6 @@ npx monomind@latest swarm monitor
 ### Advanced Commands (14)
 | Command | Subcommands | Description |
 |---------|-------------|-------------|
-| \`daemon\` | 5 | Background workers |
 | \`neural\` | 5 | Pattern training |
 | \`security\` | 6 | Security scanning |
 | \`performance\` | 5 | Profiling & benchmarks |
@@ -1800,21 +1747,28 @@ npx monomind@latest doctor --fix
 | \`coverage-suggest\` | Improvement suggestions |
 | \`coverage-gaps\` | Gap analysis |
 
-### 12 Background Workers
+### 15 Background Workers (@monomind/hooks, run in-process)
 | Worker | Priority | Purpose |
 |--------|----------|---------|
-| \`ultralearn\` | normal | Deep knowledge |
-| \`optimize\` | high | Performance |
-| \`consolidate\` | low | Memory consolidation |
-| \`predict\` | normal | Predictive preload |
-| \`audit\` | critical | Security |
+| \`performance\` | normal | Benchmark performance |
+| \`health\` | high | System health monitoring |
+| \`swarm\` | high | Swarm activity monitoring |
+| \`git\` | normal | Branch/change tracking |
+| \`learning\` | normal | Learning optimization |
+| \`adr\` | low | ADR compliance |
+| \`ddd\` | low | DDD progress |
+| \`security\` | high | Secret/vulnerability scan |
+| \`patterns\` | normal | Pattern consolidation |
+| \`cache\` | background | Cache cleanup |
+| \`progress\` | normal | Progress tracking |
 | \`map\` | normal | Codebase mapping |
-| \`preload\` | low | Resource preload |
-| \`deepdive\` | normal | Deep analysis |
-| \`document\` | normal | Auto-docs |
-| \`refactor\` | normal | Suggestions |
-| \`benchmark\` | normal | Benchmarking |
-| \`testgaps\` | normal | Coverage gaps |
+| \`audit\` | high | Security audit metrics |
+| \`optimize\` | normal | Performance snapshot |
+| \`consolidate\` | low | Memory consolidation |
+
+Metrics-producing workers (ddd, map, audit, optimize, consolidate) refresh at
+session start when their output is >6h old; run on demand with
+\`monomind hooks worker run <name>\`.
 
 ---
 
@@ -1943,7 +1897,6 @@ claude mcp add monomind -- npx -y monomind@latest mcp start
 \`\`\`bash
 # Setup
 npx monomind@latest init --wizard
-npx monomind@latest daemon start
 npx monomind@latest doctor --fix
 
 # Swarm
@@ -1959,7 +1912,7 @@ npx monomind@latest memory search --query "patterns"
 
 # Hooks
 npx monomind@latest hooks pre-task --description "task"
-npx monomind@latest hooks worker dispatch --trigger optimize
+npx monomind@latest hooks worker run optimize
 \`\`\`
 
 ### File Structure

package/packages/@monomind/cli/dist/src/init/settings-generator.js

@@ -105,18 +105,6 @@ export function generateSettings(options) {
         neural: {
             enabled: options.runtime.enableNeural,
         },
-        daemon: {
-            autoStart: false, // Opt-in only — prevents unintended token consumption (#1427, #1330)
-            workers: [
-                'map', // Codebase mapping
-                'audit', // Security auditing (critical priority)
-                'optimize', // Performance optimization (high priority)
-            ],
-            schedules: {
-                audit: { interval: '4h', priority: 'critical' },
-                optimize: { interval: '2h', priority: 'high' },
-            },
-        },
         learning: {
             enabled: true,
             autoTrain: true,

package/packages/@monomind/cli/dist/src/init/statusline-generator.js

@@ -846,6 +846,39 @@ function getTriggerStats() {
   } catch { return { triggers: 0, agents: 0 }; }
 }
 
+// Daemon worker alerts — security-audit, testgaps, benchmark. Fast: single
+// stat + JSON.parse per file (files are small, KB-scale), skip entirely when
+// the worker hasn't run yet (no metrics dir / file) so cold projects pay
+// zero cost beyond the existsSync check.
+function getDaemonAlerts() {
+  const metricsDir = path.join(CWD, '.monomind', 'metrics');
+  const out = { security: null, testgaps: null, benchmark: null };
+  if (!fs.existsSync(metricsDir)) return out;
+
+  const audit = readJSON(path.join(metricsDir, 'security-audit.json'));
+  if (audit) {
+    const riskLevel = (audit.riskLevel || 'low').toLowerCase();
+    const findings = (audit.recommendations || []).length + (audit.priorityScanTargets || []).length;
+    out.security = { riskLevel, findings };
+  }
+
+  const gaps = readJSON(path.join(metricsDir, 'testgaps.json'));
+  if (gaps) {
+    const gapList = Array.isArray(gaps.gaps) ? gaps.gaps : [];
+    const uncovered = gaps.uncoveredCount ?? gapList.length;
+    if (uncovered > 0 || gapList.length > 0) out.testgaps = { uncovered };
+  }
+
+  const bench = readJSON(path.join(metricsDir, 'benchmark.json'));
+  if (bench?.benchmarks) {
+    const heapMB = bench.benchmarks.memoryUsage ? Math.floor(bench.benchmarks.memoryUsage.heapUsed / 1024 / 1024) : null;
+    const uptimeMin = bench.benchmarks.uptime ? Math.floor(bench.benchmarks.uptime / 60) : null;
+    out.benchmark = { heapMB, uptimeMin, timestamp: bench.timestamp };
+  }
+
+  return out;
+}
+
 // Hook latency — surface slow per-prompt hooks in the statusline.
 function getHookLatency() {
   const p = path.join(CWD, '.monomind', 'metrics', 'hook-latency.json');
@@ -1059,6 +1092,15 @@ function generateStatusline() {
     parts.push(\`\${x.mint}⚡ \${hooks.enabled}h\${x.reset}\`);
   }
 
+  // Daemon alerts — only show when there's something worth flagging
+  const alerts = getDaemonAlerts();
+  if (alerts.security && (alerts.security.riskLevel === 'high' || alerts.security.riskLevel === 'critical')) {
+    parts.push(\`\${x.coral}🛡 \${alerts.security.findings}\${x.reset}\`);
+  }
+  if (alerts.testgaps && alerts.testgaps.uncovered > 0) {
+    parts.push(\`\${x.gold}🧪 \${alerts.testgaps.uncovered}\${x.reset}\`);
+  }
+
   return parts.join(\`  \${DIV}  \`);
 }
 
@@ -1178,6 +1220,25 @@ function generateDashboard() {
 
   lines.push(\`\${x.teal}🧠  CONTEXT\${x.reset}  \${graphStr}\${hilStr}\`);
 
+  // ── Row 3: Daemon worker alerts (security / testgaps / benchmark) ──
+  const alerts = getDaemonAlerts();
+  const alertParts = [];
+  if (alerts.security) {
+    const s = alerts.security;
+    const col = s.riskLevel === 'critical' || s.riskLevel === 'high' ? x.coral : s.findings > 0 ? x.gold : x.green;
+    alertParts.push(\`\${col}🛡 sec \${s.riskLevel}\${s.findings > 0 ? \` (\${s.findings})\` : ''}\${x.reset}\`);
+  }
+  if (alerts.testgaps) {
+    alertParts.push(\`\${x.gold}🧪 gaps \${alerts.testgaps.uncovered}\${x.reset}\`);
+  }
+  if (alerts.benchmark && alerts.benchmark.heapMB !== null) {
+    alertParts.push(\`\${x.slate}⏱ bench heap \${alerts.benchmark.heapMB}MB\${alerts.benchmark.uptimeMin !== null ? \` up \${alerts.benchmark.uptimeMin}m\` : ''}\${x.reset}\`);
+  }
+  if (alertParts.length > 0) {
+    lines.push(SEP);
+    lines.push(\`\${x.purple}⚙️  WORKERS\${x.reset}  \${alertParts.join(\`   \${DIV}   \`)}\`);
+  }
+
   return lines.join('\\n');
 }
 
@@ -1195,6 +1256,7 @@ function generateJSON() {
     lancedb: getMemoryStats(),
     tests:      getTestStats(),
     git:        { modified: git.modified, untracked: git.untracked, staged: git.staged, ahead: git.ahead, behind: git.behind },
+    daemonAlerts: getDaemonAlerts(),
     lastUpdated: new Date().toISOString(),
   };
 }

package/packages/@monomind/cli/dist/src/init/types.d.ts

@@ -64,7 +64,7 @@ export interface HooksConfig {
  * Skills configuration
  */
 export interface SkillsConfig {
-    /** Include core skills (swarm, sparc, mastermind, monodesign, monomotion) */
+    /** Include core skills (swarm, mastermind, monodesign, monomotion) */
     core: boolean;
     /** Include memory/LanceDB skills */
     memory: boolean;
@@ -81,7 +81,7 @@ export interface SkillsConfig {
  * Commands configuration
  */
 export interface CommandsConfig {
-    /** Include core commands (mastermind.md, tokens.md, browse.md, sparc.md, ts.md) */
+    /** Include core commands (mastermind.md, tokens.md, browse.md, ts.md) */
     core: boolean;
     /** Include agents commands */
     agents?: boolean;
@@ -111,8 +111,6 @@ export interface CommandsConfig {
     optimization: boolean;
     /** Include pair commands */
     pair?: boolean;
-    /** Include SPARC commands */
-    sparc: boolean;
     /** Include stream-chain commands */
     streamChain?: boolean;
     /** Include swarm commands */
@@ -140,8 +138,6 @@ export interface AgentsConfig {
     github: boolean;
     /** Include hive-mind agents */
     hiveMind: boolean;
-    /** Include SPARC agents */
-    sparc: boolean;
     /** Include swarm coordinators */
     swarm: boolean;
     /** Include optimization agents */

package/packages/@monomind/cli/dist/src/init/types.js

@@ -87,7 +87,6 @@ export const DEFAULT_INIT_OPTIONS = {
         hooks: true,
         monitoring: true,
         optimization: true,
-        sparc: true,
         all: true,
     },
     agents: {
@@ -95,7 +94,6 @@ export const DEFAULT_INIT_OPTIONS = {
         consensus: true,
         github: true,
         hiveMind: true,
-        sparc: true,
         swarm: true,
         optimization: true,
         testing: true,
@@ -173,7 +171,6 @@ export const MINIMAL_INIT_OPTIONS = {
         consensus: false,
         github: false,
         hiveMind: false,
-        sparc: false,
         swarm: false,
         optimization: false,
         testing: false,

package/packages/@monomind/cli/dist/src/knowledge/document-pipeline.js

@@ -10,7 +10,10 @@ import * as crypto from 'node:crypto';
 import { DOC_EXTENSIONS, extractText } from '../capabilities/cap-documents.js';
 const DEFAULT_CHUNK_SIZE = 3200;
 const DEFAULT_OVERLAP = 400;
-function chunkDocument(docId, text) {
+// Inline fallback identical to @monoes/memory's knowledge/document-chunker.ts —
+// used only if the dynamic import below fails (package not installed/built).
+// Keep in sync if the shared chunker's boundary-snapping logic changes.
+function chunkDocumentInline(docId, text) {
     if (text.length === 0)
         return [];
     const chunks = [];
@@ -33,6 +36,15 @@ function chunkDocument(docId, text) {
     }
     return chunks;
 }
+async function chunkDocument(docId, text) {
+    try {
+        const mod = await import('@monoes/memory');
+        return mod.chunkDocument(docId, text, DEFAULT_CHUNK_SIZE, DEFAULT_OVERLAP);
+    }
+    catch {
+        return chunkDocumentInline(docId, text);
+    }
+}
 // ── Constants ──────────────────────────────────────────────────────
 const KNOWLEDGE_NS_PREFIX = 'knowledge:';
 const METADATA_FILE = 'doc-metadata.jsonl';
@@ -129,14 +141,14 @@ export async function ingestDocument(filePath, scope = 'shared', rootDir = proce
         removeMetadataEntry(rootDir, resolved, scope);
     }
     const docId = `${scope}:${resolved}`;
-    const chunks = chunkDocument(docId, fullContent);
+    const chunks = await chunkDocument(docId, fullContent);
     const bridge = await getBridge();
     let indexed = 0;
     for (const chunk of chunks) {
         const key = `doc:${hash}:${chunk.chunkIndex}`;
         if (bridge) {
             try {
-                await bridge.bridgeStoreEntry({
+                const storeResult = await bridge.bridgeStoreEntry({
                     key,
                     value: chunk.text,
                     namespace: namespace(scope),
@@ -144,15 +156,13 @@ export async function ingestDocument(filePath, scope = 'shared', rootDir = proce
                     tags: ['document', ext, `src:${resolved}`],
                     upsert: true,
                 });
-                indexed++;
+                if (storeResult?.success)
+                    indexed++;
             }
             catch {
-                indexed++;
+                // chunk not stored — don't count as indexed
             }
         }
-        else {
-            indexed++;
-        }
     }
     // Persist metadata
     appendMetadata(rootDir, {

package/packages/@monomind/cli/dist/src/mcp-client.js

@@ -16,7 +16,6 @@ import { hooksTools } from './mcp-tools/hooks-tools.js';
 import { taskTools } from './mcp-tools/task-tools.js';
 import { sessionTools } from './mcp-tools/session-tools.js';
 import { hiveMindTools } from './mcp-tools/hive-mind-tools.js';
-import { workflowTools } from './mcp-tools/workflow-tools.js';
 import { analyzeTools } from './mcp-tools/analyze-tools.js';
 import { embeddingsTools } from './mcp-tools/embeddings-tools.js';
 import { claimsTools } from './mcp-tools/claims-tools.js';
@@ -66,7 +65,6 @@ registerTools([
     ...taskTools,
     ...sessionTools,
     ...hiveMindTools,
-    ...workflowTools,
     ...analyzeTools,
     ...embeddingsTools,
     ...claimsTools,

package/packages/@monomind/cli/dist/src/mcp-server.js

@@ -464,22 +464,20 @@ export class MCPServerManager extends EventEmitter {
                     }
                     const toolName = params.name;
                     const toolParams = (rawArgs || {});
-                    // validateInput boundary: sanitize the incoming tool name
-                    try {
-                        const secMod = await import('@monomind/security').catch(() => null);
-                        const validateInput = secMod?.validateInput;
-                        if (validateInput) {
-                            const check = validateInput(toolName, { type: 'string', maxLength: 200 });
-                            if (!check.valid) {
-                                return {
-                                    jsonrpc: '2.0',
-                                    id: message.id,
-                                    error: { code: -32602, message: `Invalid tool name: ${check.error}` },
-                                };
-                            }
+                    // validateInput boundary: sanitize the incoming tool name.
+                    // This gates every MCP tool invocation (including path/write/command
+                    // tools), so invalid names are rejected before reaching tool handlers.
+                    {
+                        const { validateInput } = await import('./utils/input-guards.js');
+                        const check = validateInput(toolName, { type: 'string', maxLength: 200 });
+                        if (!check.valid) {
+                            return {
+                                jsonrpc: '2.0',
+                                id: message.id,
+                                error: { code: -32602, message: `Invalid tool name: ${check.error}` },
+                            };
                         }
                     }
-                    catch { /* security module optional */ }
                     if (!hasTool(toolName)) {
                         return {
                             jsonrpc: '2.0',

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/coherence-check.js

@@ -6,6 +6,7 @@
  *
  * Uses CohomologyEngine from prime-radiant-advanced-wasm
  */
+import { cosineSimilarity } from '../../utils/cosine-similarity.js';
 import { CoherenceInputSchema, successResult, errorResult, } from './types.js';
 // Default logger for when context doesn't provide one
 const defaultLogger = {
@@ -68,25 +69,6 @@ function detectContradictions(vectors, threshold) {
     }
     return violations;
 }
-/**
- * Calculate cosine similarity
- */
-function cosineSimilarity(a, b) {
-    if (a.length !== b.length)
-        return 0;
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        const ai = a[i];
-        const bi = b[i];
-        dotProduct += ai * bi;
-        normA += ai * ai;
-        normB += bi * bi;
-    }
-    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-    return denominator > 0 ? dotProduct / denominator : 0;
-}
 /**
  * Get interpretation of energy level
  */

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/types.d.ts

@@ -423,7 +423,8 @@ export declare function trackPerformance<T>(operationName: string, operation: ()
     metrics: PerformanceMetrics;
 }>;
 /**
- * Calculate cosine similarity between two vectors
+ * Cosine similarity — re-exported from shared utility.
+ * Callers that already import from this module continue to work unchanged.
  */
-export declare function cosineSimilarity(a: number[] | Float32Array, b: number[] | Float32Array): number;
+export { cosineSimilarity } from '../../utils/cosine-similarity.js';
 //# sourceMappingURL=types.d.ts.map