npm - @monoes/monomindcli - Versions diffs - 1.6.3 → 1.6.4 - Mend

@monoes/monomindcli 1.6.3 → 1.6.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/.claude/commands/monomind-createtask.md +3 -3
package/.claude/commands/monomind-do.md +2 -2
package/.claude/commands/monomind-idea.md +2 -2
package/.claude/helpers/graphify-freshen.cjs +5 -5
package/README.md +307 -553
package/dist/src/commands/memory.d.ts.map +1 -1
package/dist/src/commands/memory.js +0 -1
package/dist/src/commands/memory.js.map +1 -1
package/dist/src/init/executor.d.ts.map +1 -1
package/dist/src/init/executor.js +6 -1
package/dist/src/init/executor.js.map +1 -1
package/dist/tsconfig.tsbuildinfo +1 -1
package/package.json +1 -1
/package/.claude/commands/{monobrain-help.md → monomind-help.md} +0 -0
/package/.claude/commands/{monobrain-memory.md → monomind-memory.md} +0 -0
/package/.claude/commands/{monobrain-swarm.md → monomind-swarm.md} +0 -0

package/README.md CHANGED Viewed

@@ -1,687 +1,441 @@
-<div align="center">
+<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>
-<img src="docs/assets/banner.svg" alt="Monomind — Enterprise AI Agent Orchestration" width="860"/>
-<br/>
-[![npm version](https://img.shields.io/npm/v/monomind?style=for-the-badge&logo=npm&color=7c3aed&logoColor=white)](https://www.npmjs.com/package/monomind)
-[![Downloads](https://img.shields.io/npm/dm/monomind?style=for-the-badge&logo=npm&color=3b82f6&logoColor=white&label=Monthly%20Downloads)](https://www.npmjs.com/package/monomind)
-[![Stars](https://img.shields.io/github/stars/monoes/monomind?style=for-the-badge&logo=github&color=f59e0b&logoColor=white)](https://github.com/monoes/monomind)
-[![License: MIT](https://img.shields.io/badge/License-MIT-10b981?style=for-the-badge&logo=opensourceinitiative&logoColor=white)](https://opensource.org/licenses/MIT)
-[![Node](https://img.shields.io/badge/node-%3E%3D20-06b6d4?style=for-the-badge&logo=nodedotjs&logoColor=white)](https://nodejs.org)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-3b82f6?style=for-the-badge&logo=typescript&logoColor=white)](https://www.typescriptlang.org)
-_Deploy 60+ specialized agents in coordinated swarms with self-learning capabilities, fault-tolerant consensus, and enterprise-grade security._
-</div>
-> **Why Monomind?** Claude Code is powerful — but it thinks alone. Monomind gives it a brain trust: a coordinated swarm of 100+ specialized agents that share memory, reach consensus, learn from every task, and route work to the right specialist automatically. Built on a WASM-powered intelligence layer, it gets smarter every session.
-## How Monomind Works
+---
-```
-User → Monomind (CLI/MCP) → Router → Swarm → Agents → Memory → LLM Providers
-                           ↑                          ↓
-                           └──── Learning Loop ←──────┘
-```
+## Why Monomind?
-<details>
-<summary>📐 <strong>Expanded Architecture</strong> — Full system diagram with RuVector intelligence</summary>
-```mermaid
-flowchart TB
-    subgraph USER["👤 User Layer"]
-        U[User]
-        CC[Claude Code]
-    end
-    subgraph ENTRY["🚪 Entry Layer"]
-        CLI[CLI / MCP Server]
-        AID[AIDefence Security]
-    end
-    subgraph ROUTING["🧭 Routing Layer"]
-        KW[Keyword Pre-Filter]
-        SEM[Semantic Router]
-        LLM_FB[LLM Fallback · Haiku]
-        TRIG[MicroAgent Triggers]
-        HK[17 Hooks · Event Bus]
-    end
-    subgraph SWARM["🐝 Swarm Coordination"]
-        TOPO[Topologies<br/>hierarchical/mesh/adaptive]
-        CONS[Consensus<br/>Raft/BFT/Gossip/CRDT]
-        CLM[Claims<br/>Trust Tiers]
-        GOV[Guidance<br/>Policy Gates]
-    end
-    subgraph AGENTS["🤖 100+ Agents"]
-        AG1[coder]
-        AG2[tester · reviewer]
-        AG3[architect · planner]
-        AG4[security-auditor]
-        AG5[devops · sre]
-        AG6[60+ more...]
-    end
-    subgraph RESOURCES["📦 Resources"]
-        MEM[(AgentDB · HNSW · SQLite)]
-        PROV[Providers<br/>Claude/GPT/Gemini/Ollama]
-        WORK[12 Workers<br/>ultralearn/audit/optimize]
-    end
-    subgraph RUVECTOR["🧠 RuVector Intelligence"]
-        direction TB
-        SONA[SONA<br/>Self-Optimize<br/>&lt;0.05ms]
-        EWC[EWC++<br/>Anti-Forgetting]
-        FLASH[Flash Attention<br/>2.49–7.47x]
-        HNSW_I[HNSW<br/>150x–12500x]
-        RB[ReasoningBank<br/>RETRIEVE→JUDGE→DISTILL]
-        LORA[LoRA/MicroLoRA<br/>128x compress]
-    end
-    subgraph LEARNING["🔄 Learning Loop"]
-        L1[RETRIEVE] --> L2[JUDGE] --> L3[DISTILL] --> L4[CONSOLIDATE] --> L5[ROUTE]
-    end
-    U --> CC --> CLI --> AID
-    AID --> KW & SEM & LLM_FB & TRIG & HK
-    KW & SEM & LLM_FB & TRIG --> TOPO & CONS & CLM & GOV
-    TOPO & CONS --> AG1 & AG2 & AG3 & AG4 & AG5 & AG6
-    AG1 & AG2 & AG3 & AG4 & AG5 & AG6 --> MEM & PROV & WORK
-    MEM --> SONA & EWC & FLASH & HNSW_I & RB & LORA
-    LORA --> L1
-    L5 -.->|loop| SEM
-```
+You already use Claude Code. Monomind makes it **10x more powerful**.
-**RuVector Intelligence Components:**
+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.
-| Component             | Purpose                                                         | Performance                      |
-| --------------------- | --------------------------------------------------------------- | -------------------------------- |
-| **SONA**              | Self-Optimizing Neural Architecture — learns optimal routing    | <0.05ms adaptation               |
-| **EWC++**             | Elastic Weight Consolidation — prevents catastrophic forgetting | Preserves all learned patterns   |
-| **Flash Attention**   | Optimized attention computation                                 | 2.49–7.47× speedup               |
-| **HNSW**              | Hierarchical Navigable Small World vector search                | 150×–12,500× faster              |
-| **ReasoningBank**     | Pattern storage with RETRIEVE→JUDGE→DISTILL pipeline            | Sub-ms recall                    |
-| **Hyperbolic**        | Poincaré ball embeddings for hierarchical data                  | Better code relationship mapping |
-| **LoRA / MicroLoRA**  | Low-Rank Adaptation weight compression                          | 128× compression ratio           |
-| **Int8 Quantization** | Memory-efficient weight storage                                 | ~4× memory reduction             |
-| **9 RL Algorithms**   | Q-Learning, SARSA, A2C, PPO, DQN, A3C, TD3, SAC, HER            | Task-specific policy learning    |
+**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.
-</details>
+> One command. Entire engineering workflows. Zero babysitting.
 ---
-## Get Started Fast
-**Option 1 — npx (recommended):**
+## Quickstart
 ```bash
-npx monomind@latest init --wizard
-claude mcp add monomind -- npx -y monomind@latest mcp start
-npx monomind@latest daemon start
-npx monomind@latest doctor --fix
-```
-**Option 2 — Clone from GitHub:**
+# Install globally
+npm install -g monomind
-```bash
-git clone https://github.com/nokhodian/monomind.git
-cd monomind
-npm install
-node packages/@monomind/cli/bin/cli.js init --wizard
+# Initialize in any project
+cd your-project
+monomind init
-# Wire up the MCP server in Claude Code
-claude mcp add monomind -- node "$PWD/packages/@monomind/cli/bin/cli.js" mcp start
+# Add MCP server to Claude Code
+claude mcp add monomind npx monomind mcp start
 ```
-> **New to Monomind?** You don't need to learn 170+ MCP tools or 41 CLI commands up front. After running `init`, just use Claude Code normally — the hooks system automatically routes tasks to the right agents, learns from successful patterns, and coordinates multi-agent work in the background.
+That's it. Monomind is now active in your Claude Code sessions.
 ---
-## Key Capabilities
+## Monomind Control — Live Dashboard
-🤖 **100+ Specialized Agents** — Ready-to-use AI agents for every engineering domain: coding, review, testing, security, DevOps, mobile, ML, blockchain, SRE, and more. Each optimized for its specific role.
+<p align="center">
+  <img src="assets/dashboard-control.png" alt="Monomind Control Dashboard" width="100%" />
+</p>
-🐝 **Coordinated Agent Swarms** — Agents organize into teams using hierarchical (queen/workers) or mesh (peer-to-peer) topologies. They share context, divide work, and reach consensus — even when agents fail.
+Real-time visibility into every project, session, agent, memory, route decision, and token spend — all in one terminal-native dashboard.
-🧠 **Learns From Every Session** — Successful patterns are stored in HNSW-indexed vector memory and reused. Similar tasks route to the best-performing agents automatically. Gets smarter over time without retraining.
-⚡ **3-Tier Cost Routing** — Simple transforms run in WASM at <1ms and $0. Medium tasks use Haiku. Complex reasoning uses Sonnet/Opus. Smart routing cuts API costs by 30–50%.
-🔌 **Deep Claude Code Integration** — 170+ MCP tools expose the full platform directly inside Claude Code sessions. The hooks system fires on every file edit, command, task start/end, and session event.
-🔒 **Production-Grade Security** — CVE-hardened AIDefence layer blocks prompt injection, path traversal, command injection, and credential leakage. Per-agent WASM/Docker sandboxing with cryptographic audit proofs.
-🧩 **Extensible Plugin System** — Add custom capabilities with the plugin SDK. Distribute via the IPFS-based decentralized marketplace. 20 plugins available today across core, integration, optimization, and domain categories.
+---
-🏛️ **Runtime Governance** — `@monomind/guidance` compiles your `CLAUDE.md` into enforced policy gates: destructive-op blocking, tool allowlists, diff size limits, secret detection, trust tiers, and HMAC-chained proof envelopes.
+## What Monomind Does
----
+### From Prompt to Production
-## Claude Code: With vs Without Monomind
-| Capability              | Claude Code Alone               | Claude Code + Monomind                                              |
-| ----------------------- | ------------------------------- | -------------------------------------------------------------------- |
-| **Agent Collaboration** | One agent, isolated context     | Swarms with shared memory and consensus                              |
-| **Hive Mind**           | ⛔ Not available                | Queen-led hierarchical swarms with 3+ queen types                    |
-| **Consensus**           | ⛔ No multi-agent decisions     | Byzantine fault-tolerant (f < n/3), Raft, Gossip, CRDT               |
-| **Memory**              | Session-only, ephemeral         | HNSW vector memory + knowledge graph, persistent cross-session       |
-| **Self-Learning**       | Static, starts fresh every time | SONA self-optimization, EWC++ anti-forgetting, pattern reuse         |
-| **Task Routing**        | Manual agent selection          | Intelligent 3-layer routing (keyword → semantic → LLM), 89% accuracy |
-| **Simple Transforms**   | Full LLM call every time        | Agent Booster (WASM): <1ms, $0 cost                                  |
-| **Background Work**     | Nothing runs automatically      | 12 workers auto-dispatch on hooks events                             |
-| **LLM Providers**       | Anthropic only                  | Claude, GPT, Gemini, Cohere, Ollama with failover and cost routing   |
-| **Security**            | Standard Claude sandboxing      | CVE-hardened, WASM/Docker sandbox per agent, cryptographic proofs    |
-| **Governance**          | CLAUDE.md is advisory           | Runtime-enforced policy gates with HMAC audit trail                  |
-| **Cost**                | Full LLM cost every task        | 30–50% reduction via WASM, caching, smart routing                    |
+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
+```
-## Architecture Deep Dives
+### Autonomous Task Pipelines
-<details>
-<summary>🧭 <strong>Intelligent Task Routing</strong> — 3-layer pipeline that routes every request</summary>
+```bash
+# Turn a spec into executable tasks, then run them
+/monomind:createtask docs/specs/webhook-system.md
-Every request passes through a 3-layer pipeline before any agent sees it:
+# Or let it generate ideas, evaluate, and execute
+/monomind:idea add real-time collaboration to the editor
-```
-Request
-  │
-  ├─► [Layer 1] Keyword pre-filter     → instant match, zero LLM cost
-  │
-  ├─► [Layer 2] Semantic routing       → embedding similarity vs. agent catalog
-  │
-  └─► [Layer 3] LLM fallback (Haiku)  → Haiku-powered classification for ambiguous tasks
+# Pick up tasks and execute them autonomously
+/monomind:do
 ```
-Once classified, the task hits the **3-tier cost model**:
+---
-| Tier  | Handler              | Latency | Cost          | Used for                                          |
-| ----- | -------------------- | ------- | ------------- | ------------------------------------------------- |
-| **1** | Agent Booster (WASM) | <1ms    | **$0**        | Simple transforms (var→const, add types, logging) |
-| **2** | Haiku                | ~500ms  | ~$0.0002      | Moderate tasks, summaries, Q&A                    |
-| **3** | Sonnet / Opus        | 2–5s    | $0.003–$0.015 | Architecture, security, complex reasoning         |
+## Features
-**Hook signals** — what the system emits to guide routing:
+### 230+ Specialized Agents
-```bash
-# Agent Booster can handle it — skip LLM entirely
-[AGENT_BOOSTER_AVAILABLE] Intent: var-to-const
-→ Use Edit tool directly, <1ms, $0
+Not generic "code assistants" — domain experts with targeted system prompts, each optimized for a specific class of work.
-# Model recommendation for Task tool
-[TASK_MODEL_RECOMMENDATION] Use model="haiku" (complexity=22)
-→ Pass model="haiku" to Task tool for cost savings
-```
+| 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 |
-**Microagent trigger scanner** — 10 specialist agents with keyword frontmatter triggers:
+### Two-Stage LLM Routing
-| Domain   | Trigger keywords                        | Agent                |
-| -------- | --------------------------------------- | -------------------- |
-| Security | `auth`, `injection`, `CVE`, `secret`    | `security-architect` |
-| DevOps   | `deploy`, `CI/CD`, `pipeline`, `k8s`    | `devops-automator`   |
-| Database | `query`, `schema`, `migration`, `index` | `database-optimizer` |
-| Frontend | `React`, `CSS`, `component`, `SSR`      | `frontend-dev`       |
-| Solidity | `contract`, `ERC`, `Solidity`, `DeFi`   | `solidity-engineer`  |
+Monomind doesn't guess which agent to use — it **asks an LLM**.
-</details>
+```
+Stage 1: "This task is about SEO optimization" → marketing domain
+Stage 2: "Best fit in marketing: SEO Specialist" → spawns SEO Specialist
+```
-<details>
-<summary>🐝 <strong>Swarm Coordination</strong> — How agents organize and reach consensus</summary>
+Runs in under 2 seconds via Haiku. Falls back to keyword scoring if the API is unavailable.
-Agents organize into swarms with configurable topologies and consensus algorithms:
+### Swarm Orchestration
-| Topology         | Best for                             | Consensus           |
-| ---------------- | ------------------------------------ | ------------------- |
-| **Hierarchical** | Coding tasks, feature work (default) | Raft (leader-based) |
-| **Mesh**         | Distributed exploration, research    | Gossip / CRDT       |
-| **Adaptive**     | Auto-switches based on load          | Byzantine (BFT)     |
+Coordinate multiple agents working on the same problem:
-**Consensus algorithms:**
+| 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 |
-| Algorithm           | Fault tolerance          | Use case                           |
-| ------------------- | ------------------------ | ---------------------------------- |
-| **Raft**            | f < n/2                  | Authoritative state, coding swarms |
-| **Byzantine (BFT)** | f < n/3                  | Untrusted environments             |
-| **Gossip**          | Eventual consistency     | Large swarms (100+ agents)         |
-| **CRDT**            | No coordination overhead | Conflict-free concurrent writes    |
+**Consensus protocols:** Raft (leader-based), Byzantine (fault-tolerant), Gossip (eventually consistent), CRDT (conflict-free), Quorum (majority vote).
-**Anti-drift swarm configuration** (recommended for all coding tasks):
+<p align="center">
+  <img src="assets/swarm-topology.png" alt="Swarm Topology" width="60%" />
+</p>
 ```bash
-npx monomind@latest swarm init \
-  --topology hierarchical \
-  --max-agents 8 \
-  --strategy specialized \
-  --consensus raft
-```
+# Let Monomind pick the best topology
+/mastermind
-| Setting          | Why it prevents drift                               |
-| ---------------- | --------------------------------------------------- |
-| `hierarchical`   | Coordinator validates every output against the goal |
-| `max-agents 6–8` | Smaller team = less coordination overhead           |
-| `specialized`    | Clear roles, no task overlap                        |
-| `raft`           | Single leader maintains authoritative state         |
+# Or configure manually
+monomind swarm init --topology hierarchical --agents 8 --strategy specialized
+```
-**Task → agent routing:**
+### Self-Learning Memory
-| Task           | Agents                                              |
-| -------------- | --------------------------------------------------- |
-| Bug fix        | coordinator · researcher · coder · tester           |
-| New feature    | coordinator · architect · coder · tester · reviewer |
-| Refactor       | coordinator · architect · coder · reviewer          |
-| Performance    | coordinator · perf-engineer · coder                 |
-| Security audit | coordinator · security-architect · auditor          |
+Every interaction makes Monomind smarter:
-</details>
+- **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
-<details>
-<summary>🧠 <strong>Self-Learning Intelligence</strong> — How Monomind gets smarter every session</summary>
+<p align="center">
+  <img src="assets/memory-palace.png" alt="Memory Palace — Browse memories, sessions, knowledge, and swarms" width="100%" />
+</p>
-Every task feeds the 4-step RETRIEVE-JUDGE-DISTILL-CONSOLIDATE pipeline:
+### 17 Hooks + 12 Background Workers
-```
-RETRIEVE  ──►  JUDGE  ──►  DISTILL  ──►  CONSOLIDATE
-   │               │            │               │
-HNSW search   success/fail   LoRA extract   EWC++ preserve
-150x faster    verdicts       128x compress  anti-forgetting
-```
+Monomind hooks into every phase of your Claude Code workflow:
-**Memory architecture:**
+| 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 |
-| Feature               | Details                                                       |
-| --------------------- | ------------------------------------------------------------- |
-| **Episodic memory**   | Full task histories with timestamps and outcomes              |
-| **Entity extraction** | Automatic extraction of code entities into structured records |
-| **Procedural memory** | Learned skills from `.monomind/skills.jsonl`                 |
-| **Vector search**     | 384-dim embeddings, sub-ms retrieval via HNSW                 |
-| **Knowledge graph**   | PageRank + community detection for structural insights        |
-| **Agent isolation**   | Per-agent memory scopes prevent cross-contamination           |
-| **Hybrid backend**    | SQLite + AgentDB, zero native binary dependencies             |
+**Background workers** handle: optimization, consolidation, prediction, auditing, documentation, refactoring, benchmarking, and test gap analysis — all running autonomously.
-**Specialization scorer** — per-agent, per-task-type success/failure tracking with time-decay. Feeds routing quality over time. Persists to `.monomind/scores.jsonl`.
+---
-</details>
+## Agent Catalog
-<details>
-<summary>⚡ <strong>Agent Booster (WASM)</strong> — Skip the LLM for simple code transforms</summary>
+### Development
-Agent Booster uses WebAssembly to handle deterministic code transforms without any LLM call:
+| 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 |
-| Intent               | Example                        | vs LLM      |
-| -------------------- | ------------------------------ | ----------- |
-| `var-to-const`       | `var x = 1` → `const x = 1`    | 352× faster |
-| `add-types`          | Add TypeScript annotations     | 420× faster |
-| `add-error-handling` | Wrap in try/catch              | 380× faster |
-| `async-await`        | `.then()` → `async/await`      | 290× faster |
-| `add-logging`        | Insert structured debug logs   | 352× faster |
-| `remove-console`     | Strip all `console.*` calls    | 352× faster |
-| `format-string`      | Modernize to template literals | 400× faster |
-| `null-check`         | Add `?.` / `??` operators      | 310× faster |
+### Marketing & Growth
-When hooks emit `[AGENT_BOOSTER_AVAILABLE]`, Claude Code intercepts and uses the Edit tool directly — zero LLM round-trip.
+| 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 |
-</details>
+### Game Development
-<details>
-<summary>💰 <strong>Token Optimizer</strong> — 30–50% API cost reduction</summary>
+| 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 |
-Smart caching and routing stack multiplicatively to reduce API costs:
+[See all 230 agents →](.claude/agents/)
-| Optimization                 | Savings    | Mechanism                                   |
-| ---------------------------- | ---------- | ------------------------------------------- |
-| ReasoningBank retrieval      | –32%       | Fetches relevant patterns, not full context |
-| Agent Booster transforms     | –15%       | Simple edits skip LLM entirely              |
-| Pattern cache (95% hit rate) | –10%       | Reuses embeddings and routing decisions     |
-| Optimal batch size           | –20%       | Groups related operations                   |
-| **Combined**                 | **30–50%** | Multiplicative stacking                     |
+---
-</details>
+## Swarm Orchestration
-<details>
-<summary>🏛️ <strong>Governance</strong> — Runtime policy enforcement from CLAUDE.md</summary>
+### How Swarms Work
-`@monomind/guidance` compiles `CLAUDE.md` into a 7-phase runtime enforcement pipeline:
+<p align="center">
+  <img src="assets/swarm-inspector.png" alt="Swarm Inspector — topology graph, agent roles, and communication logs" width="100%" />
+</p>
 ```
-CLAUDE.md ──► Compile ──► Retrieve ──► Enforce ──► Trust ──► Prove ──► Defend ──► Evolve
+/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
 ```
-| Phase       | Enforces                                                            |
-| ----------- | ------------------------------------------------------------------- |
-| **Enforce** | Destructive ops, tool allowlist, diff size limits, secret detection |
-| **Trust**   | Per-agent trust accumulation with privilege tiers                   |
-| **Prove**   | HMAC-SHA256 hash-chained audit envelopes                            |
-| **Defend**  | Prompt injection, memory poisoning, collusion detection             |
-| **Evolve**  | Policy drift detection, auto-update proposals                       |
+### Anti-Drift Protection
-1,331 tests · 27 subpath exports · WASM security kernel
+Swarms don't just run — they **stay on track**:
-</details>
+- **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
 ---
-## Quick Start
-### Prerequisites
+## Commands
-- **Node.js 20+** (required)
-- **Claude Code** — `npm install -g @anthropic-ai/claude-code`
+### Slash Commands (Inside Claude Code)
-### Installation
+| 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 |
-**One-line (recommended):**
+### CLI Commands
 ```bash
-curl -fsSL https://cdn.jsdelivr.net/gh/nokhodian/monomind@main/scripts/install.sh | 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
 ```
-**Via npx:**
+41 CLI commands across: agent management, swarm coordination, memory, sessions, hooks, neural training, security, performance profiling, and more.
-```bash
-npx monomind@latest init --wizard
-```
+### Session Inspector
-**Manual:**
+Every session is recorded and browsable — tool calls, agent spawns, memory operations, and full conversation replay:
-```bash
-# Register MCP server with Claude Code
-claude mcp add monomind -- npx -y monomind@latest mcp start
+<p align="center">
+  <img src="assets/session-detail.png" alt="Session Inspector — full conversation replay with tool breakdown" width="100%" />
+</p>
-# Start background worker daemon
-npx monomind@latest daemon start
+---
-# Health check
-npx monomind@latest doctor --fix
-```
+## Memory & Intelligence
-### First Commands
+### Knowledge Graph (Graphify)
+Monomind builds a full dependency graph of your codebase — automatically queried before every task:
 ```bash
-# Spawn an agent
-npx monomind@latest agent spawn -t coder --name my-coder
+# What files are relevant to my task?
+graphify_suggest "add webhook retry logic"
+# → returns ranked list of files with relevance scores
-# Launch a full swarm
-npx monomind@latest hive-mind spawn "Refactor auth module to use OAuth2"
+# What depends on UserService?
+graphify_query "UserService dependencies"
+# → returns file paths + line numbers
-# Search learned patterns
-npx monomind@latest memory search -q "authentication patterns"
+# Find the most connected files in the codebase
+graphify_god_nodes
+# → returns high-centrality internal files (external/test filtered out)
 ```
----
-## ⚡ Slash Commands
+All graphify tools are called automatically by hooks and slash commands — you don't need to invoke them manually.
-> Type these directly in Claude Code. No setup beyond `npx monomind init`.
----
+### Vector Memory (AgentDB + HNSW)
-### 🤖 Agent Intelligence
+Every insight, pattern, and decision is stored in searchable vector memory:
-| Command | What it does |
-|---|---|
-| **`/specialagent`** | Scores all 60+ agents against your task and picks the best one (or recommends a full swarm config). Prevents wasting a generic `coder` on a job that needs a `Database Optimizer` or `tdd-london-swarm`. |
-| **`/use-agent [slug]`** | Instantly activates a non-dev specialist agent — Sales Coach, TikTok Strategist, Legal Compliance Checker, UX Researcher, etc. Without a slug, auto-picks from conversation context. |
-| **`/list-agents [category]`** | Lists all available specialist agents, optionally filtered by category (`marketing`, `sales`, `design`, `academic`, `product`, `project-management`, `support`). |
+- **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)
-### 🌐 Browser & UI Automation
+Self-Optimizing Neural Adaptation learns from every task:
-| Command | What it does |
-|---|---|
-| **`/ui-test <url>`** | Full UI test run: opens the URL, snapshots interactive elements, walks golden-path flows, tests edge cases, reports pass/fail/warn. Powered by `agent-browser`. |
-| **`/browse <url>`** | Navigates to a URL and walks through it step by step — narrating what's on screen, proposing actions, and helping you accomplish tasks via the browser. |
-| **`/crawl <url>`** | Crawls a website — extracts links, text, structured data, or anything you specify. Great for scraping, auditing, or data extraction tasks. |
-| **`/browser`** | Raw agent-browser session: opens an interactive browser automation context with snapshot, click, fill, and screenshot tools. Use when you need fine-grained control. |
+- Pattern recognition improves agent routing over time
+- Trajectory tracking identifies what works and what doesn't
+- Automatic model adaptation with <0.05ms overhead
 ---
-### 🏛️ SPARC Methodology
-| Command | What it does |
-|---|---|
-| **`/sparc`** | Runs the full SPARC orchestrator — breaks down your objective, delegates to the right modes, and coordinates the full development lifecycle. |
-| **`/sparc spec-pseudocode`** | Captures requirements, edge cases, and constraints, then translates them into structured pseudocode ready for implementation. |
-| **`/sparc code`** | Auto-coder mode — writes clean, efficient, modular code from pseudocode or a spec. |
-| **`/sparc debug`** | Debugger mode — traces runtime bugs, logic errors, and integration failures systematically. |
-| **`/sparc security-review`** | Security reviewer — static and dynamic audit, flags secrets, poor module boundaries, and injection risks. |
-| **`/sparc devops`** | DevOps mode — CI/CD, Docker, deployment automation. |
-| **`/sparc docs-writer`** | Writes clear, modular Markdown documentation: READMEs, API references, usage guides. |
-| **`/sparc refinement-optimization-mode`** | Refactors, modularizes, and improves system performance. Enforces file size limits and dependency hygiene. |
-| **`/sparc integration`** | System integrator — merges outputs of all modes into a working, tested, production-ready system. |
+## 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                      │
+└─────────────────────────────────────────────────────────────┘
+```
-### 🐝 Swarm & Memory
+### Key Packages
-| Command | What it does |
+| Package | Purpose |
 |---|---|
-| **`/monomind-swarm`** | Coordinates a multi-agent swarm for complex tasks — spawns agents, distributes work, waits for results, synthesizes output. |
-| **`/monomind-memory`** | Interacts with the AgentDB memory system — store, search, retrieve, and inspect patterns across sessions. |
-| **`/monomind-help`** | Shows all Monomind CLI commands and usage reference inline. |
+| `@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 |
 ---
-> **Pro tip — automatic activation:** You don't need to type slash commands for most flows. The `UserPromptSubmit` hook reads every prompt and automatically suggests the right slash command (or activates it) based on what you wrote. `/specialagent` activates when you ask "which agent", `/ui-test` activates when you say "test the UI", `/browse` activates when you say "go to the website", etc.
+## Performance
----
-## Agents
-100+ specialized agents across every engineering domain:
-<details>
-<summary>🔧 <strong>Core Development</strong></summary>
-| Agent        | Specialization                                       |
-| ------------ | ---------------------------------------------------- |
-| `coder`      | Clean, efficient implementation across any language  |
-| `reviewer`   | Code review — correctness, security, maintainability |
-| `tester`     | TDD, integration, E2E, coverage analysis             |
-| `planner`    | Task decomposition, sprint planning, roadmap         |
-| `researcher` | Deep research, information gathering                 |
-| `architect`  | System design, DDD, architectural patterns           |
-| `analyst`    | Code quality analysis and improvement                |
-</details>
-<details>
-<summary>🔒 <strong>Security</strong></summary>
-| Agent                | Specialization                                           |
-| -------------------- | -------------------------------------------------------- |
-| `security-architect` | Threat modeling, secure design, vulnerability assessment |
-| `security-auditor`   | Smart contract audits, CVE analysis                      |
-| `security-engineer`  | Application security, OWASP, secure code review          |
-| `threat-detection`   | SIEM rules, MITRE ATT&CK, detection engineering          |
-| `compliance-auditor` | SOC 2, ISO 27001, HIPAA, PCI-DSS                         |
-</details>
-<details>
-<summary>🐝 <strong>Swarm & Consensus</strong></summary>
-| Agent                      | Specialization                                            |
-| -------------------------- | --------------------------------------------------------- |
-| `hierarchical-coordinator` | Queen-led coordination with specialized worker delegation |
-| `mesh-coordinator`         | P2P mesh, distributed decision-making, fault tolerance    |
-| `adaptive-coordinator`     | Dynamic topology switching, self-organizing               |
-| `byzantine-coordinator`    | BFT consensus, malicious actor detection                  |
-| `raft-manager`             | Raft protocol, leader election, log replication           |
-| `gossip-coordinator`       | Gossip-based eventual consistency                         |
-| `crdt-synchronizer`        | Conflict-free replication                                 |
-| `consensus-coordinator`    | Sublinear solvers, fast agreement                         |
-</details>
-<details>
-<summary>🚀 <strong>DevOps & Infrastructure</strong></summary>
-| Agent                | Specialization                                      |
-| -------------------- | --------------------------------------------------- |
-| `devops-automator`   | CI/CD pipelines, infrastructure automation          |
-| `cicd-engineer`      | GitHub Actions, pipeline creation                   |
-| `sre`                | SLOs, error budgets, chaos engineering              |
-| `incident-response`  | Production incident management, post-mortems        |
-| `database-optimizer` | Schema design, query optimization, PostgreSQL/MySQL |
-| `data-engineer`      | Data pipelines, lakehouse, dbt, Spark, streaming    |
-</details>
-<details>
-<summary>🌐 <strong>Frontend, Mobile & Specialized</strong></summary>
-| Agent               | Specialization                                  |
-| ------------------- | ----------------------------------------------- |
-| `frontend-dev`      | React/Vue/Angular, UI, performance optimization |
-| `mobile-dev`        | React Native iOS/Android, cross-platform        |
-| `accessibility`     | WCAG, screen readers, inclusive design          |
-| `solidity-engineer` | EVM smart contracts, gas optimization, DeFi, L2 |
-| `ml-engineer`       | ML model development, training, deployment      |
-| `embedded-firmware` | ESP32, STM32, FreeRTOS, Zephyr, bare-metal      |
-| `backend-architect` | Scalable systems, microservices, API design     |
-| `technical-writer`  | Developer docs, API references, tutorials       |
-</details>
-<details>
-<summary>🔀 <strong>GitHub Workflow Automation</strong></summary>
-| Agent                 | Specialization                                      |
-| --------------------- | --------------------------------------------------- |
-| `pr-manager`          | PR lifecycle, review coordination, merge management |
-| `code-review-swarm`   | Parallel multi-agent code review                    |
-| `release-manager`     | Automated release coordination, changelog           |
-| `repo-architect`      | Repository structure, multi-repo management         |
-| `issue-tracker`       | Issue management, project coordination              |
-| `workflow-automation` | GitHub Actions creation and optimization            |
-</details>
-<details>
-<summary>🔬 <strong>SPARC Methodology</strong></summary>
-| Agent           | Specialization                          |
-| --------------- | --------------------------------------- |
-| `sparc-coord`   | SPARC orchestrator across all 5 phases  |
-| `specification` | Requirements analysis and decomposition |
-| `pseudocode`    | Algorithm design, logic planning        |
-| `architecture`  | System design from spec                 |
-| `refinement`    | Iterative improvement                   |
-| `sparc-coder`   | TDD-driven implementation from specs    |
-View all: `npx monomind@latest agent list`
-</details>
+| 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 |
 ---
-## Live Statusline
+## Who Uses Monomind?
-Monomind adds a real-time six-row dashboard to Claude Code:
+Monomind is built for teams and individuals who use Claude Code for serious engineering work:
-```
-▊ Monomind v1.0.0  ○ IDLE  nokhodian  │  ⎇ main  +1  ~9921 mod  ↑5  │  🤖 Sonnet 4.6
-──────────────────────────────────────────────────────────────────────────────────────
-💡  INTEL    ▱▱▱▱▱▱ 3%   │   📚 190 chunks   │   76 patterns
-──────────────────────────────────────────────────────────────────────────────────────
-🐝  SWARM    0/15 agents   ⚡ 14/14 hooks   │   🎯 3 triggers · 24 agents   │   → ROUTED  👤 Coder  81%
-──────────────────────────────────────────────────────────────────────────────────────
-🧩  ARCH     82/82 ADRs   │   DDD ▰▰▱▱▱ 40%   │   🛡️ ✖ NONE   │   CVE not scanned
-──────────────────────────────────────────────────────────────────────────────────────
-🗄️  MEMORY   0 vectors   │   2.0 MB   │   🧪 66 test files   │   MCP 1/1  DB ✔
-──────────────────────────────────────────────────────────────────────────────────────
-📋  CONTEXT  📄 SI 80% budget (1201/1500 chars)   │   🏗 ▰▰▱▱▱ 2/5 domains   │   💾 47 MB RAM
-```
-| Row         | Shows                                                               |
-| ----------- | ------------------------------------------------------------------- |
-| **Header**  | Version, session state, git user, branch, uncommitted changes       |
-| **INTEL**   | Intelligence score, knowledge chunks indexed, learned patterns      |
-| **SWARM**   | Active agents, hook count, microagent triggers, last routing result |
-| **ARCH**    | ADR compliance, DDD domain coverage, security gates, CVE status     |
-| **MEMORY**  | Vector count, DB size, test file count, MCP/DB health               |
-| **CONTEXT** | Shared instructions budget, domain coverage, RAM usage              |
-Toggle compact ↔ full: `/ts` — Full reference: [tagline.md](tagline.md)
+- **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
 ---
-## Packages
-todo: write about packages of this app
-## Plugins
-todo: write about plugins of this app
-20 plugins via the IPFS-distributed registry:
-```bash
-npx monomind@latest plugins list
-npx monomind@latest plugins install @monomind/plugin-name
-npx monomind@latest plugins create my-plugin
-```
 ## Contributing
 ```bash
 git clone https://github.com/nokhodian/monomind.git
-cd monomind/packages
+cd monomind
 pnpm install
-pnpm test
+monomind doctor --fix
 ```
-## Support
-|               |                                                                                        |
-| ------------- | -------------------------------------------------------------------------------------- |
-| Documentation | [github.com/nokhodian/monomind](https://github.com/nokhodian/monomind)               |
-| Issues        | [github.com/nokhodian/monomind/issues](https://github.com/nokhodian/monomind/issues) |
-| Enterprise    | [monoes.me](monoes.me)                                                                 |
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 ---
-MIT — [nokhodian](https://github.com/nokhodian)
+## License
+MIT License — See [LICENSE](LICENSE) for details.
 ---
-## Acknowledgements
-Monomind builds on ideas, patterns, and research from the following projects:
-| Repository                                                                      | What we took                                                                                                                                     |
-| ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
-| [ruvnet/ruflo](https://github.com/ruvnet/ruflo)                                 | Original skeleton — swarm coordination, hooks system, and SPARC methodology                                                                      |
-| [msitarzewski/agency-agents](https://github.com/msitarzewski/agency-agents)     | Agent architecture patterns and multi-agent md files                                                                                             |
-| [microsoft/autogen](https://github.com/microsoft/autogen)                       | Human oversight interrupt gates, AutoBuild ephemeral agents, procedural skill learning from executions, and tool-retry patterns                  |
-| [crewAIInc/crewAI](https://github.com/crewAIInc/crewAI)                         | Multi-tier memory (short/long/entity/contextual), role/goal/backstory agent registry, task context chaining, and output schema patterns          |
-| [langchain-ai/langgraph](https://github.com/langchain-ai/langgraph)             | Graph checkpointing + resume, `StateGraph` workflow DSL (fan-out/fan-in, conditional, loops), and entity extraction from conversation state      |
-| [All-Hands-AI/OpenHands](https://github.com/All-Hands-AI/OpenHands)             | Per-agent Docker/WASM sandboxing, semantic versioned agent registry (AgentHub), and EventStream session replay                                   |
-| [agno-agi/agno](https://github.com/agno-agi/agno)                               | `AgentMemory` knowledge base architecture and team-level agent coordination class                                                                |
-| [huggingface/smolagents](https://github.com/huggingface/smolagents)             | Explicit planning step before execution and `ManagedAgent` delegation wrapper                                                                    |
-| [pydantic/pydantic-ai](https://github.com/pydantic/pydantic-ai)                 | Typed `Agent[Deps, Result]` I/O schemas, auto-retry on validation failure, `TestModel` for deterministic CI, and dynamic system prompt functions |
-| [BAAI/AgentSwarm (Agency Swarm)](https://github.com/VRSEN/agency-swarm)         | Declared directed communication flows between agents and shared instruction propagation                                                          |
-| [BerriAI/atomic-agents](https://github.com/KRunchPL/atomic-agents)              | `BaseIOSchema` typed agent contracts and `SystemPromptContextProvider` composition                                                               |
-| [stanfordnlp/dspy](https://github.com/stanfordnlp/dspy)                         | `BootstrapFewShot` + MIPRO automatic prompt optimization pipeline                                                                                |
-| [aurelio-labs/semantic-router](https://github.com/aurelio-labs/semantic-router) | Utterance-based `RouteLayer` replacing static routing codes, dynamic routes, and hybrid routing mode                                             |
-| [langfuse/langfuse](https://github.com/langfuse/langfuse)                       | Unified trace/span/generation observability hierarchy, per-agent cost attribution, latency views, and prompt version management                  |
-| [karpathy/autoresearch](https://github.com/karpathy/autoresearch)               | Experiment loop protocol (BASELINE/KEEP/DISCARD `results.tsv`), fixed time-budget per run, and Best-Fit Decreasing bin packing for API chunking — wired into `@monomind/graph` pipeline |
-| [safishamsi/graphify](https://github.com/safishamsi/graphify)                   | Knowledge graph construction approach, AST-based node/edge extraction, community detection with Louvain, and `GRAPH_REPORT.md` report format — foundation for `@monomind/graph`          |
-| [google/gvisor](https://gvisor.dev) ([paper](https://dl.acm.org/doi/10.1145/3317550.3321422)) | gVisor `runsc` OCI-compatible runtime — reduces Docker container syscall surface from 350+ to ~50 interceptions; wired into `SandboxConfig.use_gvisor` and `buildDockerArgs()` |
-| [Indirect Injection research](https://arxiv.org/abs/2302.12173) ([follow-up](https://arxiv.org/abs/2310.12815)) | Prompt injection via external tool content — `validateExternalContent()` in `@monomind/security` applies pattern + optional aidefence semantic scan to all externally-sourced content |
-| [FOREVER Forgetting Curve](https://arxiv.org/html/2601.03938v1)                 | Exponential importance-weighted forgetting curve (`importanceScore × e^(−λt)`) replacing linear decay — implemented in `LearningBridge.decayConfidences()` and `MemoryEntry.importanceScore` |
-| [Awesome RLVR](https://github.com/opendilab/awesome-RLVR)                       | Reinforcement Learning with Verifiable Rewards — `hooksModelOutcome` now accepts `verifier_type` (tsc/vitest/eslint/llm_judge) and `exit_code` to derive grounded binary reward signals |
-| [ERL — Experiential Reflective Learning](https://arxiv.org/abs/2603.24639)      | Structured `{condition, action, confidence}` heuristics extracted at `hooks_post-task` and injected as ranked hints into `hooks_pre-task` suggestions via the `heuristics` memory namespace |
-| [A-MEM — Agentic Memory](https://arxiv.org/abs/2502.12110)                      | Zettelkasten-style automatic note linking — after every `bridgeStoreEntry`, top-3 HNSW neighbors above 0.7 similarity receive a `similar` causal edge via `bridgeRecordCausalEdge` |
-| [DSPy](https://dspy.ai)                                                         | Bayesian exploration option (`bayesian: true`) added to `PromptOptimizer.optimize()` — shuffles trace scores with U(0,0.1) noise before `selectExamples` to escape local optima |
-| [Collaborative Memory Promotion](https://arxiv.org/abs/2505.18279)              | Auto-promote memory `access_level` from `private` → `team` when 3+ distinct agents read an entry within 24 h — implemented via `agent_reads` table in `SQLiteBackend` and `checkAndPromoteEntry()` |
-| [Zep / Graphiti — Bi-Temporal Knowledge Graph](https://arxiv.org/abs/2501.13956) ([repo](https://github.com/getzep/graphiti)) | Separates event time T from ingestion time T' — `MemoryEntry.eventAt` nullable field + `event_at` SQLite column for temporal filtering without index rebuilds; 94.8% on Deep Memory Retrieval at 90% lower latency than MemGPT |
-| [HippoRAG 2 — PPR Graph Retrieval](https://arxiv.org/abs/2405.14831)            | Personalized PageRank over the memory reference graph — `MemoryGraph.pprRerank()` expands HNSW candidates one hop via `MemoryEntry.references`, boosting associative recall by up to 20% on multi-hop QA |
-| [RAPTOR — Recursive Abstractive Tree Indexing](https://arxiv.org/abs/2401.18059) | Cluster episodic entries → summarize each cluster → store as `contextual`-tier entry — implemented in the `consolidate` background worker (`runConsolidateWorker`), creating RAPTOR's tree within existing stores |
-| [Multi-Agent Reflexion (MAR)](https://arxiv.org/html/2512.20845)                | Heterogeneous Diagnoser → Critic×2 → Aggregator reflection loop — `hooks_post-task` now returns `marReflection` when a task fails, specifying the four agent roles and spawn order |
-| [TextGrad — Automatic Differentiation via Text](https://arxiv.org/abs/2406.07496) ([Nature](https://www.nature.com)) | LLM textual gradients flow backward through the pipeline — on `hooks_post-task` failure a `textual_gradient` critique is stored to the `gradients` memory namespace for next-prompt injection; +20% on LeetCode-Hard |
-| [CP-WBFT — Confidence-Probe Weighted BFT](https://arxiv.org/abs/2511.10400)     | Confidence-weighted voting replaces one-node-one-vote — `weightedTally()` in `consensus/vote-signer.ts` scales each agent's vote by its confidence score, tolerating 85.7% fault rate (AAAI 2026) |
-| [GraphRAG + Practical GraphRAG](https://arxiv.org/abs/2404.16130) ([Practical](https://arxiv.org/abs/2507.03226)) | Community-level global query answering — `MemoryGraph.getCommunitySummaries()` returns top-k community descriptors (nodeCount, avgPageRank) for prepending to semantic search results; enables thematic reasoning over the entire knowledge base |
-| [MemPalace](https://github.com/nokhodian/mempalace) | Spatially-organized verbatim memory with Wing→Room→Hall hierarchy, Okapi BM25 + closet-topic hybrid retrieval, score-based L1 promotion, and temporal knowledge graph — implemented in `.claude/helpers/memory-palace.cjs`; injects L0 identity + L1 essential story on every session start via `SessionStart` hook; achieves 96.6% LongMemEval recall without summarization |
+<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>