@monoes/monomindcli 2.16.4 → 2.16.5

package/.claude/commands/monoswarm/monoswarm.md

@@ -25,19 +25,19 @@ Then describe what you want to accomplish:
 
 ```bash
 # Initialize a swarm
-npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
+npx monomind monoswarm init --topology hierarchical --max-agents 8 --strategy specialized
 
 # Start a swarm with an objective
-npx monomind swarm start "Build REST API" --strategy development --parallel
+npx monomind monoswarm start "Build REST API" --strategy development --parallel
 
 # Check swarm status
-npx monomind swarm status
+npx monomind monoswarm status
 
 # Stop the swarm
-npx monomind swarm stop
+npx monomind monoswarm stop
 
 # Scale agents
-npx monomind swarm scale <swarm-id> --agents 12
+npx monomind monoswarm scale <swarm-id> --agents 12
 ```
 
 ## MCP Tools

package/.claude/commands/monoswarm/optimization.md

@@ -39,8 +39,8 @@ mcp__monomind__coordination_orchestrate({
 
 ```bash
 # CLI equivalent
-npx monomind swarm init --topology mesh --max-agents 6
-npx monomind swarm start "optimize performance" --strategy optimization --parallel
+npx monomind monoswarm init --topology mesh --max-agents 6
+npx monomind monoswarm start "optimize performance" --strategy optimization --parallel
 ```
 
 ## Agent Roles

package/.claude/commands/monoswarm/research.md

@@ -38,8 +38,8 @@ mcp__monomind__coordination_orchestrate({
 
 ```bash
 # CLI equivalent
-npx monomind swarm init --topology mesh --max-agents 6
-npx monomind swarm start "research topic X" --strategy research --parallel
+npx monomind monoswarm init --topology mesh --max-agents 6
+npx monomind monoswarm start "research topic X" --strategy research --parallel
 ```
 
 ## Agent Roles

package/.claude/commands/monoswarm/spawn.md

@@ -1,5 +1,6 @@
 ---
 name: monoswarm:spawn
+description: Write worker agent records into the agent store and register their ids on the monoswarm state file (combines `agent_spawn` + `monoswarm_join`).
 ---
 
 # monoswarm spawn

package/.claude/commands/monoswarm/status.md

@@ -1,5 +1,6 @@
 ---
 name: monoswarm:status
+description: "Show monoswarm status: agent roster, task metrics, and (if voting is in use) pending/history proposals."
 ---
 
 # monoswarm status
@@ -8,7 +9,7 @@ Show monoswarm status: agent roster, task metrics, and (if voting is in
 use) pending/history proposals.
 
 ```bash
-npx monomind@latest swarm status
+npx monomind@latest monoswarm status
 ```
 
 Or, for the fuller vote/consensus view, as an MCP tool call:

package/.claude/commands/monoswarm/stop.md

@@ -1,5 +1,6 @@
 ---
 name: monoswarm:stop
+description: Clear monoswarm workers from the shared agent store and reset run state.
 ---
 
 # monoswarm shutdown
@@ -7,7 +8,7 @@ name: monoswarm:stop
 Clear monoswarm workers from the shared agent store and reset run state.
 
 ```bash
-npx monomind@latest swarm stop
+npx monomind@latest monoswarm stop
 ```
 
 Or, as a direct MCP tool call (needed to also clear vote/consensus state):

package/.claude/commands/monoswarm/testing.md

@@ -38,8 +38,8 @@ mcp__monomind__coordination_orchestrate({
 
 ```bash
 # CLI equivalent
-npx monomind swarm init --topology star --max-agents 7
-npx monomind swarm start "test application" --strategy testing --parallel
+npx monomind monoswarm init --topology star --max-agents 7
+npx monomind monoswarm start "test application" --strategy testing --parallel
 ```
 
 ## Agent Roles

package/.claude/commands/pair/README.md

@@ -47,10 +47,10 @@ Task({
 })
 ```
 
-Or use a specific specialist:
-- `superpowers:test-driven-development` — TDD-focused pairing
-- `superpowers:systematic-debugging` — debugging sessions
-- `superpowers:receiving-code-review` — code review sessions
+Or load a skill that fits the session:
+- `mastermind-debug` — debugging sessions (failing test first, then fix)
+- `mastermind-review` — code review sessions
+- `mastermind-receive-review` — working through review feedback
 
 ## Hooks Integration
 
@@ -61,7 +61,7 @@ Use hooks to track pair session quality:
 npx monomind hooks pre-task -d "Pair programming: implement JWT auth"
 
 # After session, record outcome
-npx monomind hooks post-task --task-id <id> --success true --quality 0.95
+npx monomind hooks post-task --task-id <id> --success true
 ```
 
 ## Files
@@ -72,8 +72,7 @@ npx monomind hooks post-task --task-id <id> --success true --quality 0.95
 
 ## See Also
 
-- `superpowers:pair-programming` — structured pair programming skill
-- `superpowers:test-driven-development` — TDD workflow
-- `superpowers:systematic-debugging` — debugging workflow
-- `superpowers:requesting-code-review` — code review workflow
+- `pair-programming` skill — structured pair programming workflow
+- `mastermind-debug` skill — debugging workflow, failing test first
+- `mastermind-review` skill — code review workflow
 - `hooks pre-task` — register task start and get recommendations

package/.claude/commands/pair/examples.md

@@ -35,7 +35,7 @@ End:
 > "Summarize what we built and what's still needed before this is production-ready."
 
 ```bash
-npx monomind hooks post-task --task-id <id> --success true --quality 0.9
+npx monomind hooks post-task --task-id <id> --success true
 ```
 
 ---
@@ -152,6 +152,5 @@ At end:
 
 - [modes.md](./modes.md) — choosing the right mode
 - [session.md](./session.md) — session lifecycle and tracking
-- `superpowers:pair-programming` — structured pair programming skill
-- `superpowers:test-driven-development` — full TDD workflow
-- `superpowers:systematic-debugging` — debugging methodology
+- The `pair-programming` skill — structured pair programming workflow
+- The `mastermind-debug` skill — systematic debugging, failing test first

package/.claude/commands/pair/session.md

@@ -79,7 +79,7 @@ Record outcomes for future sessions:
 
 ```bash
 # Record task completion
-npx monomind hooks post-task --task-id <id> --success true --quality 0.9
+npx monomind hooks post-task --task-id <id> --success true
 
 # Store any patterns worth remembering
 npx monomind memory store \

package/.claude/commands/workflows/README.md

@@ -1,64 +1,69 @@
 ---
 name: workflows:README
-description: Workflow skills index — run, validate, and manage multi-agent workflows using real CLI subcommands and MCP tools
+description: Workflow skills index — run multi-agent workflows with the Task tool in Claude Code, or as a persistent org with monomind org; there is no workflow CLI command
 ---
 
 # Workflows Skills
 
-Skills for running and managing multi-agent workflows in Monomind.
+Skills for running multi-stage, multi-agent workflows in Monomind.
+
+The CLI has no `workflow` command. A workflow runs in one of two real ways:
+
+1. **In the conversation** — Claude Code runs the stages itself, spawning Task-tool agents (all independent agents in one message) and tracking steps with TodoWrite. Best for one-off work.
+2. **As an org** — `monomind org` runs a set of roles as a controlled daemon from a JSON config in `.monomind/orgs/<name>.json`. Best for repeatable or scheduled workflows.
 
 ## Available Skills
 
-- [workflow-execute](./workflow-execute.md) — Run workflows using built-in templates
-- [workflow-create](./workflow-create.md) — Create and save custom workflow templates
-- [workflow-export](./workflow-export.md) — Manage and list workflow templates
-- [development](./development.md) — Development workflow coordination pattern
-- [research](./research.md) — Research workflow coordination pattern
+- [workflow-execute](./workflow-execute.md) — Run a workflow (Task tool or `org run`)
+- [workflow-create](./workflow-create.md) — Create a reusable workflow as an org config
+- [workflow-export](./workflow-export.md) — List, inspect, and export workflows (org configs, Mermaid flow)
+- [development](./development.md) — Development workflow pattern
+- [research](./research.md) — Research workflow pattern
 
-## Real CLI Subcommands
+## Real CLI Commands
 
 ```bash
-# Run a workflow from a template
-npx monomind workflow run -t development --task "Build auth system"
-npx monomind workflow run -t research --task "Analyze performance"
-npx monomind workflow run -f ./workflow.yaml
+# Scaffold an org from a starter template
+npx monomind org create api-dev --template dev-team --goal "Build REST API with auth"
 
-# Validate a workflow file
-npx monomind workflow validate -f ./workflow.yaml --strict
+# Validate, preview, run
+npx monomind org validate api-dev
+npx monomind org run api-dev --dry-run
+npx monomind org run api-dev --task "Add refresh-token rotation"
 
-# List running/completed workflows
-npx monomind workflow list --status all --limit 10
+# Observe and control
+npx monomind org list
+npx monomind org status api-dev
+npx monomind org logs api-dev --follow
+npx monomind org stop api-dev
+npx monomind org report api-dev
 
-# Check workflow status
-npx monomind workflow status <workflowId>
+# Portable step-by-step procedures (plan, execute, review, debug, research, ...)
+npx monomind mastermind --list
+npx monomind mastermind run plan --print
 
-# Stop a running workflow
-npx monomind workflow stop <workflowId>
-
-# Manage templates
-npx monomind workflow template list
-npx monomind workflow template show development
-npx monomind workflow template create --name "my-workflow"
+# Staged task graph with dependencies
+npx monomind task create -t implementation -d "Implement auth API"
+npx monomind task create -t testing -d "Test auth API" --dependencies <task-id>
 ```
 
-## Built-in Templates
+## Org Starter Templates
 
-| Template | Stages | Agents |
-|----------|--------|--------|
-| `development` | Planning → Implementation → Testing → Review → Integration | coder, tester, reviewer |
-| `research` | Discovery → Analysis → Synthesis → Documentation | researcher, analyst |
-| `testing` | Unit → Integration → E2E → Performance | tester, coder |
-| `security-audit` | Threat Model → Static → Dynamic → Report | security-architect, auditor |
-| `code-review` | Initial → Security → Quality → Feedback | reviewer, auditor, analyst |
-| `refactoring` | Analysis → Planning → Refactor → Validation | architect, coder, reviewer |
-| `custom` | Define your own stages | configurable |
+| Template | Roles |
+|----------|-------|
+| `dev-team` | tech-lead, developer, code-reviewer, qa |
+| `research-pod` | lead-analyst, researcher, fact-checker |
+| `content-team` | editor-in-chief, writer, reviewer |
+| `kg-extraction` | kg-lead, entity-extractor, relationship-resolver, ontology-validator |
+| `advisor-orchestrator` | advisor, worker-1, worker-2 |
 
 ## MCP Tools
 
+There are no workflow MCP tools. Related real tools:
+
 ```javascript
-mcp__monomind__workflow_run({ template: "development", task: "Build feature", options: { parallel: true } })
-mcp__monomind__workflow_list({ status: "all", limit: 10 })
-mcp__monomind__workflow_status({ workflowId: "wf-123" })
-mcp__monomind__workflow_create({})
-mcp__monomind__workflow_template({})
+mcp__monomind__monoswarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+mcp__monomind__task_create({ /* see task_create schema */ })
+mcp__monomind__memory_pattern-store({ pattern: "JWT auth + Zod validation worked well", type: "workflow" })
+mcp__monomind__memory_pattern-search({ query: "auth workflow", topK: 5 })
 ```

package/.claude/commands/workflows/development.md

@@ -1,11 +1,11 @@
 ---
 name: workflows:development
-description: Development workflow coordination pattern — hierarchical swarm for structured implementation tasks using real MCP tools and npx monomind workflow run -t development
+description: Development workflow pattern — plan, implement, test, and review with Task-tool agents in Claude Code, or as a dev-team org via npx monomind org
 ---
 
 # Development Workflow Coordination
 
-Structure multi-agent development tasks using the built-in development template for maximum efficiency.
+Structure multi-agent development work. The CLI has no `workflow` command; run the stages with the Task tool, or as a `dev-team` org.
 
 ## How to Invoke
 
@@ -15,72 +15,59 @@ Skill("workflows:development")
 
 ---
 
-## Quick Start
+## Stages
 
-```bash
-# Run the built-in development workflow
-npx monomind workflow run -t development --task "Build REST API with auth"
+1. **Planning** — requirements, architecture decisions (`planner`)
+2. **Implementation** — code (`coder`)
+3. **Testing** — unit and integration tests (`tester`, in parallel with implementation where the contract is known)
+4. **Review** — quality and security (`reviewer`, `Security Engineer`)
+5. **Integration** — wire the pieces together, run the full build and test suite
 
-# Preview stages without executing
-npx monomind workflow run -t development --dry-run
+## In the Conversation (Task Tool)
 
-# Show template details (stages, agents, duration)
-npx monomind workflow template show development
-```
+```javascript
+// Stage 1
+Task({ subagent_type: "planner", prompt: "Plan a REST API with JWT auth: endpoints, data model, files to touch." })
 
-## Stages
+// Stages 2-3, one message
+Task({ subagent_type: "coder",  prompt: "Implement the plan in src/api/ ..." })
+Task({ subagent_type: "tester", prompt: "Write tests for the endpoints defined in the plan ..." })
 
-The `development` template runs these stages:
-1. **Planning** — Requirements, architecture decisions
-2. **Implementation** — Code writing
-3. **Testing** — Unit and integration tests
-4. **Review** — Code quality and security check
-5. **Integration** — Connect all pieces
+// Stage 4, one message
+Task({ subagent_type: "reviewer",          prompt: "Review the diff for correctness and maintainability." })
+Task({ subagent_type: "Security Engineer", prompt: "Review the auth code for vulnerabilities." })
+```
 
-Agents: `coder`, `tester`, `reviewer` (in parallel where possible)
+Optional coordination and tracking:
 
-## MCP Coordination
+```bash
+npx monomind monoswarm init --topology hierarchical --max-agents 8
+npx monomind hooks pre-task --description "Build REST API with auth" --task-id rest-api
+npx monomind hooks post-task --task-id rest-api --success true
+npx monomind memory store --key "dev-pattern-rest-api" \
+  --value "JWT auth + Express + Zod validation worked well" --namespace patterns
+```
 
-For custom development coordination via MCP:
+## As an Org
 
-```javascript
-// Initialize hierarchical swarm for development
-mcp__monomind__swarm_init({
-  topology: "hierarchical",
-  maxAgents: 8,
-  strategy: "specialized"
-})
-
-// Run the development workflow
-mcp__monomind__workflow_run({
-  template: "development",
-  task: "Build REST API with authentication",
-  options: { parallel: true, maxAgents: 6 }
-})
-
-// Check progress
-mcp__monomind__workflow_status({ workflowId: "wf-123" })
-
-// Store findings for future sessions
-mcp__monomind__memory_pattern-store({
-  key: "dev-pattern-rest-api",
-  value: "JWT auth + Express + Zod validation worked well",
-  namespace: "patterns"
-})
+```bash
+npx monomind org create rest-api --template dev-team --goal "Build REST API with auth"
+npx monomind org run rest-api --dry-run
+npx monomind org run rest-api
+npx monomind org report rest-api
 ```
 
-## What Claude Code Actually Does
+The `dev-team` template has tech-lead, developer, code-reviewer, and qa roles.
 
-Claude Code handles all execution via native tools:
-1. **Read/Write/Edit** tools — create and modify files
-2. **Bash** tool — run tests, builds, type checks
-3. **TodoWrite** tool — track implementation steps
-4. **Task** tool — spawn parallel agent workers
+## What Claude Code Actually Does
 
-The workflow template defines the coordination strategy; Claude Code does the actual work.
+1. **Read/Write/Edit** — create and modify files
+2. **Bash** — run tests, builds, type checks
+3. **TodoWrite** — track stages
+4. **Task** — spawn parallel agents
 
 ## Related Skills
 
-- `workflows:workflow-execute` — Full workflow run reference
-- `swarm:development` — Direct swarm-based development coordination
-- `swarm:swarm-strategies` — Strategy selection guide
+- `workflows:workflow-execute` — Running workflows
+- `monoswarm:development` — Monoswarm-based development coordination
+- `mastermind-plan` / `mastermind-execute` — Plan, then execute step by step

package/.claude/commands/workflows/research.md

@@ -1,11 +1,11 @@
 ---
 name: workflows:research
-description: Research workflow coordination pattern — mesh swarm for comprehensive exploration using real MCP tools and npx monomind workflow run -t research
+description: Research workflow pattern — parallel researcher agents via the Task tool with findings kept in memory, or a research-pod org via npx monomind org
 ---
 
 # Research Workflow Coordination
 
-Coordinate multi-agent research activities for comprehensive, systematic exploration.
+Coordinate multi-agent research. The CLI has no `workflow` command; run the stages with the Task tool, or as a `research-pod` org.
 
 ## How to Invoke
 
@@ -15,75 +15,59 @@ Skill("workflows:research")
 
 ---
 
-## Quick Start
+## Stages
 
-```bash
-# Run the built-in research workflow
-npx monomind workflow run -t research --task "Analyze modern web framework performance"
+1. **Discovery** — identify sources, gather raw information
+2. **Analysis** — evaluate and compare findings
+3. **Synthesis** — combine into conclusions
+4. **Documentation** — write up findings
 
-# Preview stages without executing
-npx monomind workflow run -t research --dry-run
+## In the Conversation (Task Tool)
 
-# Show template details
-npx monomind workflow template show research
+Search past research first:
+
+```bash
+npx monomind memory search --query "web framework performance" --namespace research
 ```
 
-## Stages
+Spawn one researcher per angle, in one message:
+
+```javascript
+Task({ subagent_type: "researcher", prompt: "Benchmarks and SSR performance of Next.js vs Astro vs SvelteKit (2026 sources)." })
+Task({ subagent_type: "researcher", prompt: "Bundle size and hydration cost comparisons for the same frameworks." })
+Task({ subagent_type: "researcher", prompt: "Production case studies and migration reports for the same frameworks." })
+```
 
-The `research` template runs these stages:
-1. **Discovery** — Identify sources, gather raw information
-2. **Analysis** — Evaluate and compare findings
-3. **Synthesis** — Combine into coherent conclusions
-4. **Documentation** — Write up findings
+Synthesize the results in the conversation, then store the conclusion:
 
-Agents: `researcher`, `analyst` (mesh topology for broad coverage)
+```bash
+npx monomind memory store --key "research-web-frameworks-2026" \
+  --value "Next.js leads for SSR; Astro for static; Svelte for runtime performance" \
+  --namespace research
+```
 
-## MCP Coordination
+Optional: record a mesh topology for the roster with `npx monomind monoswarm init --topology mesh --max-agents 5`.
 
-For custom research coordination via MCP:
+## As an Org
 
-```javascript
-// Initialize mesh swarm for broad exploration
-mcp__monomind__swarm_init({
-  topology: "mesh",
-  maxAgents: 5,
-  strategy: "balanced"
-})
-
-// Run the research workflow
-mcp__monomind__workflow_run({
-  template: "research",
-  task: "Research modern web frameworks performance",
-  options: { parallel: true, maxAgents: 4 }
-})
-
-// Store research findings in memory
-mcp__monomind__memory_pattern-store({
-  key: "research-web-frameworks-2026",
-  value: "React/Next.js leads for SSR; Astro for static; Svelte for performance",
-  namespace: "research"
-})
-
-// Search past research before starting
-mcp__monomind__memory_pattern-search({
-  query: "web framework performance analysis",
-  namespace: "research",
-  limit: 5
-})
+```bash
+npx monomind org create fw-brief --template research-pod --goal "Brief on web framework performance"
+npx monomind org run fw-brief
+npx monomind org report fw-brief
 ```
 
-## What Claude Code Actually Does
+The `research-pod` template has lead-analyst, researcher, and fact-checker roles.
 
-1. **WebSearch** tool — finds relevant resources
-2. **Read** tool — analyzes documentation and code
-3. **Task** tool — spawns parallel research agents for different angles
-4. Synthesizes findings in the conversation
-5. Stores insights in memory for future sessions
+## What Claude Code Actually Does
 
-The workflow template coordinates the research strategy; Claude Code does the actual searching and reading.
+1. **WebSearch / WebFetch** — find and read sources
+2. **Read** — analyze documentation and code
+3. **Task** — parallel research agents for different angles
+4. Synthesizes findings and stores them in memory
 
 ## Related Skills
 
-- `workflows:workflow-execute` — Full workflow run reference
-- `swarm:research` — Direct swarm-based research coordination
-- `memory:memory-search` — Search past research findings
+- `workflows:workflow-execute` — Running workflows
+- `monoswarm:research` — Monoswarm-based research coordination
+- `mastermind-research` — Structured research protocol
+- `memory:memory-search` — Search past findings