monomind 1.10.1 → 1.10.2

package/.claude/commands/monomind/review.md

@@ -0,0 +1,317 @@
+---
+name: monomind:review
+description: "Monomind — Multi-agent iterative review loop: runs Code Reviewer, Security Engineer, and domain specialists in parallel, auto-fixes findings each iteration, and captures human-in-loop items to a dated file."
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-arguments check below.
+
+Parse remaining `$ARGUMENTS` as `TOTAL_ITERATIONS` (integer, min 1, max 10).
+
+If `$ARGUMENTS` is empty, not a positive integer, or greater than 10, output this and STOP:
+
+> **Usage:** `/monomind:review <iterations>`
+>
+> Examples:
+> - `/monomind:review 1` — single review pass
+> - `/monomind:review 3` — three fix-and-re-review cycles
+>
+> Runs parallel review agents each iteration, auto-fixes what can be fixed, and saves items requiring human judgment to `humaninloopreview-YYYY-MM-DD.md`.
+
+Do NOT proceed further if no valid number was provided.
+
+---
+
+## Terminology
+
+- **Finding**: An issue reported by any review agent.
+- **Auto-fixable**: Claude can apply the fix without ambiguity and without changing intended behavior.
+- **Human-in-loop (HIL)**: Requires a product/design/architecture decision, a credential, a policy choice, or something Claude cannot safely assume. These are written to the HIL file and skipped.
+- **HIL file**: `humaninloopreview-<YYYY-MM-DD>.md` in the project root. Appended each loop; never overwritten.
+
+---
+
+## Step 0: Setup
+
+Parse `$ARGUMENTS` as `TOTAL_ITERATIONS` (integer, min 1, max 10).
+
+Collect the following in parallel:
+
+1. **Git context**: Run the following to get recently changed files. Store result as `CHANGED_FILES`.
+   ```bash
+   CHANGED_FILES=$(git diff --name-only HEAD~1 HEAD 2>/dev/null)
+   [ -z "$CHANGED_FILES" ] && CHANGED_FILES=$(git ls-files -m 2>/dev/null)
+   [ -z "$CHANGED_FILES" ] && CHANGED_FILES=$(git diff --name-only HEAD~5 HEAD 2>/dev/null)
+   ```
+2. **Repo structure**: Run `git ls-files | head -80` to get a representative file list. Store as `FILE_LIST`.
+3. **Branch info**: Run `git log --oneline -5` to get recent commit context. Store as `RECENT_COMMITS`.
+4. **Stack detection**: Run `ls package.json pyproject.toml go.mod Cargo.toml 2>/dev/null; find . -maxdepth 3 \( -name "*.swift" -o -name "*.kt" \) | head -3` to detect language/framework. Store detected stacks as `STACK`.
+5. **HIL file path**: Compute `HIL_FILE=humaninloopreview-$(date +%Y-%m-%d).md` in the project root.
+
+Initialize tracking state:
+```
+ITERATION = 1
+ITERATIONS_RUN = 0       # how many iterations actually executed (for final report)
+ALL_FIXED = []           # auto-fixed items (across all iterations)
+ALL_HIL = []             # human-in-loop items (across all iterations)
+HIL_COUNT = 0            # global counter for HIL-N labels
+PENDING_FIXED = []       # staging: auto-fixed this batch, not yet verified
+ITERATION_FIXED_FILES = []  # file paths edited this iteration
+```
+
+---
+
+## Step 1: Select Review Agents for This Stack
+
+Based on `STACK`, determine which specialist agents to run beyond the always-on core set.
+
+**Always run (every stack):**
+- `Code Reviewer` — correctness, maintainability, performance, naming, dead code
+- `Security Engineer` — injection, auth gaps, secrets exposure, CVE-prone patterns, OWASP Top 10
+- `Reality Checker` — evidence-based assessment: does the code actually do what it claims?
+
+**Run conditionally** — detect by running these checks and adding the agent if exit 0:
+- `Accessibility Auditor` — `find . -maxdepth 5 \( -name "*.html" -o -name "*.jsx" -o -name "*.tsx" \) -not -path "*/node_modules/*" | head -1 | grep -q .`
+- `API Tester` — `find . -maxdepth 5 \( -name "*.route.*" -o -name "openapi.yml" -o -name "openapi.json" -o -name "swagger.*" \) -not -path "*/node_modules/*" | head -1 | grep -q . || grep -rqEl "express\(|fastify|hono|koa|router\." --include="*.ts" --include="*.js" . 2>/dev/null`
+- `Database Optimizer` — `find . -maxdepth 5 \( -name "*.sql" -o -name "*migration*" -o -name "*schema*" \) -not -path "*/node_modules/*" | head -1 | grep -q . || grep -rqEl "prisma|typeorm|sequelize|drizzle|knex" --include="*.ts" --include="*.js" . 2>/dev/null`
+- `SRE` — `find . -maxdepth 3 \( -name "Dockerfile" -o -name "docker-compose*" -o -name "*.yml" -path "*/.github/workflows/*" \) | head -1 | grep -q .`
+- `Mobile App Builder` — `find . -maxdepth 3 \( -name "*.swift" -o -name "*.kt" \) | head -1 | grep -q . || grep -q "react-native" package.json 2>/dev/null`
+
+Store the selected set as `ACTIVE_REVIEWERS`.
+
+---
+
+## Loop: Run `TOTAL_ITERATIONS` times
+
+For each iteration, first reset per-iteration state:
+```
+PENDING_FIXED = []
+ITERATION_FIXED_FILES = []
+```
+
+---
+
+### Step 2: Run All Reviewers in Parallel
+
+Spawn one agent per reviewer in `ACTIVE_REVIEWERS` using the `Task` tool — all in a **single message** so they run concurrently.
+
+Each agent receives:
+- `CHANGED_FILES`, `FILE_LIST`, `RECENT_COMMITS`, `STACK`
+- The list of findings already auto-fixed in prior iterations (so they don't re-report them)
+- The list of HIL items already deferred (same reason)
+- Their specific review focus (below)
+
+#### Agent Instructions by Role
+
+All agent prompts share this finding schema. `hil_reason` and `context` are only required when `auto_fixable: false`:
+```
+{
+  file, line,
+  severity: critical|high|medium|low,
+  category: "...",
+  description,
+  suggested_fix,
+  auto_fixable: true|false,
+  hil_reason?: "only if auto_fixable=false — why Claude cannot safely apply this",
+  context?: "only if auto_fixable=false — 2-4 sentences: what the code does, why this is a problem, what the risk is"
+}
+```
+
+**Code Reviewer prompt:**
+> Review the codebase for: logic errors, off-by-one bugs, null/undefined handling, dead code, overly complex functions (>50 lines or >3 nesting levels), naming inconsistencies, missing error propagation, and performance anti-patterns (N+1, blocking I/O, unnecessary allocations). Focus on `CHANGED_FILES` first, then related files. Return findings using the shared schema above.
+
+**Security Engineer prompt:**
+> Audit for: hardcoded secrets or API keys, SQL/command/path injection, missing input validation at system boundaries, insecure deserialization, broken auth/authz, sensitive data in logs, unpatched dependency versions with known CVEs, missing rate limiting on public endpoints, and CORS misconfigurations. Categories: injection|secrets|auth|deps|logging|config. Return findings using the shared schema above.
+
+**Reality Checker prompt:**
+> Check: does each function do what its name/docs claim? Are there missing test assertions? Are there commented-out code blocks, TODO/FIXME/HACK markers, or debug statements left in? Are there import cycles? Are env vars assumed to exist without validation? Categories: correctness|tests|debt|env. Return findings using the shared schema above.
+
+**Accessibility Auditor prompt (if applicable):**
+> Check: missing alt text, non-semantic HTML, keyboard-inaccessible interactive elements, insufficient color contrast (< 4.5:1 for text), missing ARIA labels, focus trap issues, and missing skip navigation. Category: a11y. Return findings using the shared schema above.
+
+**API Tester prompt (if applicable):**
+> Check: endpoints missing auth middleware, routes with no input validation, missing HTTP status codes on error paths, inconsistent response shapes, pagination not implemented where expected, and missing rate-limit headers. Category: api. Return findings using the shared schema above.
+
+**Database Optimizer prompt (if applicable):**
+> Check: missing indexes on foreign keys and frequently-queried columns, N+1 query patterns in ORM code, unparameterized queries, missing transactions around multi-step writes, and schema column type mismatches. Category: database. Return findings using the shared schema above.
+
+**SRE prompt (if applicable):**
+> Check: Docker images without pinned versions, CI jobs with no timeout, missing health check endpoints, hardcoded environment assumptions (localhost, fixed ports), missing retry logic on external calls, and secrets in CI config files. Categories: reliability|infra. Return findings using the shared schema above.
+
+**Mobile App Builder prompt (if applicable):**
+> Check: missing permission explanations, sensitive data stored in plain UserDefaults/SharedPreferences, missing loading/error states, hard-coded URLs, deprecated API usage, and missing offline/degraded-mode handling. Category: mobile. Return findings using the shared schema above.
+
+---
+
+### Step 3: Merge and Deduplicate Findings
+
+Collect all agent outputs. As you collect each agent's findings, annotate each finding with `reporter: <agent role name>` (e.g., `"Code Reviewer"`, `"Security Engineer"`, `"Reality Checker"`). Merge into a single `ITERATION_FINDINGS` list. Deduplicate by `(file, category, description[:60])` — keep highest severity when duplicates exist. Do NOT deduplicate by line number, as applied fixes shift line numbers across iterations. Exclude anything already in `ALL_FIXED` or `ALL_HIL` by matching on `(file, description[:60])`.
+
+Sort by severity: critical → high → medium → low.
+
+---
+
+### Step 4: Classify and Act
+
+For each finding in `ITERATION_FINDINGS`:
+
+**If `auto_fixable: true`:**
+- Apply the fix using `Edit` (or `Write` for new files). Add the file path to `ITERATION_FIXED_FILES` list. Add the finding to a staging list `PENDING_FIXED`.
+
+**If `auto_fixable: false` (HIL):**
+- Add to `ALL_HIL`. Do NOT attempt to fix.
+
+After processing all findings, if `PENDING_FIXED` is empty, skip verification and proceed to Step 5. Otherwise, run verification **once** for the whole batch. Run only commands appropriate for `STACK`:
+
+**Node.js / TypeScript:**
+```bash
+npm run --if-present lint 2>&1 | tail -5
+npm run --if-present typecheck 2>&1 | tail -5
+npm run --if-present test 2>&1 | tail -10
+```
+
+**Python** (if `pyproject.toml` or `*.py` detected):
+```bash
+ruff check . 2>&1 | tail -5
+python -m pytest --tb=short -q 2>&1 | tail -10
+```
+
+**Go** (if `go.mod` detected):
+```bash
+go vet ./... 2>&1 | tail -5
+go test ./... 2>&1 | tail -10
+```
+
+**Rust** (if `Cargo.toml` detected):
+```bash
+cargo check 2>&1 | tail -5
+cargo test 2>&1 | tail -10
+```
+- If all checks pass: move all `PENDING_FIXED` entries into `ALL_FIXED`.
+- If any check fails: run `git restore` on each file in `ITERATION_FIXED_FILES` to undo all changes, move all `PENDING_FIXED` entries to `ALL_HIL` with `hil_reason: "batch auto-fix caused verification failure — apply individually"`. Print the error output.
+
+---
+
+### Step 5: Commit Fixes for This Iteration
+
+If `ALL_FIXED` gained any new entries this iteration:
+
+Stage only the files that were actually edited (tracked from `ITERATION_FIXED_FILES` collected in Step 4):
+```bash
+git add <space-separated list of ITERATION_FIXED_FILES paths>
+```
+
+Then commit with each fixed item on its own line in the body:
+```bash
+git commit -m "fix(review): iteration <ITERATION> — <count> findings fixed by monomind:review
+
+<file>:<line> — <description>
+<file>:<line> — <description>
+
+Co-Authored-By: nokhodian <nokhodian@gmail.com>"
+```
+
+---
+
+### Step 6: Write HIL Items to File
+
+If any new HIL items were added this iteration, **append** to `HIL_FILE`. For each new HIL item, increment `HIL_COUNT` by 1 and use it as the label number:
+
+```markdown
+## Review Iteration <ITERATION> — <YYYY-MM-DD HH:MM>
+
+<!-- One block per HIL finding; HIL_COUNT increments globally across all iterations -->
+### HIL-<HIL_COUNT>: <description> [`<severity>`]
+
+**File:** `<file>:<line>`
+**Category:** <category>
+**Reported by:** <agent name>
+
+**Context:**
+<context from agent finding, or derive from description if context field absent>
+
+**Suggested fix:**
+<suggested_fix from agent, verbatim>
+
+**Why human decision needed:**
+<hil_reason>
+
+**Your options:**
+- [ ] Apply the suggested fix as-is
+- [ ] Apply a modified fix (describe below)
+- [ ] Defer — not a priority right now
+- [ ] Reject — not applicable for this project
+
+**Your response (fill in and save):**
+> 
+
+---
+```
+
+After writing, print:
+> `HIL_FILE` updated with <count> new items requiring human judgment.
+
+---
+
+### Step 7: Iteration Summary
+
+Increment `ITERATIONS_RUN` by 1. Then print a table:
+
+```
+### Iteration <ITERATION> / <TOTAL_ITERATIONS>
+
+| Reviewer            | Findings | Auto-Fixed | HIL |
+|---------------------|----------|------------|-----|
+| Code Reviewer       | N        | N          | N   |
+| Security Engineer   | N        | N          | N   |
+| Reality Checker     | N        | N          | N   |
+| ...                 | ...      | ...        | ... |
+| **Total**           | **N**    | **N**      | **N**|
+
+Severity breakdown: X critical, Y high, Z medium, W low
+```
+
+If zero findings remain after dedup and exclusions, print:
+> No new findings. Review complete.
+> Break out of the loop early.
+
+Increment `ITERATION`. Continue to next iteration.
+
+---
+
+## Step 8: Final Report
+
+After all iterations complete (or early exit), output:
+
+```markdown
+## monomind:review — Complete
+
+**Iterations run:** <ITERATIONS_RUN> / <TOTAL_ITERATIONS>
+**Reviewers active:** <list>
+
+### Auto-Fixed (<N> total)
+| File | Line | Severity | Category | Description |
+|------|------|----------|----------|-------------|
+| ... | ... | ... | ... | ... |
+
+### Human-in-Loop (<N> items)
+Saved to: `humaninloopreview-<date>.md`
+
+| # | File | Severity | Category | Why HIL |
+|---|------|----------|----------|---------|
+| 1 | ... | ... | ... | ... |
+
+### How to resolve HIL items
+1. Open `humaninloopreview-<date>.md`
+2. For each item, fill in **Your response** and check the option box
+3. Apply your chosen fixes manually, or run `/monomind:review 1` again after fixing to re-verify
+
+### Commits created
+<list of commit SHAs and messages from this session>
+```
+
+If `ALL_HIL` is empty, omit the HIL section and congratulate:
+> All findings were auto-fixed. No human decisions required.
+
+To repeat this command on a schedule, wrap it with `/monomind:repeat` or use `--repeat N` / `--tillend` directly.
+
+Follow the REPEAT POSTAMBLE from `_repeat.md`.

package/.claude/commands/monomind/specialagents.md

@@ -0,0 +1,125 @@
+---
+name: monomind-specialagents
+description: Activate a specialist agent persona — browse by category, activate by slug, or auto-select based on conversation context
+---
+
+Activate a specialist agent persona. Three modes:
+
+**Direct:** `/monomind:specialagents <slug>` — skip selection, activate immediately.
+
+**Interactive:** `/monomind:specialagents` — guided category → agent selection.
+
+**Auto:** `/monomind:specialagents auto` — LLM picks the best match from conversation context.
+
+---
+
+## Step 0 — Detect mode
+
+- If `$ARGUMENTS` is a non-empty string that is **not** `auto`:
+  - Treat it as a slug/name → jump to **Step 4: Activate**.
+- If `$ARGUMENTS` is `auto` or the user's message contains words like "auto", "automatically", "pick for me", "best agent", "suggest an agent":
+  - Jump to **Auto flow**.
+- Otherwise → **Interactive flow**.
+
+---
+
+## Interactive flow
+
+### Step 1 — List categories
+
+Run:
+```bash
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/hook-handler.cjs" list-extras 2>/dev/null
+```
+
+Parse the output. Extract the category names (lines like `=== ACADEMIC ===` → `academic`). Display them as a numbered list:
+
+```
+Available agent categories:
+1. academic
+2. design
+3. marketing
+4. paid-media
+5. product
+6. project-management
+7. sales
+8. specialized
+9. support
+
+Enter a number or category name:
+```
+
+Wait for the user to reply with their choice.
+
+### Step 2 — List agents in chosen category
+
+Map the user's reply to the lowercase category slug (e.g. "1" → `academic`, "Project Management" → `project-management`).
+
+Run:
+```bash
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/hook-handler.cjs" list-extras <category> 2>/dev/null
+```
+
+Parse the agents listed. Display them numbered:
+
+```
+Agents in <category>:
+1. slug-name — Short description
+2. ...
+
+Enter a number or agent slug:
+```
+
+Wait for the user to reply.
+
+### Step 3 — Confirm selection
+
+Echo back: `Activating agent: <slug>`
+
+Jump to **Step 4: Activate**.
+
+---
+
+## Auto flow
+
+### Auto Step 1 — Fetch all categories
+
+Run:
+```bash
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/hook-handler.cjs" list-extras 2>/dev/null
+```
+
+Read the full output. Based on the current conversation context (the user's request, task description, or recent messages), decide which **category** is the best fit. Do not ask the user — choose silently.
+
+### Auto Step 2 — Fetch agents in chosen category
+
+Run:
+```bash
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/hook-handler.cjs" list-extras <chosen-category> 2>/dev/null
+```
+
+Read the agent list. Based on the same conversation context, decide which **agent** is the best fit. Do not ask the user — choose silently.
+
+Announce your reasoning in one sentence:
+> "Auto-selected **<slug>** from **<category>** because <brief reason>."
+
+Jump to **Step 4: Activate**.
+
+---
+
+## Step 4 — Activate
+
+Run:
+```bash
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/router.cjs" --load-agent "<slug>" 2>/dev/null
+```
+
+Read the output. It will contain the agent's persona definition, capabilities, and behavioral rules.
+
+**Adopt the agent identity fully:**
+- Introduce yourself in the agent's voice: name, specialty, how you can help.
+- Apply all behavioral rules from the loaded persona for the rest of this conversation.
+- If the agent definition includes example openers or greetings, use one.
+- Remain in character unless the user explicitly asks to switch agents or end the session.
+
+If `router.cjs` returns an error or empty output, say: "Could not load agent `<slug>`. Run `/monomind:specialagents` to browse available agents."

package/.claude/commands/monomind/swarm.md

@@ -0,0 +1,161 @@
+---
+name: monomind-swarm
+description: Multi-agent swarm coordination — init, start, status, stop, scale, and coordinate agent teams
+---
+
+# Monomind Swarm Coordination
+
+Multi-agent swarm coordination with hierarchical topology, distributed memory, and load balancing.
+
+## Subcommands
+
+| Subcommand | Description |
+|---|---|
+| `init` | Initialize a new swarm (topology + strategy) |
+| `start` | Start swarm execution with an objective |
+| `status` | Show current swarm status and progress |
+| `stop` | Stop swarm execution |
+| `scale` | Scale swarm agent count up or down |
+| `coordinate` | Launch v1 15-agent hierarchical-mesh coordination |
+
+## init — Initialize a Swarm
+
+```bash
+# Default (hierarchical, 15 agents)
+npx monomind swarm init
+
+# Anti-drift configuration (recommended)
+npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
+
+# v1 15-agent hierarchical-mesh
+npx monomind swarm init --v1-mode
+npx monomind swarm init --topology hierarchical-mesh --max-agents 15 --strategy specialized
+```
+
+**Flags:**
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--topology` | `-t` | `hierarchical` | Swarm topology (see table below) |
+| `--max-agents` | `-m` | `15` | Maximum concurrent agents |
+| `--strategy` | `-s` | — | Coordination strategy |
+| `--auto-scale` | — | `true` | Enable automatic scaling |
+| `--v1-mode` | — | `false` | Enable v1 hierarchical-mesh with 15 agents |
+
+## Topologies
+
+| Topology | Use When |
+|---|---|
+| `hierarchical` | Feature dev, bug fixes — anti-drift, tight control |
+| `hierarchical-mesh` | Large teams 10-15 agents — v1 queen + peer communication |
+| `mesh` | Research, analysis — broad coverage |
+| `star` | Parallel testing, parallel maintenance |
+| `ring` | Sequential pipeline processing |
+| `hybrid` | Dynamic topology switching |
+
+## Strategies
+
+`specialized` (anti-drift, clear roles), `balanced`, `adaptive`, `development`, `research`, `testing`, `optimization`, `maintenance`, `analysis`
+
+## start — Start Swarm Execution
+
+```bash
+# Start a development swarm
+npx monomind swarm start -o "Build REST API with authentication" -s development
+
+# Parallel research swarm
+npx monomind swarm start -o "Analyze performance bottlenecks" -s research --parallel
+```
+
+**Flags:**
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--objective` | `-o` | — | Swarm objective/task (required) |
+| `--strategy` | `-s` | `development` | Execution strategy |
+| `--parallel` | `-p` | `true` | Enable parallel execution |
+| `--monitor` | — | `true` | Enable real-time monitoring |
+
+## status — Check Swarm Progress
+
+```bash
+# Overall status
+npx monomind swarm status
+
+# Status for a specific swarm ID
+npx monomind swarm status swarm-abc123
+```
+
+## stop — Stop a Swarm
+
+```bash
+# Graceful stop (saves state by default)
+npx monomind swarm stop swarm-abc123
+
+# Force immediate stop
+npx monomind swarm stop swarm-abc123 --force
+```
+
+**Flags:**
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--force` | `-f` | `false` | Force immediate stop |
+| `--save-state` | — | `true` | Save state for potential resume |
+
+## scale — Adjust Agent Count
+
+```bash
+# Scale to 12 agents
+npx monomind swarm scale swarm-abc123 --agents 12
+
+# Scale a specific agent type
+npx monomind swarm scale swarm-abc123 --agents 8 --type coder
+```
+
+## coordinate — v1 15-Agent Coordination
+
+```bash
+# Full v1 15-agent hierarchical mesh
+npx monomind swarm coordinate
+
+# Subset of agents
+npx monomind swarm coordinate --agents 8
+```
+
+Activates the v1 agent roster: Queen Coordinator, Security Architect, Security Auditor, Test Architect, Core Architect, Memory Specialist, Swarm Specialist, Integration Architect, Performance Engineer, CLI Developer, Hooks Developer, MCP Specialist, Project Coordinator, Documentation Lead, DevOps Engineer.
+
+## MCP Tools
+
+```javascript
+// Initialize swarm
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+
+// Check status
+mcp__monomind__swarm_status({})
+
+// Health check
+mcp__monomind__swarm_health({})
+
+// Shutdown swarm
+mcp__monomind__swarm_shutdown({})
+```
+
+## Agent Team Routing
+
+| Task Type | Agents | Topology |
+|---|---|---|
+| Bug Fix | coordinator, researcher, coder, tester | hierarchical |
+| Feature | coordinator, architect, coder, tester, reviewer | hierarchical |
+| Refactor | coordinator, architect, coder, reviewer | hierarchical |
+| Performance | coordinator, perf-engineer, coder | hierarchical |
+| Security | coordinator, security-architect, auditor | hierarchical |
+| Research | coordinator, researcher x4, analyst x2 | mesh |
+
+## See Also
+
+- `npx monomind agent spawn` — Spawn individual agents
+- `npx monomind hive-mind init` — Byzantine fault-tolerant consensus
+- `/mastermind` — Interactive swarm topology selection
+
+Documentation: https://github.com/nokhodian/monomind