monomind 1.8.0 → 1.9.1

package/packages/@monomind/cli/README.md

@@ -0,0 +1,441 @@
+<p align="center">
+  <img src="assets/hero-banner.png" alt="Monomind — AI Agent Orchestration" width="100%" />
+</p>
+
+<p align="center">
+  <img src="assets/logo.png" alt="Monomind Logo" width="120" />
+</p>
+
+<h1 align="center">Monomind</h1>
+
+<p align="center">
+  <strong>The orchestration layer that turns Claude Code into an autonomous engineering team.</strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/monomind"><img src="https://img.shields.io/npm/v/monomind?color=%234F46E5&label=npm&style=flat-square" alt="npm version" /></a>
+  <a href="https://www.npmjs.com/package/monomind"><img src="https://img.shields.io/npm/dm/monomind?color=%2310B981&style=flat-square" alt="downloads" /></a>
+  <a href="https://github.com/nokhodian/monomind/stargazers"><img src="https://img.shields.io/github/stars/nokhodian/monomind?color=%23F59E0B&style=flat-square" alt="stars" /></a>
+  <a href="https://github.com/nokhodian/monomind/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-%238B5CF6?style=flat-square" alt="license" /></a>
+  <a href="https://nodejs.org/"><img src="https://img.shields.io/badge/node-%3E%3D20-green?style=flat-square" alt="node" /></a>
+</p>
+
+<p align="center">
+  <a href="#quickstart">Quickstart</a> &nbsp;&bull;&nbsp;
+  <a href="#what-monomind-does">What It Does</a> &nbsp;&bull;&nbsp;
+  <a href="#features">Features</a> &nbsp;&bull;&nbsp;
+  <a href="#agent-catalog">Agent Catalog</a> &nbsp;&bull;&nbsp;
+  <a href="#swarm-orchestration">Swarms</a> &nbsp;&bull;&nbsp;
+  <a href="#commands">Commands</a> &nbsp;&bull;&nbsp;
+  <a href="#memory--intelligence">Memory</a>
+</p>
+
+---
+
+## Why Monomind?
+
+You already use Claude Code. Monomind makes it **10x more powerful**.
+
+Instead of one AI assistant handling everything, Monomind coordinates **230+ specialized agents** — architects, security auditors, performance engineers, frontend developers, database optimizers — each with domain expertise, working in parallel swarms that review each other's work.
+
+**The difference:**
+- **Without Monomind:** You prompt Claude, it does its best across every domain.
+- **With Monomind:** Claude spawns the *right specialist* for each subtask, coordinates them in fault-tolerant swarms, remembers everything across sessions, and learns from every interaction.
+
+> One command. Entire engineering workflows. Zero babysitting.
+
+---
+
+## Quickstart
+
+```bash
+# Install globally
+npm install -g monomind
+
+# Initialize in any project
+cd your-project
+monomind init
+
+# Add MCP server to Claude Code
+claude mcp add monomind npx monomind mcp start
+```
+
+That's it. Monomind is now active in your Claude Code sessions.
+
+---
+
+## Monomind Control — Live Dashboard
+
+<p align="center">
+  <img src="assets/dashboard-control.png" alt="Monomind Control Dashboard" width="100%" />
+</p>
+
+Real-time visibility into every project, session, agent, memory, route decision, and token spend — all in one terminal-native dashboard.
+
+---
+
+## What Monomind Does
+
+### From Prompt to Production
+
+Monomind turns high-level instructions into coordinated multi-agent execution:
+
+```
+You: "Add webhook delivery with retries and dead-letter queue"
+
+Monomind:
+  1. Routes to Software Architect → designs the system
+  2. Spawns backend-dev → implements webhook dispatcher
+  3. Spawns backend-dev → implements retry logic with exponential backoff
+  4. Spawns Database Optimizer → designs dead-letter queue schema
+  5. Spawns tester → writes integration tests
+  6. Spawns Code Reviewer → reviews all changes
+  7. Commits, reports, moves to next task
+```
+
+### Autonomous Task Pipelines
+
+```bash
+# Turn a spec into executable tasks, then run them
+/monomind:createtask docs/specs/webhook-system.md
+
+# Or let it generate ideas, evaluate, and execute
+/monomind:idea add real-time collaboration to the editor
+
+# Pick up tasks and execute them autonomously
+/monomind:do
+```
+
+---
+
+## Features
+
+### 230+ Specialized Agents
+
+Not generic "code assistants" — domain experts with targeted system prompts, each optimized for a specific class of work.
+
+| Category | Count | Examples |
+|---|---|---|
+| **Engineering** | 23 | Backend Architect, Frontend Developer, Database Optimizer, Embedded Firmware Engineer, SRE |
+| **Marketing** | 27 | SEO Specialist, TikTok Strategist, Content Creator, Growth Hacker, LinkedIn Content Creator |
+| **Specialized** | 27 | Legal Compliance, Finance Tracker, Salesforce Architect, Document Generator, MCP Builder |
+| **Game Dev** | 20 | Unity Architect, Unreal Systems Engineer, Godot Scripter, Roblox Systems Scripter |
+| **Sales** | 8 | Deal Strategist, Sales Engineer, Pipeline Analyst, Outbound Strategist |
+| **Design** | 8 | UI Designer, UX Researcher, Brand Guardian, Visual Storyteller |
+| **Paid Media** | 7 | PPC Strategist, Ad Creative Strategist, Programmatic Buyer, Tracking Specialist |
+| **Support** | 6 | Support Responder, Analytics Reporter, Study Abroad Advisor, Trend Researcher |
+| **Product** | 5 | Product Manager, Sprint Prioritizer, UX Researcher, Experiment Tracker |
+| **Academic** | 5 | Anthropologist, Historian, Psychologist, Geographer, Narratologist |
+| **And more...** | 94+ | Consensus, Swarm Coordination, Neural, SPARC, Architecture, DevOps, Testing |
+
+### Two-Stage LLM Routing
+
+Monomind doesn't guess which agent to use — it **asks an LLM**.
+
+```
+Stage 1: "This task is about SEO optimization" → marketing domain
+Stage 2: "Best fit in marketing: SEO Specialist" → spawns SEO Specialist
+```
+
+Runs in under 2 seconds via Haiku. Falls back to keyword scoring if the API is unavailable.
+
+### Swarm Orchestration
+
+Coordinate multiple agents working on the same problem:
+
+| Topology | Best For |
+|---|---|
+| **Hierarchical** | Feature development — coordinator delegates to specialists |
+| **Mesh** | Research — all agents share findings peer-to-peer |
+| **Hierarchical-Mesh** | Complex projects — structured delegation with cross-talk |
+| **Adaptive** | Unknown complexity — topology evolves based on task |
+
+**Consensus protocols:** Raft (leader-based), Byzantine (fault-tolerant), Gossip (eventually consistent), CRDT (conflict-free), Quorum (majority vote).
+
+<p align="center">
+  <img src="assets/swarm-topology.png" alt="Swarm Topology" width="60%" />
+</p>
+
+```bash
+# Let Monomind pick the best topology
+/mastermind
+
+# Or configure manually
+monomind swarm init --topology hierarchical --agents 8 --strategy specialized
+```
+
+### Self-Learning Memory
+
+Every interaction makes Monomind smarter:
+
+- **AgentDB** — Persistent vector memory with HNSW indexing (150x-12,500x faster search)
+- **Knowledge Graph** — Full dependency mapping of your codebase via Graphify
+- **Session Continuity** — Pick up exactly where you left off across sessions
+- **Neural Patterns** — SONA learning adapts routing and agent behavior over time
+- **Memory Palace** — Visual dashboard for exploring stored knowledge
+
+<p align="center">
+  <img src="assets/memory-palace.png" alt="Memory Palace — Browse memories, sessions, knowledge, and swarms" width="100%" />
+</p>
+
+### 17 Hooks + 12 Background Workers
+
+Monomind hooks into every phase of your Claude Code workflow:
+
+| Hook | What It Does |
+|---|---|
+| `pre-task` | Routes to the best agent before execution starts |
+| `post-task` | Learns from outcomes, updates neural patterns |
+| `pre-edit` | Validates changes against project conventions |
+| `post-edit` | Indexes new code into the knowledge graph |
+| `session-start` | Restores context, preloads relevant memory |
+| `session-end` | Persists learnings, updates metrics |
+
+**Background workers** handle: optimization, consolidation, prediction, auditing, documentation, refactoring, benchmarking, and test gap analysis — all running autonomously.
+
+---
+
+## Agent Catalog
+
+### Development
+
+| Agent | Specialty |
+|---|---|
+| `coder` | General implementation with TDD |
+| `backend-dev` | APIs, databases, server-side logic |
+| `Frontend Developer` | React, Vue, Angular, CSS systems |
+| `mobile-dev` | React Native, iOS, Android |
+| `Rapid Prototyper` | Fast MVPs and proof-of-concepts |
+| `Solidity Smart Contract Engineer` | EVM, DeFi, gas optimization |
+| `WeChat Mini Program Developer` | WXML/WXSS, WeChat ecosystem |
+| `Embedded Firmware Engineer` | ESP32, ARM Cortex-M, FreeRTOS |
+| `visionOS Spatial Engineer` | SwiftUI volumetric, Liquid Glass |
+
+### Architecture & Quality
+
+| Agent | Specialty |
+|---|---|
+| `Software Architect` | System design, DDD, architectural patterns |
+| `Code Reviewer` | Correctness, security, performance review |
+| `Security Engineer` | Threat modeling, vulnerability assessment |
+| `Database Optimizer` | Schema design, query tuning, indexing |
+| `SRE` | SLOs, error budgets, chaos engineering |
+
+### Marketing & Growth
+
+| Agent | Specialty |
+|---|---|
+| `SEO Specialist` | Technical SEO, content optimization |
+| `TikTok Strategist` | Viral content, algorithm optimization |
+| `LinkedIn Content Creator` | Thought leadership, professional content |
+| `Growth Hacker` | Viral loops, conversion funnels |
+| `Content Creator` | Multi-platform editorial calendars |
+
+### Game Development
+
+| Agent | Specialty |
+|---|---|
+| `Unity Architect` | ScriptableObjects, modular systems |
+| `Unreal Systems Engineer` | C++/Blueprint, Nanite, Lumen |
+| `Godot Gameplay Scripter` | GDScript 2.0, signal architecture |
+| `Roblox Systems Scripter` | Luau, client-server, DataStore |
+
+[See all 230 agents →](.claude/agents/)
+
+---
+
+## Swarm Orchestration
+
+### How Swarms Work
+
+<p align="center">
+  <img src="assets/swarm-inspector.png" alt="Swarm Inspector — topology graph, agent roles, and communication logs" width="100%" />
+</p>
+
+```
+/mastermind "implement authentication system with OAuth2, JWT, and role-based access"
+
+Monomind recommends: Hierarchical swarm, 6 agents, Raft consensus
+
+  Queen Coordinator
+  ├── Software Architect    → designs auth architecture
+  ├── backend-dev           → implements OAuth2 flow
+  ├── backend-dev           → implements JWT + RBAC
+  ├── Security Engineer     → audits for vulnerabilities
+  ├── tester                → writes auth test suite
+  └── Code Reviewer         → reviews everything before merge
+```
+
+### Anti-Drift Protection
+
+Swarms don't just run — they **stay on track**:
+
+- **Raft consensus** — Leader maintains authoritative state, prevents conflicting changes
+- **Frequent checkpoints** — `post-task` hooks validate progress after every step
+- **Shared memory namespace** — All agents in a swarm see the same context
+- **Review cycles** — Code reviewer validates before any task is marked done
+
+---
+
+## Commands
+
+### Slash Commands (Inside Claude Code)
+
+| Command | What It Does |
+|---|---|
+| `/monomind:createtask <spec>` | Ingests a prompt, file, or folder → generates full implementation plan → creates self-contained tasks on monotask |
+| `/monomind:idea <prompt>` | Research swarm generates ideas → PM evaluates → architect decomposes into tasks |
+| `/monomind:do` | Picks up tasks, executes with assigned agents, reviews, fixes bugs, loops |
+| `/mastermind` | Analyzes your task and recommends the optimal swarm topology |
+| `/specialagent <task>` | Two-stage LLM routing to find the perfect specialist agent |
+
+### CLI Commands
+
+```bash
+monomind agent spawn --type coder       # Spawn a specific agent
+monomind agent list                      # List running agents
+monomind swarm init                      # Initialize a swarm
+monomind memory search "auth patterns"   # Search vector memory
+monomind hooks route --task "fix bug"    # Route to best agent
+monomind doctor --fix                    # Diagnose and fix issues
+monomind daemon start                    # Start background workers
+```
+
+41 CLI commands across: agent management, swarm coordination, memory, sessions, hooks, neural training, security, performance profiling, and more.
+
+### Session Inspector
+
+Every session is recorded and browsable — tool calls, agent spawns, memory operations, and full conversation replay:
+
+<p align="center">
+  <img src="assets/session-detail.png" alt="Session Inspector — full conversation replay with tool breakdown" width="100%" />
+</p>
+
+---
+
+## Memory & Intelligence
+
+### Knowledge Graph (Monograph)
+
+Monomind builds a full dependency graph of your codebase — automatically queried before every task:
+
+```bash
+# What files are relevant to my task?
+monograph_suggest "add webhook retry logic"
+# → returns ranked list of files with relevance scores
+
+# What depends on UserService?
+monograph_query "UserService dependencies"
+# → returns file paths + line numbers
+
+# Find the most connected files in the codebase
+monograph_god_nodes
+# → returns high-centrality internal files (external/test filtered out)
+```
+
+All monograph tools are called automatically by hooks and slash commands — you don't need to invoke them manually.
+
+### Vector Memory (AgentDB + HNSW)
+
+Every insight, pattern, and decision is stored in searchable vector memory:
+
+- **150x-12,500x faster** than brute-force search via HNSW indexing
+- **Hybrid backend** — SQLite for structured data, AgentDB for semantic search
+- **Cross-session persistence** — context survives restarts
+
+### Neural Learning (SONA)
+
+Self-Optimizing Neural Adaptation learns from every task:
+
+- Pattern recognition improves agent routing over time
+- Trajectory tracking identifies what works and what doesn't
+- Automatic model adaptation with <0.05ms overhead
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                         Monomind                            │
+├──────────────┬──────────────┬──────────────┬───────────────┤
+│   230+ Agents │  Swarm Engine │  Memory Layer │  Intelligence │
+│              │              │              │               │
+│  Specialized │  Hierarchical │  AgentDB     │  SONA Neural  │
+│  agent defs  │  Mesh/Raft   │  HNSW Vector │  Pattern      │
+│  + routing   │  consensus   │  Knowledge   │  Learning     │
+│              │              │  Graph       │               │
+├──────────────┴──────────────┴──────────────┴───────────────┤
+│                     17 Hooks + 12 Workers                   │
+├─────────────────────────────────────────────────────────────┤
+│              MCP Server (stdio/http/websocket)              │
+├─────────────────────────────────────────────────────────────┤
+│                    Claude Code Runtime                      │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Key Packages
+
+| Package | Purpose |
+|---|---|
+| `@monomind/cli` | 41 commands, agent definitions, slash commands, hooks, MCP server |
+| `@monomind/memory` | AgentDB with HNSW vector search |
+| `@monomind/hooks` | 17 lifecycle hooks + 12 background workers |
+| `@monomind/security` | Input validation, CVE remediation |
+| `@monomind/guidance` | Governance control plane |
+
+---
+
+## Performance
+
+| Metric | Result |
+|---|---|
+| Agent routing | <2s (LLM) / <5ms (keyword fallback) |
+| Vector search | 150x-12,500x faster (HNSW) |
+| SONA learning | <0.05ms per adaptation |
+| Session restore | <500ms cold start |
+| Memory reduction | 50-75% vs baseline |
+
+---
+
+## Who Uses Monomind?
+
+Monomind is built for teams and individuals who use Claude Code for serious engineering work:
+
+- **Solo developers** who want the power of a full engineering team
+- **Startups** shipping features faster with autonomous agent pipelines
+- **Enterprise teams** coordinating complex multi-module changes
+- **Game studios** using specialized Unity/Unreal/Godot agents
+- **Marketing teams** running content operations with domain-specific agents
+- **Security teams** automating audit and compliance workflows
+
+---
+
+## Contributing
+
+```bash
+git clone https://github.com/nokhodian/monomind.git
+cd monomind
+pnpm install
+monomind doctor --fix
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+---
+
+## License
+
+MIT License — See [LICENSE](LICENSE) for details.
+
+---
+
+<p align="center">
+  <strong>Stop prompting. Start orchestrating.</strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/monomind">npm</a> &nbsp;&bull;&nbsp;
+  <a href="https://github.com/nokhodian/monomind">GitHub</a> &nbsp;&bull;&nbsp;
+  <a href="https://github.com/nokhodian/monomind/issues">Issues</a>
+</p>

package/packages/@monomind/cli/bin/cli.js

@@ -4,35 +4,81 @@
  *
  * Monomind Command Line Interface
  *
- * Auto-detects MCP mode when stdin is piped and no args provided.
- * This allows: echo '{"jsonrpc":"2.0",...}' | npx @monomind/cli
+ * MCP mode requires explicit `mcp start` subcommand or MONOMIND_MCP_AUTODETECT=1.
+ * Usage: npx @monomind/cli mcp start
  */
 
 import { randomUUID } from 'crypto';
 
-// Check if we should run in MCP server mode
-// Conditions:
-//   1. stdin is being piped AND no CLI arguments provided (auto-detect)
-//   2. stdin is being piped AND args are "mcp start" (explicit, e.g. npx monomind@alpha mcp start)
+// Check if we should run in MCP server mode.
+// SECURITY: only accept explicit `mcp start` plus piped stdin, OR the explicit
+// `MONOMIND_MCP_AUTODETECT=1` opt-in for the legacy "no args + non-TTY" path.
+// Previously any `monomind` invocation with redirected stdin (CI pipes, xargs,
+// editor integrations) silently flipped into MCP server mode and accepted
+// JSON-RPC tools/call — privilege escalation by environment.
 const cliArgs = process.argv.slice(2);
 const isExplicitMCP = cliArgs.length >= 1 && cliArgs[0] === 'mcp' && (cliArgs.length === 1 || cliArgs[1] === 'start');
-const isMCPMode = !process.stdin.isTTY && (process.argv.length === 2 || isExplicitMCP);
+const allowAutoDetect = process.env.MONOMIND_MCP_AUTODETECT === '1';
+const isMCPMode = !process.stdin.isTTY && (isExplicitMCP || (allowAutoDetect && process.argv.length === 2));
 
 if (isMCPMode) {
   // Run MCP server mode
   const { listMCPTools, callMCPTool, hasTool } = await import('../dist/src/mcp-client.js');
 
-  const VERSION = '3.0.0';
+  // Read version from package.json instead of hardcoding (prevents stale
+  // version drift between bin entry and the published package).
+  let VERSION = '0.0.0';
+  try {
+    const { readFileSync } = await import('fs');
+    const { fileURLToPath } = await import('url');
+    const { dirname, join } = await import('path');
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    if (typeof pkg.version === 'string') VERSION = pkg.version;
+  } catch { /* fall back to 0.0.0 */ }
   const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
 
-  console.error(
-    `[${new Date().toISOString()}] INFO [monomind-mcp] (${sessionId}) Starting in stdio mode`
-  );
+  // Don't leak nodeVersion/platform/arch/pid to stderr by default; gate behind
+  // MONOMIND_LOG_LEVEL=debug to reduce fingerprinting in shared log aggregators.
+  if (process.env.MONOMIND_LOG_LEVEL === 'debug') {
+    console.error(
+      `[${new Date().toISOString()}] INFO [monomind-mcp] (${sessionId}) Starting in stdio mode (node=${process.version} platform=${process.platform} arch=${process.arch})`
+    );
+  } else {
+    console.error(
+      `[${new Date().toISOString()}] INFO [monomind-mcp] (${sessionId}) Starting in stdio mode`
+    );
+  }
+
+  // Top-level safety nets — without these, an unhandled async error in a tool
+  // handler crashes the process with no observable cleanup.
+  process.on('uncaughtException', (err) => {
+    console.error(`[${new Date().toISOString()}] FATAL [monomind-mcp] uncaughtException: ${err && err.message ? err.message : String(err)}`);
+    process.exit(1);
+  });
+  process.on('unhandledRejection', (reason) => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    console.error(`[${new Date().toISOString()}] FATAL [monomind-mcp] unhandledRejection: ${msg}`);
+    process.exit(1);
+  });
+  const shutdown = (sig) => {
+    console.error(`[${new Date().toISOString()}] INFO [monomind-mcp] (${sessionId}) ${sig} received, shutting down`);
+    process.exit(0);
+  };
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
 
+  // Cap on accumulated input buffer so a peer pumping a single multi-GB line
+  // (or a slow trickle without newlines) cannot OOM-kill the process.
+  const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
   let buffer = '';
   process.stdin.setEncoding('utf8');
   process.stdin.on('data', async (chunk) => {
     buffer += chunk;
+    if (buffer.length > MAX_BUFFER_BYTES) {
+      console.error(`[${new Date().toISOString()}] FATAL [monomind-mcp] input exceeds ${MAX_BUFFER_BYTES} bytes`);
+      process.exit(1);
+    }
     let lines = buffer.split('\n');
     buffer = lines.pop() || '';
 
@@ -146,11 +192,30 @@ if (isMCPMode) {
     }
   }
 } else {
-  // Run normal CLI mode
+  // Run normal CLI mode.
+  // Install top-level handlers so an asynchronous error fired from an event-
+  // loop callback does not bypass the synchronous .catch below. Default Node
+  // handler prints the full stack to stderr — which on this codebase includes
+  // attacker-influenced bytes from registry/config error messages and full
+  // filesystem paths. Sanitize before logging and exit non-zero.
+  const safeMsg = (m) =>
+    String(m == null ? '' : m).replace(/[\x00-\x1f\x7f-\x9f]/g, '?').slice(0, 1000);
+  process.on('uncaughtException', (err) => {
+    console.error(`[${new Date().toISOString()}] FATAL [monomind] uncaughtException: ${safeMsg(err && err.message)}`);
+    if (process.env.DEBUG) console.error(err && err.stack);
+    process.exit(1);
+  });
+  process.on('unhandledRejection', (reason) => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    console.error(`[${new Date().toISOString()}] FATAL [monomind] unhandledRejection: ${safeMsg(msg)}`);
+    if (process.env.DEBUG && reason instanceof Error) console.error(reason.stack);
+    process.exit(1);
+  });
+
   const { CLI } = await import('../dist/src/index.js');
   const cli = new CLI();
   cli.run().catch((error) => {
-    console.error('Fatal error:', error.message);
+    console.error('Fatal error:', safeMsg(error && error.message));
     process.exit(1);
   });
 }

package/packages/@monomind/cli/dist/src/agents/halt-signal.js

@@ -6,14 +6,23 @@
  * can query whether a halt has been issued.
  */
 import { randomUUID } from 'crypto';
-import { existsSync, mkdirSync, appendFileSync, readFileSync } from 'fs';
-import { join, dirname } from 'path';
-const DEFAULT_FILE = () => join(process.cwd(), 'data', 'halt-signals.jsonl');
+import { existsSync, mkdirSync, appendFileSync, readFileSync, statSync } from 'fs';
+import { join, dirname, resolve, sep } from 'path';
+const ALLOWED_ROOT = () => resolve(process.env.MONOMIND_DATA_DIR ?? process.cwd());
+const DEFAULT_FILE = () => join(ALLOWED_ROOT(), 'data', 'halt-signals.jsonl');
+function safeHaltFilePath(filePath) {
+    const allowedRoot = ALLOWED_ROOT();
+    const resolved = resolve(filePath);
+    if (resolved !== allowedRoot && !resolved.startsWith(allowedRoot + sep)) {
+        throw new Error(`Halt signal file path escapes allowed directory: ${filePath}`);
+    }
+    return resolved;
+}
 /**
  * Broadcast a halt signal for a swarm.
  */
 export function broadcast(swarmId, sourceAgentId, reason, filePath) {
-    const target = filePath ?? DEFAULT_FILE();
+    const target = filePath ? safeHaltFilePath(filePath) : DEFAULT_FILE();
     const dir = dirname(target);
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
@@ -32,10 +41,22 @@ export function broadcast(swarmId, sourceAgentId, reason, filePath) {
  * Check whether any halt signal exists for the given swarm.
  */
 export function isHalted(swarmId, filePath) {
-    const target = filePath ?? DEFAULT_FILE();
+    const target = filePath ? safeHaltFilePath(filePath) : DEFAULT_FILE();
     if (!existsSync(target)) {
         return false;
     }
+    // Size cap. isHalted is on the swarm-coordination hot path; without this
+    // cap a planted multi-GB file (or unbounded broadcast accumulation over
+    // weeks) reliably OOMs the CLI on the next call. Treat oversized halt
+    // logs as "no halt" — fail-safe in the swarm-termination flow.
+    try {
+        const stat = statSync(target);
+        if (stat.size > 10 * 1024 * 1024)
+            return false;
+    }
+    catch {
+        return false;
+    }
     const raw = readFileSync(target, 'utf-8').trim();
     if (!raw)
         return false;
@@ -43,8 +64,13 @@ export function isHalted(swarmId, filePath) {
         .split('\n')
         .filter(Boolean)
         .some((line) => {
-        const rec = JSON.parse(line);
-        return rec.swarmId === swarmId;
+        try {
+            const rec = JSON.parse(line);
+            return rec.swarmId === swarmId;
+        }
+        catch {
+            return false;
+        }
     });
 }
 //# sourceMappingURL=halt-signal.js.map

package/packages/@monomind/cli/dist/src/agents/managed-agent.js

@@ -8,10 +8,13 @@ export async function spawnAndAwait(agentSlug, task, runner, options = {}) {
     const startedAt = Date.now();
     const taskId = `managed-${Date.now().toString(36)}-${randomBytes(4).toString('hex')}`;
     try {
+        let timeoutHandle;
         const output = await Promise.race([
             runner(agentSlug, taskId, task),
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs)),
-        ]);
+            new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]).finally(() => clearTimeout(timeoutHandle));
         return {
             agentSlug, taskId, output, status: 'success',
             durationMs: Date.now() - startedAt,

package/packages/@monomind/cli/dist/src/agents/prompt-experiment.d.ts

@@ -5,9 +5,9 @@
  * routes to the candidate or control version. Falls back to the active version
  * when no experiment is running.
  *
- * @module @monoes/cli/agents/prompt-experiment
+ * @module @monomind/cli/agents/prompt-experiment
  */
-import type { PromptVersionStore } from '../../../memory/src/prompt-version-store.js';
+type PromptVersionStore = any;
 export interface ResolvedPrompt {
     prompt: string;
     version: string;
@@ -19,4 +19,5 @@ export declare class PromptExperimentRouter {
     constructor(store: PromptVersionStore);
     resolvePromptForSpawn(agentSlug: string): ResolvedPrompt;
 }
+export {};
 //# sourceMappingURL=prompt-experiment.d.ts.map

package/packages/@monomind/cli/dist/src/agents/prompt-experiment.js

@@ -5,7 +5,7 @@
  * routes to the candidate or control version. Falls back to the active version
  * when no experiment is running.
  *
- * @module @monoes/cli/agents/prompt-experiment
+ * @module @monomind/cli/agents/prompt-experiment
  */
 export class PromptExperimentRouter {
     store;