monomind 1.11.12 → 1.11.14

package/.claude/scheduled_tasks.lock

@@ -1 +1 @@
-{"sessionId":"64f579c5-48a4-4db0-a746-46a7f3fab6ab","pid":6041,"procStart":"Tue Jun  9 11:59:20 2026","acquiredAt":1781035942894}
+{"sessionId":"32f0c05a-658e-4c7f-9974-7214ef185323","pid":6093,"procStart":"Tue Jun  9 11:59:20 2026","acquiredAt":1781172269626}

package/.claude/skills/mastermind/architect.md

@@ -88,14 +88,14 @@ If this skill is invoked directly (not by master):
    ```
    After the bash above completes, apply the 60% classification rule: sum the total file count across all extensions. If any single extension group exceeds 60% of the total, set `<stack>` to that stack's name (e.g. `typescript`, `python`, `go`); otherwise set `<stack>` to `multi-stack`. Use this value for `Stack: <stack>` in all subsequent briefings.
    If `scope` was not provided by the caller, infer it from the prompt: "review"/"audit"/"check"/"assess" → `review`; "deduplicate"/"dedup"/"consolidate" → `deduplicate`; "design"/"architect"/"model"/"bounded context" → `design`; "migrate"/"migration"/"port to"/"convert" → `migrate`; no keyword match or multiple keyword matches → `all`. Use the resolved scope for all subsequent steps.
-5. If `board_id` was not provided by the caller: find or create monotask space `<project_name>`, then create board `architect` within it (optional — proceed without a board if monotask is not installed). Before executing the bash block below, substitute the resolved `project_name` (or `basename "$PWD"` if not provided) for every `<project_name>` occurrence:
+5. If `board_id` was not provided by the caller: find or create monotask space `<project_name>`, then create board `architect` within it. Before executing the bash block below, substitute the resolved `project_name` (or `basename "$PWD"` if not provided) for every `<project_name>` occurrence:
    ```bash
    space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="<project_name>" '$2==n{print $1}' | head -1)
    [ -z "$space_id" ] && space_id=$(monotask space create "<project_name>" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
    result=$(monotask board create "architect" --json 2>/dev/null)
    board_id=$(echo "$result" | jq -r '.id // empty')
    [ -n "$board_id" ] && [ -n "$space_id" ] && monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
-   [ -z "$board_id" ] && echo "[architect] monotask board unavailable — board tracking skipped. Install monotask to enable progress tracking."
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create monotask board — verify monotask is installed (run: monotask --version)"; exit 1; }
    echo "$board_id"
    ```
    If this block exits with an error (board_id is still empty), stop execution and return an error to the caller — do not proceed to complexity assessment.
@@ -363,13 +363,10 @@ For each stream, identify:
 - Dependencies between streams (e.g. coupling analysis before deduplication plan)
 
 STEP 3 — CREATE TASKS
-For each architecture stream, create a monotask card on the project board if a board is available. If BOARD_ID is empty (monotask not installed), skip all monotask card operations in this step — proceed directly to STEP 4 with an in-memory task list instead.
-
-If BOARD_ID is non-empty: First resolve column IDs (slash commands are not available inside background Task agents — use bash directly):
+For each architecture stream, create a monotask card on the project board. First resolve column IDs (slash commands are not available inside background Task agents — use bash directly):
 
 \`\`\`bash
-[ -z "$BOARD_ID" ] && { echo "[architect] No board — skipping card creation, proceeding with in-memory tasks."; }
-columns=$([ -n "$BOARD_ID" ] && monotask column list "$BOARD_ID" --json || echo '[]')
+columns=$(monotask column list "$BOARD_ID" --json)
 COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Todo" or .title == "Backlog") | .id' | head -1)
 COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Done") | .id' | head -1)
 \`\`\`

package/.claude/skills/mastermind/autodev.md

@@ -432,7 +432,7 @@ Invoke `Skill("mastermind:build")` with:
 - `brain_context`: the loaded brain context
 - `project_name`: `$(basename "$PWD")`
 - `mode`: `auto`
-- `board_id`: the autodev board (only if non-empty; omit if monotask was unavailable)
+- `board_id`: the autodev board (create once at startup, reuse)
 
 The brief passed to build MUST include:
 - What to build (concrete spec, not vague)
@@ -490,13 +490,11 @@ If `N < count`: log `[autodev] Moving to improvement <N+1>/<count>...` and repea
 
 1. Extract flags (leading integer for count, --newfeature N, --focus, --auto/--confirm)
 2. Load brain context via _protocol.md Brain Load Procedure (namespace: `autodev`)
-3. Create monotask board (optional — skip gracefully if monotask is not installed):
+3. Create monotask board:
    ```bash
    project_name="${project_name:-$(basename "$PWD")}"
    board_id=$(monotask board create "autodev" --json 2>/dev/null | jq -r '.id // empty')
-   [ -z "$board_id" ] && echo "[autodev] monotask board unavailable — board tracking skipped."
    ```
-   Pass `board_id` to `mastermind:build` only if non-empty; omit the parameter otherwise.
 4. **If `--newfeature` was parsed:** run the Feature Pipeline (FP-0 through FP-End) and skip the improvement loop entirely.
    **Otherwise:** run the Loop section above for each improvement.
 5. At end: follow _protocol.md Brain Write Procedure (namespace: `autodev`)

package/.claude/skills/mastermind/idea.md

@@ -9,14 +9,6 @@ default_mode: confirm
 
 This skill is invoked by `mastermind:master` or directly via `/mastermind:idea`.
 
-**Extract `--monotask` flag:** If present in `$ARGUMENTS`, set `USE_MONOTASK=true` and remove it. Default: `USE_MONOTASK=false`.
-
-**File mode (default, `USE_MONOTASK=false`):**
-
-Invoke `Skill("mastermind:ideate", $ARGUMENTS)` immediately — it provides the same research, evaluation, elaboration, and task-decomposition pipeline with file-first storage (`docs/ideas/` and `docs/tasks/`). The rest of this skill only runs in monotask mode.
-
-**Monotask mode (`USE_MONOTASK=true` only):** Continue with the steps below.
-
 ---
 
 ## Inputs

package/.claude/skills/mastermind/monitor.md

@@ -1128,7 +1128,7 @@ If `caller` is not "command", follow `_protocol.md` Brain Write Procedure for do
       "type": "linear",
       "filter": {
         "team": "ENG",
-        "assignees": ["morteza@agent-f.com"],
+        "assignees": ["your@email.com"],
         "states": ["Todo"],
         "labels": ["ai-agent"],
         "project": ""
@@ -1219,7 +1219,7 @@ If `caller` is not "command", follow `_protocol.md` Brain Write Procedure for do
 
 # Add a Linear source to an existing monitor
 /mastermind:monitor --action add-source --name dev-watcher \
-  --source linear --team ENG --user morteza@agent-f.com \
+  --source linear --team ENG --user your@email.com \
   --state Todo --label ai-agent
 
 # Add a monotask board source

package/README.md

@@ -1,12 +1,12 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/monoes/monomind/main/assets/mascot.png" alt="Monomind Mascot" width="160" />
+  <img src="https://raw.githubusercontent.com/monoes/monomind/main/assets/mascot.png" alt="Monomind" width="140" />
 </p>
 
 <h1 align="center">Monomind</h1>
 
 <p align="center">
-  <strong>The autonomous Claude Code orchestration layer.</strong><br/>
-  Research → Build → Review → Repeat. While you sleep.
+  <strong>Hire an AI team. Set a goal. Walk away.</strong><br/>
+  Autonomous Claude Code orchestration with persistent memory, self-coordinating agent orgs, and a codebase knowledge graph.
 </p>
 
 <p align="center">
@@ -19,169 +19,283 @@
 </p>
 
 <p align="center">
-  <a href="https://monoes.github.io/monomind/">📖 Docs</a> &nbsp;·&nbsp;
-  <a href="#quickstart">Quickstart</a> &nbsp;·&nbsp;
-  <a href="#what-it-does">What It Does</a> &nbsp;·&nbsp;
-  <a href="#commands">Commands</a> &nbsp;·&nbsp;
-  <a href="#packages">Packages</a> &nbsp;·&nbsp;
-  <a href="https://github.com/monoes/monomind">GitHub</a>
+  <a href="https://monoes.github.io/monomind/#orgs">🏢 Orgs</a> &nbsp;·&nbsp;
+  <a href="https://monoes.github.io/monomind/#getting-started">🚀 Quickstart</a> &nbsp;·&nbsp;
+  <a href="https://monoes.github.io/monomind/#mastermind">⚡ Mastermind</a> &nbsp;·&nbsp;
+  <a href="https://monoes.github.io/monomind/#slash">📋 Commands</a> &nbsp;·&nbsp;
+  <a href="https://monoes.github.io/monomind/#architecture">🏗️ Architecture</a>
 </p>
 
 ---
 
 ## What is Monomind?
 
-You already use Claude Code. Monomind makes it **autonomous**.
+Claude Code is already powerful. Monomind makes it **run itself**.
 
-Give it a direction. Walk away. Come back to a finished feature.
+Install once. Wire it into Claude Code. Then instead of prompting Claude to do individual tasks, you tell Monomind what outcome you want — and it assembles a team, coordinates the work, and delivers.
 
 ```bash
+# Assemble an AI content team and let it run
+/mastermind:createorg content-team "publish 3 SEO-optimized posts per week"
+/mastermind:runorg --org content-team
+
+# Or run the autonomous code improvement loop
 /mastermind:autodev --tillend --focus security
 ```
 
-Monomind researches your project, selects the highest-impact improvement, builds it with a coordinated agent chain, reviews until zero findings — then loops. Indefinitely. Until there is nothing left to fix.
+That's it. Come back later.
 
-```
-Without Monomind   You prompt Claude → wait → review → iterate manually
-With Monomind      You set a direction → Monomind executes the entire loop
+---
+
+## 🏢 Autonomous Organizations
+
+> **This is the headline feature.** Build a persistent AI organization — roles, hierarchy, shared task board — and start it as a background daemon that runs without you.
+
+### The idea
+
+Every business function needs a team. Monomind lets you design that team in one command, then run it forever. The org persists across sessions. It checkpoints, recovers from failures, and coordinates its agents through a shared task board — all automatically.
+
+```mermaid
+flowchart TD
+    U(["You"])
+    CO["/mastermind:createorg\nDefine goal + roles"]
+    RO["/mastermind:runorg\nStart daemon"]
+    BOSS["Boss Agent\ncoordinator"]
+    W["Writer\nContent Creator"]
+    S["SEO Specialist"]
+    R["Reviewer"]
+    M["Growth Marketer"]
+    BOARD[("Shared\nTask Board")]
+    MEM[("AgentDB\nMemory")]
+
+    U --> CO --> RO --> BOSS
+    BOSS -->|spawns| W
+    BOSS -->|spawns| S
+    BOSS -->|spawns| R
+    BOSS -->|spawns| M
+    BOSS <-->|claims + reports| BOARD
+    W <-->|stores output| MEM
+    S <-->|reads context| MEM
+
+    style BOSS fill:#00D2AA22,stroke:#00D2AA
+    style BOARD fill:#F59E0B22,stroke:#F59E0B
+    style MEM fill:#8B5CF622,stroke:#8B5CF6
 ```
 
----
+### Two commands to a running org
 
-## Quickstart
+**Step 1 — Design it:**
 
-```bash
-# Install globally
-npm install -g monomind
+```
+/ mastermind:createorg content-team
+  "Build and publish 3 blog posts per week on AI dev tools"
 
-# Initialise in your project
-cd your-project
-monomind init
+Deriving roles from goal...
 
-# Wire into Claude Code as an MCP server
-claude mcp add monomind npx monomind mcp start
+╔ ORG: content-team
+║ TOPOLOGY: star (5 roles)
 
-# Start the background daemon
-monomind daemon start
-```
+  boss      → coordinator
+  writer    → Content Creator
+  reviewer  → reviewer
+  marketer  → Growth Hacker
+  seo       → SEO Specialist
 
-Open Claude Code and run your first autonomous loop:
+Type "go" to save, or describe changes.
+→ go
 
-```bash
-/mastermind:autodev --tillend
+✓ Saved .monomind/orgs/content-team.json
+  → Run: /mastermind:runorg --org content-team
 ```
 
-**[→ Full setup guide](https://monoes.github.io/monomind/#getting-started)**
+**Step 2 — Start it:**
 
----
+```bash
+/mastermind:runorg --org content-team
 
-## What It Does
+# Boss agent spawns in background
+# Coordinates all roles via shared task board
+# Checkpoints every 30 minutes
+# Loops until you stop it
+```
 
-### `/mastermind:autodev` — The Autonomous Build Loop
+### What runs under the hood
 
+| What | How |
+|---|---|
+| **Boss agent** | Coordinator type, no supervisor — owns the goal |
+| **Role agents** | Spawned on demand, specialized by task type |
+| **Task board** | Todo → Doing → Done, shared across all agents |
+| **Memory** | All output stored in org-scoped AgentDB namespace |
+| **Checkpoint** | State saved every 30 min — survives crashes and restarts |
+| **Governance** | `auto` (free), `board` (approve sensitive), `strict` (approve all external actions) |
+
+### Topology is auto-derived
+
+```mermaid
+graph LR
+    A["1-3 roles"] -->|mesh| B["All-to-all\ndirect comms"]
+    C["4-6 roles"] -->|star| D["Boss to workers\nfan-out"]
+    E["7+ roles"] -->|hierarchical| F["Boss to leads to workers\nmiddle management"]
 ```
-Phase 1  Research    Parallel scan: git log, file analysis, TODO/FIXME grep,
-                     monograph god nodes, memory search for prior work.
-                     Returns ranked list of 3–5 improvement candidates.
 
-Phase 2  Select      Picks by feasibility × blast-radius × focus alignment.
-                     Stores selection to AgentDB. Avoids repeating past work.
+### Pre-built org types
 
-Phase 3  Build       Spawns architect → coder → tester → reviewer chain.
-                     Runs with concrete spec and acceptance criteria.
+| Org | Goal | Roles |
+|---|---|---|
+| `content-team` | 3 posts/week on AI tools | Director · Writer · Reviewer · SEO · Growth |
+| `dev-squad` | Features from design spec | Lead · Architect · Developer · QA |
+| `research-lab` | Weekly competitive intelligence | Director · Researcher · Analyst · Writer |
+| `sales-engine` | ICP research + outreach sequences | Director · Outbound · Email · Researcher |
+| `ops-squad` | 24/7 monitoring + incident response | SRE · Security · Perf · Incident Cmdr |
 
-Phase 4  Review      Code Reviewer + Security Engineer + Reality Checker
-                     run in parallel. Auto-fixes. Repeats up to 5× until clean.
+### Org management commands
 
-Phase 5  Loop        Records completion. Continues to next improvement.
-                     --tillend loops until zero findings remain.
+```bash
+/mastermind:createorg <name> "<goal>"   # design org from a goal
+/mastermind:runorg --org <name>         # start as background daemon
+/mastermind:orgs                        # list all orgs + status
+/mastermind:orgstatus --org <name>      # detailed status for one org
+/mastermind:stoporg --org <name>        # stop a running org
+/mastermind:approve                     # review pending approval requests
 ```
 
-### Swarm Topologies
+---
+
+## ⚡ The Autonomous Build Loop
+
+For code, `/mastermind:autodev` is the equivalent of Orgs — a loop that researches, builds, and reviews your codebase without stopping.
+
+```mermaid
+flowchart LR
+    R["Research\nParallel scan:\ngit log, files\nTODOs, graph\nmemory"] --> S
+    S["Select\nFeasibility x\nblast-radius x\nfocus"] --> B
+    B["Build\nArchitect\nCoder\nTester\nReviewer"] --> V
+    V["Review Loop\nCode + Security\n+ Reality\nmax 5 iterations"] --> L
+    L["Log + Loop\nStore to memory\n--tillend:\nschedule next"]
+    L -->|"more to do"| R
 
+    style R fill:#00D2AA22,stroke:#00D2AA
+    style B fill:#8B5CF622,stroke:#8B5CF6
+    style V fill:#F59E0B22,stroke:#F59E0B
+    style L fill:#10B98122,stroke:#10B981
 ```
-Hierarchical   Coordinator → specialists → reviewers. Best for features.
-Mesh           All-to-all communication. Best for codebase analysis.
-Adaptive       Changes topology based on task complexity.
-Hive-Mind      Byzantine fault-tolerant consensus across 6+ agents.
+
+```bash
+/mastermind:autodev --tillend              # loop until nothing left
+/mastermind:autodev --tillend --focus security   # bias toward security fixes
+/mastermind:autodev 3                     # exactly 3 improvements
 ```
 
-### Memory & Intelligence
+### Universal loop flags
 
-Every session writes to [AgentDB](https://github.com/monoes/monomind) — a hybrid SQLite + HNSW vector store. The next session reads it. Monomind learns which improvements it already shipped, which patterns failed, and which agents perform best on which tasks.
+| Flag | Purpose |
+|---|---|
+| `--tillend` | Repeat until empty round (zero findings, zero actions) |
+| `--repeat <N>` | Repeat exactly N times |
+| `--focus <area>` | Bias toward: `security` · `dx` · `performance` |
+| `--auto` | No confirmation prompts |
+| `--maxruns <N>` | Safety cap (default 50) |
 
 ---
 
-## Commands
+## 🚀 Quickstart
 
-### Core Loop Commands
+```bash
+# 1. Install
+npm install -g monomind
 
-| Command | What it does |
-|---|---|
-| `/mastermind:autodev` | Autonomous research → build → review loop |
-| `/mastermind:autodev --tillend` | Loops until zero findings remain |
-| `/mastermind:build` | Build a feature from a brief |
-| `/mastermind:review` | Iterative code review until clean |
-| `/mastermind:debug` | Systematic root-cause debugging |
-| `/mastermind:tdd` | Test-Driven Development: Red→Green→Refactor |
-| `/mastermind:plan` | Write a comprehensive implementation plan |
+# 2. Initialize in your project
+cd your-project
+monomind init
 
-### Research & Ideas
+# 3. Wire into Claude Code as an MCP server
+claude mcp add monomind npx monomind mcp start
 
-| Command | What it does |
-|---|---|
-| `/mastermind:research` | Deep research with structured output |
-| `/mastermind:idea` | Idea generation and evaluation |
-| `/mastermind:architect` | Architecture review and design |
-| `/mastermind:techport` | Assess a foreign codebase |
+# 4. Start the background daemon
+monomind daemon start
+
+# 5. Health check
+monomind doctor --fix
+```
 
-### Autonomous Orgs
+Open Claude Code. You now have 80+ slash commands available:
 
 ```bash
-/mastermind:createorg --schedule 1h   # define + schedule an agent org
-/mastermind:runorg                    # start the loop
-/mastermind:orgs                      # list all orgs + status
-/mastermind:stoporg                   # stop a running org
+/mastermind:autodev --tillend     # start autonomous code loop
+/mastermind:createorg my-team     # create your first AI org
+/mastermind:help                  # show all commands
 ```
 
-### Business Domains
+---
 
-```bash
-/mastermind:marketing    /mastermind:content    /mastermind:sales
-/mastermind:finance      /mastermind:ops        /mastermind:release
+## 🧠 Memory That Persists
+
+Every session, every agent, every org writes to **AgentDB** — a hybrid SQLite + HNSW vector store that survives across sessions. The next time you run anything, Monomind already knows what was built, what failed, and which patterns work.
+
+```mermaid
+graph TD
+    L0["L0 - In-flight\nCurrent session drawers\nephemeral"]
+    L1["L1 - Working\nCross-session memory\nBM25 K1=1.5, B=0.75"]
+    L2["L2 - Long-term\nAgentDB + HNSW index\nSemantic search"]
+    L3["L3 - Shared\nCross-agent namespace\nFederated swarm reads"]
+
+    L0 -->|promoted| L1 --> L2 --> L3
+
+    style L0 fill:#00D2AA11,stroke:#00D2AA
+    style L1 fill:#F59E0B11,stroke:#F59E0B
+    style L2 fill:#8B5CF611,stroke:#8B5CF6
+    style L3 fill:#EF444411,stroke:#EF4444
 ```
 
-**[→ Full command reference (80+ commands)](https://monoes.github.io/monomind/#slash)**
+```bash
+monomind memory store "key insight" --namespace my-project
+monomind memory search "auth implementation"     # BM25 + semantic hybrid
+```
 
 ---
 
-## CLI
+## 🗺️ Monograph — Your Codebase, as a Graph
+
+Before touching any file, Monomind queries **Monograph** — a SQLite-backed knowledge graph of your entire codebase. Nodes are files, classes, and functions. Edges are imports, calls, and dependencies.
 
 ```bash
-monomind init                   # project setup wizard
-monomind daemon start           # start background workers
-monomind agent spawn <type>     # spawn a named agent
-monomind swarm init             # initialise a multi-agent swarm
-monomind memory store           # store to AgentDB
-monomind memory search          # semantic search over AgentDB
-monomind hooks pre-task         # run pre-task security scan
-monomind doctor                 # diagnose your setup
+/mastermind:understand          # build the graph
+/mastermind:graph-status        # nodes · edges · freshness
+
+# Inside Claude Code, Monograph runs automatically:
+# → "what files does auth.ts import?"
+# → "what breaks if I change UserService?"
+# → "find all callers of validateToken()"
 ```
 
+23 MCP tools. Impact analysis. Shortest-path queries. Community detection. Zero grep.
+
 ---
 
-## Packages
+## 🎣 Hooks & Workers
 
-| Package | npm | Purpose |
-|---|---|---|
-| `monomind` | [![npm](https://img.shields.io/npm/v/monomind?style=flat-square&color=00D2AA)](https://www.npmjs.com/package/monomind) | Umbrella — install this |
-| `@monoes/monomindcli` | [![npm](https://img.shields.io/npm/v/@monoes/monomindcli?style=flat-square&color=4F46E5)](https://www.npmjs.com/package/@monoes/monomindcli) | CLI engine (41 commands) |
-| `monofence-ai` | [![npm](https://img.shields.io/npm/v/monofence-ai?style=flat-square&color=EF4444)](https://www.npmjs.com/package/monofence-ai) | AI manipulation defence |
-| `@monoes/monograph` | [![npm](https://img.shields.io/npm/v/@monoes/monograph?style=flat-square&color=F59E0B)](https://www.npmjs.com/package/@monoes/monograph) | Knowledge graph engine |
+Monomind wires 22 hook events into Claude Code. Every edit, task, command, and session fires hooks that log patterns, route agents, and train the intelligence system.
+
+```mermaid
+flowchart LR
+    CE["Claude Code\nEvent"] --> H["Hook Router"]
+    H --> P["pre-edit\npre-task\npre-command"]
+    H --> SS["session-start\nsession-end\nnotify"]
+    H --> I["route\nlearn\nbuild-agents"]
+    H --> T["teammate-idle\ntask-completed"]
 
-### monofence-ai — AI Security
+    I --> DB[("AgentDB\npatterns.json")]
+    DB -->|next session| CE
+```
+
+**12 background workers** run continuously: `security` · `health` · `swarm` · `learning` · `patterns` · `git` · `performance` and more.
+
+---
+
+## 🛡️ MonoFence AI — Security Layer
 
-Protect your LLM pipelines from prompt injection, jailbreaks, and evasion attacks:
+Every agent boundary is defended by **monofence-ai** — real-time detection of prompt injection, jailbreaks, homoglyphs, base64 evasion, multi-turn escalation, and PII leakage.
 
 ```typescript
 import { isSafe, createMonoDefence } from 'monofence-ai';
@@ -190,50 +304,93 @@ isSafe('Ignore all previous instructions');  // → false (~0.04ms)
 
 const fence = createMonoDefence({ enableContextTracking: true });
 const result = await fence.detect(userInput);
-// result.safe, result.threats, result.overallRisk
+// result.safe · result.threats · result.overallRisk
 ```
 
-Features: **EvasionDetector** (homoglyphs, leetspeak, base64) · **ContextTracker** (multi-turn escalation) · **OutputScanner** (PII leakage, echo attacks) · **Allowlist** (5 built-in + custom rules) · **SecurityHook** (pre-task blocking)
-
 ---
 
-## How the Agents Work
+## 📋 80+ Slash Commands
 
-```
-Claude Code  ←→  MCP Server  ←→  Monomind Daemon
-                                      │
-                    ┌─────────────────┼─────────────────┐
-                    ▼                 ▼                 ▼
-               AgentDB           Monograph          Hooks
-            (vector memory)   (knowledge graph)   (17 hook types)
-                    │                 │                 │
-                    └─────────────────┼─────────────────┘
-                                      ▼
-                              Agent Swarm
-                    architect · coder · tester · reviewer
-                    security · perf · docs · researcher
-```
+Everything runs from inside Claude Code via slash commands. Here's the highlight reel:
 
-Monomind coordinates. Claude Code creates. You ship.
+### Development
+| Command | What it does |
+|---|---|
+| `/mastermind:autodev` | Autonomous research → build → review loop |
+| `/mastermind:build` | Build a feature from a brief |
+| `/mastermind:review` | Iterative review until zero findings |
+| `/mastermind:debug` | Systematic root-cause debugging |
+| `/mastermind:tdd` | Red → Green → Refactor |
+| `/mastermind:architect` | Architecture review + file structure |
+| `/mastermind:plan` | Comprehensive implementation plan |
+| `/mastermind:worktree` | Feature work in isolated git worktree |
+
+### Organizations
+| Command | What it does |
+|---|---|
+| `/mastermind:createorg` | Design an autonomous agent org |
+| `/mastermind:runorg` | Start it as a background daemon |
+| `/mastermind:orgs` | List all orgs + status |
+| `/mastermind:approve` | Action pending approval requests |
+
+### Business Domains
+| Command | What it does |
+|---|---|
+| `/mastermind:marketing` | Campaigns, copy, SEO, social |
+| `/mastermind:content` | Blog posts, threads, newsletters |
+| `/mastermind:sales` | Outreach, proposals, pipeline |
+| `/mastermind:finance` | Budgets, invoicing, modeling |
+| `/mastermind:ops` | Operations and workflow automation |
+
+**[→ Full reference (80+ commands)](https://monoes.github.io/monomind/#slash)**
 
 ---
 
-## Why Monomind?
+## 📦 Packages
+
+| Package | npm | Purpose |
+|---|---|---|
+| `monomind` | [![npm](https://img.shields.io/npm/v/monomind?style=flat-square&color=00D2AA)](https://www.npmjs.com/package/monomind) | Umbrella — **install this one** |
+| `@monoes/monomindcli` | [![npm](https://img.shields.io/npm/v/@monoes/monomindcli?style=flat-square&color=4F46E5)](https://www.npmjs.com/package/@monoes/monomindcli) | CLI engine (41 commands) |
+| `monofence-ai` | [![npm](https://img.shields.io/npm/v/monofence-ai?style=flat-square&color=EF4444)](https://www.npmjs.com/package/monofence-ai) | AI manipulation defence |
+| `@monoes/monograph` | [![npm](https://img.shields.io/npm/v/@monoes/monograph?style=flat-square&color=F59E0B)](https://www.npmjs.com/package/@monoes/monograph) | Code knowledge graph |
+
+---
+
+## 🏗️ How It's Built
+
+```mermaid
+graph TD
+    CC["Claude Code"]
+    MCP["MCP Server\nmonomind mcp start"]
+    D["Background Daemon\n12 workers"]
+
+    CC <-->|"23 tools: monograph, memory, swarm"| MCP
+    MCP <--> D
+
+    D --> ADB[("AgentDB\nSQLite + HNSW")]
+    D --> MG[("Monograph\ncode graph")]
+    D --> HK["Hooks\n22 event types"]
+    D --> SW["Swarm\n6 topologies\n5 consensus algos"]
+
+    CC -->|"Task tool - spawns agents"| AG["Agent Swarm\narchitect, coder\ntester, reviewer\nsecurity, perf"]
+    AG <-->|reads and writes| ADB
+
+    style CC fill:#00D2AA22,stroke:#00D2AA
+    style AG fill:#8B5CF622,stroke:#8B5CF6
+    style ADB fill:#F59E0B22,stroke:#F59E0B
+```
 
-- **80+ slash commands** wired directly into Claude Code
-- **60+ agent types** for every engineering task
-- **Self-learning routing** — agents improve with every session
-- **Monograph** — full codebase knowledge graph, always fresh
-- **AgentDB** — hybrid SQLite + HNSW vector memory
-- **17 hook types** — pre/post edit, task, command, session
-- **Security layer** — monofence-ai defends every agent boundary
-- **One command** to set direction. Nothing else needed.
+**Claude Code handles all execution.** MCP tools only coordinate. Your data never leaves your machine.
 
 ---
 
 ## Resources
 
-- 📖 [Documentation](https://monoes.github.io/monomind/)
+- 📖 [Full Documentation](https://monoes.github.io/monomind/)
+- 🏢 [Autonomous Orgs](https://monoes.github.io/monomind/#orgs)
+- ⚡ [Mastermind Reference](https://monoes.github.io/monomind/#mastermind)
+- 📋 [All Slash Commands](https://monoes.github.io/monomind/#slash)
 - 🐛 [Issues](https://github.com/monoes/monomind/issues)
 - 💬 [Discussions](https://github.com/monoes/monomind/discussions)
 - 📦 [Changelog v1.11](https://github.com/monoes/monomind/blob/main/CHANGELOG-v1.11.md)
@@ -241,6 +398,6 @@ Monomind coordinates. Claude Code creates. You ship.
 ---
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/monoes/monomind/main/assets/mascot.png" alt="Monomind" width="80" /><br/>
+  <img src="https://raw.githubusercontent.com/monoes/monomind/main/assets/mascot.png" alt="Monomind" width="72" /><br/>
   <sub>Built with ♥ by <a href="https://github.com/monoes">monoes</a> · MIT License</sub>
 </p>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.11.12",
+  "version": "1.11.14",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",
@@ -56,7 +56,7 @@
   },
   "dependencies": {
     "semver": "^7.6.0",
-    "@monoes/monograph": "^1.1.0"
+    "@monoes/monograph": "^1.2.0"
   },
   "overrides": {
     "hono": ">=4.11.4"