monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/commands/mastermind/techport.md

@@ -0,0 +1,30 @@
+---
+name: mastermind-techport
+description: Tech Port — deep-analyzes a foreign project folder and recommends porting valuable features, patterns, or infrastructure into the current monomind base project.
+---
+
+**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-prompt check below.
+
+Parse `$ARGUMENTS` for:
+- First path-like token (starts with `/`, `./`, `../`, or `~`) → source_path
+- `--auto` flag → mode = auto (port immediately after analysis)
+- `--confirm` flag → mode = confirm (present plan, wait for approval before porting)
+- `--partial` flag → suggest partial/selective ports only (no full port option)
+- Remaining text after flags = focus_hint (optional: what kind of value to look for)
+
+If source_path is empty: ask "What is the path to the project you want to analyze?"
+
+Load brain context for the `techport` domain (follow `_protocol.md` Brain Load Procedure).
+
+Default mode: **confirm** (show analysis + port plan, wait before executing anything).
+
+> **Note for `--tillend` / `--repeat` loops:** This command defaults to `--confirm`, which presents a plan but doesn't execute it. In an unattended loop, this means each run will find items (findings = yes) but take no action (actions = no), so `TILLEND_EMPTY` never becomes true and the loop runs until the safety cap. Always add `--auto` when using this command in a loop:
+> ```
+> /mastermind:techport --tillend --auto /path/to/project
+> ```
+
+Invoke `Skill("mastermind:techport")` passing: source_path, focus_hint, mode.
+
+After skill returns: follow `_protocol.md` Brain Write Procedure for domain `techport`.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/packages/@monomind/cli/.claude/commands/mastermind/understand.md

@@ -0,0 +1,139 @@
+---
+name: mastermind:understand
+description: "Monomind — Run semantic enrichment on the current project's monograph knowledge graph. Uses the active Claude Code session for LLM work — no API key needed."
+---
+
+# /mastermind:understand — Semantic Enrichment
+
+Enriches the current project's monograph knowledge graph with summaries, architectural
+layers, and semantic relationships.
+
+**Designed to run inside Claude Code** — uses YOUR current session for LLM work via
+the Task tool. No `ANTHROPIC_API_KEY` required. The script handles layer detection
+and DB writes; you (Claude) handle per-file summarization.
+
+## Parse Arguments
+
+Parse `$ARGUMENTS` for these flags:
+
+- `--dir <path>`      — project directory (default: cwd)
+- `--db <path>`       — monograph.db path (default: `<dir>/.monomind/monograph.db`)
+- `--full`            — force full re-analysis
+- `--no-llm`          — heuristic-only mode (no per-file summaries)
+- `--layers-only`     — skip per-file analysis, only re-detect layers
+- `--max-files <N>`   — stop after N files (0 = all)
+- `--dry-run`         — show what would happen, don't write
+
+Bare path argument → `--dir`.
+
+---
+
+## Step 1: Locate project, DB, and script
+
+```bash
+DIR="${ARGUMENTS_dir:-$(pwd)}"
+DB="${ARGUMENTS_db:-$DIR/.monomind/monograph.db}"
+
+# Find understand-analyze.mjs (ships with monomind globally)
+GLOBAL_ROOT=$(npm root -g 2>/dev/null)
+SCRIPT="$GLOBAL_ROOT/monomind/packages/@monomind/cli/scripts/understand-analyze.mjs"
+[ ! -f "$SCRIPT" ] && SCRIPT="$GLOBAL_ROOT/@monoes/monomindcli/scripts/understand-analyze.mjs"
+```
+
+If `$DB` does not exist:
+> monograph.db not found at `$DB`. Build it first: `npx monomind monograph build`
+
+If `$SCRIPT` does not exist:
+> understand engine missing. Update: `npm install -g monomind@latest`
+
+In either case, STOP.
+
+---
+
+## Step 2: Run the script in heuristic mode (always — fast and deterministic)
+
+This step is non-negotiable. The script handles:
+- File node discovery from monograph.db
+- Heuristic layer detection from file paths
+- DB writes (community_id + properties)
+- graph.json emission to `.understand/knowledge-graph.json`
+- Auto-shadowing the DB to `/tmp` when it lives on a network FS
+
+```bash
+node "$SCRIPT" --dir "$DIR" --db "$DB" --no-llm
+```
+
+Wait for completion. Capture stdout. Note how many file nodes were found and how
+many layers were detected. Do NOT advise the user about API keys.
+
+---
+
+## Step 3: Per-file summarization (ONLY if `--no-llm` and `--layers-only` are both UNSET)
+
+This is where YOU (the current Claude session) do the LLM work. The script left
+behind a fresh `.understand/knowledge-graph.json` with placeholder summaries.
+
+1. Read `.understand/knowledge-graph.json`. For each node where `properties.fileSummary`
+   is empty or marked `[heuristic]`, do the following:
+   - Use the `Read` tool on `node.file_path` (relative to `$DIR`).
+   - Produce a JSON object: `{ id, fileSummary, tags, complexity, functionSummaries, classSummaries }`
+     where:
+     - `fileSummary`: 1-2 sentences explaining what the file does
+     - `tags`: array of 2-5 short tags
+     - `complexity`: "simple" | "moderate" | "complex"
+     - `functionSummaries`: top-5 functions → 1-sentence each
+     - `classSummaries`: classes → 1-sentence each
+2. Process files in batches of 5 for efficiency. Use `--max-files` to cap if set.
+3. Collect all analyses into an `analyses` array.
+
+If `$ARGUMENTS` includes `--no-llm` or `--layers-only`, SKIP this step entirely.
+
+---
+
+## Step 4: Write analyses back to the DB
+
+Pipe the collected analyses to a small re-import:
+
+```bash
+echo "$ANALYSES_JSON" | node "$SCRIPT" --dir "$DIR" --db "$DB" --import-analyses-stdin
+```
+
+(If your `analyses` array is empty, skip this step.)
+
+---
+
+## Step 5: Report
+
+```
+╔══════════════════════════════════════════════════╗
+║  /mastermind:understand — Enrichment Done           ║
+╠══════════════════════════════════════════════════╣
+║  DB:              .monomind/monograph.db          ║
+║  Files analyzed:  <N>                             ║
+║  LLM summaries:   <N> (via active session)        ║
+║  Layers:          <N>                             ║
+║  graph.json:      .understand/knowledge-graph.json║
+╚══════════════════════════════════════════════════╝
+```
+
+If LLM summaries = 0 (because `--no-llm` was set), say "heuristic-only mode — no per-file summaries written".
+
+Then:
+> Open the Monomind control panel and click **Monograph → GRAPH** to see layers.
+> Each color = one architectural layer (API, Service, Data, UI, etc.).
+>
+> Follow-ups:
+> - `/mastermind:understand --full` — re-run from scratch
+> - `/mastermind:understand --layers-only` — refresh only layers
+> - `/mastermind:understand --no-llm` — heuristic-only mode
+
+---
+
+## Error Handling
+
+- Do NOT prompt the user to set `ANTHROPIC_API_KEY`. LLM work happens in this session.
+- If the script exits non-zero: show stderr and suggest `npm install -g monomind@latest`.
+- If monograph.db has no file nodes: tell the user to run `npx monomind monograph build` first.
+- All errors are non-fatal — report and return cleanly.
+
+To re-run on a schedule: wrap with `/mastermind:repeat`.

package/packages/@monomind/cli/.claude/commands/mastermind/verify.md

@@ -0,0 +1,22 @@
+---
+name: mastermind-verify
+description: Run the verification gate before claiming any work is complete, fixed, or passing — evidence before assertions always.
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`.
+
+Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text = claim_or_task.
+
+Load brain context for the `verify` domain (follow `_protocol.md` Brain Load Procedure).
+
+If claim_or_task is empty: ask "What claim or task needs verification?"
+
+Default mode: **auto**.
+
+---
+
+Invoke `Skill("mastermind:verify")` passing: brain_context, claim_or_task, project_name, mode.
+
+After skill returns: follow `_protocol.md` Brain Write Procedure for domain `verify`.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/packages/@monomind/cli/.claude/commands/mastermind/worktree.md

@@ -0,0 +1,20 @@
+---
+name: mastermind-worktree
+description: Use when starting feature work that needs isolation from the current workspace or before executing implementation plans — sets up an isolated git worktree
+---
+
+**First — extract repeat flags:** Follow REPEAT PREAMBLE from `_repeat.md`.
+
+Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text.
+
+Load brain context (follow `_protocol.md` Brain Load Procedure).
+
+Default mode: **auto**.
+
+---
+
+Invoke `Skill("mastermind:worktree")` passing: brain_context, params, mode.
+
+After skill returns: follow `_protocol.md` Brain Write Procedure.
+
+Invoke `Skill("mastermind:_repeat")` now. Required — do not skip.

package/packages/@monomind/cli/.claude/commands/mastermind.md

@@ -0,0 +1,121 @@
+---
+name: mastermind
+description: Swarm & Hive-Mind architecture picker — presents all topologies, consensus protocols, and strategies, then gives one concrete recommendation for the current task
+---
+
+IMPORTANT: Do NOT dump all the reference content at once. Follow the two-phase flow below exactly.
+
+**If $ARGUMENTS is non-empty**, treat it as the user's task description and skip Phase 1 — go straight to Phase 2 with that description.
+
+---
+
+## Phase 1 — Present the picker and STOP
+
+Output this menu and WAIT for the user's reply before doing anything else:
+
+---
+
+**MASTERMIND — Swarm & Hive-Mind Picker**
+
+Describe your task and I'll recommend the right mode, or pick directly from the options below.
+
+### Swarm Topologies
+| # | Topology | Shape | Best for |
+|---|---|---|---|
+| **1** | `hierarchical` | One coordinator → all workers | Feature dev, bug fixes, most coding tasks |
+| **2** | `mesh` | Every agent ↔ every agent | Research, brainstorming, docs |
+| **3** | `hierarchical-mesh` | Queen + peer lanes | Large projects, 10–15 agents |
+| **4** | `ring` | Agent → next → next → loop | Pipelines: research→draft→edit→review |
+| **5** | `star` | Hub aggregates independent workers | Parallel analysis, test coverage |
+| **6** | `adaptive` | Starts hierarchical, self-reconfigures | Long-running or unknown workloads |
+
+### Hive-Mind Modes
+| # | Mode | Consensus | Best for |
+|---|---|---|---|
+| **7** | `hive-mind hierarchical-mesh` | `byzantine` | Security-critical, fault-tolerant (f < n/3) |
+| **8** | `hive-mind hierarchical` | `raft` | Refactors, rewrites — leader keeps authoritative state |
+| **9** | `hive-mind mesh` | `gossip` | Large agent counts, eventual consistency |
+| **10** | `hive-mind hierarchical-mesh` | `crdt` | Concurrent writes, collaborative editing |
+| **11** | `hive-mind adaptive` | `quorum` | Custom fault-tolerance, majority vote |
+
+> Type a number (1–11), or just **describe what you want to build** and I'll pick for you.
+
+---
+
+## Phase 2 — Give a concrete recommendation
+
+Based on the task or user choice, pick ONE mode and output EXACTLY this structure:
+
+---
+
+**Your Plan**
+
+- **Mode:** `<swarm|hive-mind>` · `<topology>` — <one sentence why>
+- **Agents:** <N> · <list agent types>
+- **Consensus:** `<protocol>` — <one sentence why>
+- **Strategy:** `<specialized|balanced|pipeline|parallel>` _(swarm only)_
+
+**Launch command:**
+```bash
+# Swarm:
+npx monomind swarm init --topology <topology> --max-agents <N> --strategy <strategy>
+
+# OR Hive-Mind (no --strategy flag):
+npx monomind hive-mind init --topology <topology> --consensus <protocol> --max-agents <N>
+```
+
+**Agent team:**
+```
+coordinator  → plans and delegates
+<agent>      → <role>
+<agent>      → <role>
+...
+```
+
+**Then spawn in Claude Code (one message):**
+```javascript
+// Bash: init the swarm/hive-mind first (above command)
+// Then Task tool calls — all in the same message:
+Task({ subagent_type: "coordinator", description: "...", run_in_background: true })
+Task({ subagent_type: "<agent>",     description: "...", run_in_background: true })
+// ... one Task call per agent
+```
+
+> Ready? Say **go** and I'll launch it, or adjust any detail first.
+
+---
+
+## Recommendation Logic (internal — do not output)
+
+Use this to pick the right mode when the user describes a task:
+
+| Task type | Mode | Topology | Consensus | Agents | Strategy |
+|---|---|---|---|---|---|
+| Bug fix (1–2 files) | swarm | hierarchical | raft | 4 | specialized |
+| Feature (3+ files) | swarm | hierarchical | raft | 6–8 | specialized |
+| Refactor / migration | swarm | hierarchical | raft | 5–6 | specialized |
+| Performance optimization | swarm | star | raft | 4–5 | parallel |
+| Security audit / fix | hive-mind | hierarchical-mesh | byzantine | 6 | specialized |
+| Research / docs | swarm | mesh | gossip | 4–6 | balanced |
+| Docs pipeline | swarm | ring | raft | 4 | pipeline |
+| Testing / coverage | swarm | star | raft | 5–6 | parallel |
+| Architecture design | swarm | hierarchical-mesh | raft | 8–10 | specialized |
+| Full release (end-to-end) | hive-mind | hierarchical-mesh | byzantine | 12–15 | specialized |
+| Long-running / unknown | swarm | adaptive | raft | 8–10 | specialized |
+| Refactor with rollback safety | hive-mind | hierarchical | raft | 5–6 | specialized |
+| Concurrent collaborative writes | hive-mind | hierarchical-mesh | crdt | 4–6 | balanced |
+| Large-scale eventual consistency (20+ agents) | hive-mind | mesh | gossip | 15–20 | balanced |
+| Custom fault-tolerance / majority vote | hive-mind | adaptive | quorum | 8–12 | specialized |
+
+**Quick decision rule:**
+- 1 file → use Edit tool directly, no swarm needed
+- 2–3 files, clear scope → swarm hierarchical, 4–6 agents, raft
+- Security/fault-critical → hive-mind hierarchical-mesh, byzantine
+- Research/exploration → swarm mesh, gossip
+- Pipeline stages (A→B→C) → swarm ring
+- Parallel independent work → swarm star
+- 10+ agents or long-running → hierarchical-mesh or adaptive
+- Refactor needing authoritative rollback → hive-mind hierarchical, raft
+- Concurrent collaborative writes → hive-mind hierarchical-mesh, crdt
+- Large agent pool (20+), eventual consistency → hive-mind mesh, gossip
+- Custom fault-tolerance threshold → hive-mind adaptive, quorum

package/packages/@monomind/cli/.claude/commands/memory/README.md

@@ -0,0 +1,79 @@
+---
+name: memory:README
+---
+
+# Memory Commands
+
+Commands for the LanceDB memory system — vector search, namespaced storage, HNSW indexing, and cross-session persistence.
+
+## Available Subcommands
+
+| Subcommand | Description |
+|---|---|
+| `memory init` | Initialize memory backend (lancedb, sqlite, hybrid) |
+| `memory store` | Store a memory entry with optional vector embedding |
+| `memory retrieve` | Retrieve a memory entry by key |
+| `memory search` | Search memory (semantic / keyword / hybrid) |
+| `memory list` | List all memory entries with optional filters |
+| `memory edit` | Update an existing memory entry |
+| `memory delete` | Delete one or more memory entries |
+| `memory templates` | Manage memory templates |
+| `memory stats` | Show memory usage statistics |
+| `memory configure` | Configure memory backend settings |
+| `memory cleanup` | Remove expired or stale entries |
+| `memory compress` | Compress stored data and rebuild indexes |
+| `memory export` | Export memories to JSON/JSONL file |
+| `memory import` | Import memories from a file |
+
+## Quick Reference
+
+```bash
+# Initialize
+npx monomind memory init --backend hybrid
+
+# Store
+npx monomind memory store --key "auth-pattern" --value "Use JWT with refresh tokens" --namespace "patterns"
+
+# Search
+npx monomind memory search --query "authentication" --type hybrid --build-hnsw
+
+# Retrieve exact key
+npx monomind memory retrieve --key "auth-pattern"
+
+# List all in namespace
+npx monomind memory list --namespace "patterns"
+
+# Export / Import
+npx monomind memory export --output backup.json --format json
+npx monomind memory import --input backup.json --merge
+```
+
+## Files
+
+- [memory-search.md](./memory-search.md) — Search memory (semantic/keyword/hybrid + HNSW)
+
+## MCP Tools
+
+| Tool | Purpose |
+|---|---|
+| `mcp__monomind__memory_store` | Store a memory entry |
+| `mcp__monomind__memory_retrieve` | Retrieve by key |
+| `mcp__monomind__memory_search` | Search memory |
+| `mcp__monomind__memory_list` | List entries |
+| `mcp__monomind__memory_delete` | Delete entries |
+| `mcp__monomind__memory_stats` | Usage statistics |
+| `mcp__monomind__memory_migrate` | Migrate between backends |
+
+## Backends
+
+| Backend | Description | Recommended |
+|---|---|---|
+| `lancedb` | Full LanceDB with HNSW vector search | Production |
+| `sqlite` | SQLite-only, no vector search | Lightweight |
+| `hybrid` | SQLite + LanceDB HNSW | Default (recommended) |
+
+## See Also
+
+- `hooks intelligence` — pattern learning on top of memory
+- `neural` — neural pattern training
+- `session` — session state (separate from memory)

package/packages/@monomind/cli/.claude/commands/memory/memory-search.md

@@ -0,0 +1,77 @@
+---
+name: memory:memory-search
+---
+
+# memory search
+
+Search stored memory using semantic, keyword, or hybrid search.
+
+## Usage
+
+```bash
+npx monomind memory search [options]
+```
+
+## Options
+
+| Flag | Short | Type | Default | Description |
+|---|---|---|---|---|
+| `--query` | `-q` | string | — | Search query text |
+| `--namespace` | `-n` | string | `default` | Namespace to search |
+| `--limit` | `-l` | number | `10` | Maximum results to return |
+| `--threshold` | — | number | `0.7` | Minimum similarity threshold (0–1) |
+| `--type` | `-t` | string | `hybrid` | Search type: `semantic`, `keyword`, `hybrid` |
+| `--build-hnsw` | — | boolean | `false` | Build pure-JS HNSW index before search (O(log n) vs O(n) linear) |
+| `--format` | — | string | — | Output format: `json` |
+
+## Examples
+
+```bash
+# Semantic search
+npx monomind memory search --query "authentication patterns"
+
+# Keyword search
+npx monomind memory search -q "JWT" --type keyword
+
+# Hybrid search with namespace
+npx monomind memory search -q "error handling" -n "project-x" --type hybrid
+
+# Build HNSW index first for large datasets
+npx monomind memory search -q "config" --build-hnsw --limit 20
+
+# High-precision search with threshold
+npx monomind memory search -q "OAuth flow" --threshold 0.9
+
+# JSON output
+npx monomind memory search -q "auth" --format json
+```
+
+## Search Types
+
+| Type | Description | Best For |
+|---|---|---|
+| `semantic` | Vector similarity search | Concept/meaning matching |
+| `keyword` | BM25 full-text search | Exact term matching |
+| `hybrid` | Combined semantic + keyword | General purpose (recommended) |
+
+## HNSW Index
+
+Use `--build-hnsw` when searching large memory stores (1,000+ entries). The pure-JS HNSW index gives O(log n) approximate-nearest-neighbor queries (vs O(n) linear scan) after the one-time build cost.
+
+## MCP Tool
+
+```javascript
+mcp__monomind__memory_search({
+  query: "authentication patterns",
+  namespace: "default",
+  limit: 10,
+  threshold: 0.7,
+  type: "hybrid"
+})
+```
+
+## See Also
+
+- `memory store` — store new memories
+- `memory list` — list all memories
+- `memory retrieve` — retrieve by exact key

package/packages/@monomind/cli/.claude/commands/monitoring/README.md

@@ -0,0 +1,69 @@
+---
+name: monitoring:README
+---
+
+# Monitoring Commands
+
+Commands for monitoring Monomind system health — swarm status, agents, tasks, memory, and performance metrics.
+
+## Available Commands
+
+| Command | Description |
+|---|---|
+| `status` | Full system status (swarm, agents, tasks, memory, MCP) |
+| `status agents` | Detailed agent table with uptime and success rate |
+| `status tasks` | Detailed task table with progress and priority |
+| `status memory` | Memory backend stats and HNSW performance |
+| `agent metrics` | Agent performance metrics by type and time period |
+| `agent health` | Per-agent health check with optional watch mode |
+| `swarm status` | Swarm-specific status (topology, consensus, agents) |
+
+## Quick Reference
+
+```bash
+# One-shot system snapshot
+npx monomind status
+
+# Live watch (refreshes every 2s)
+npx monomind status --watch
+
+# Health checks with pass/warn/fail
+npx monomind status --health-check
+
+# Detailed agent view
+npx monomind status agents
+
+# Agent performance metrics
+npx monomind agent metrics --period 7d
+
+# Swarm status
+npx monomind swarm status
+```
+
+## Files
+
+- [status.md](./status.md) — Full system status + watch mode + health checks
+- [agents.md](./agents.md) — `status agents` subcommand
+- [agent-metrics.md](./agent-metrics.md) — `agent metrics` by type and period
+
+## MCP Tools
+
+| Tool | Purpose |
+|---|---|
+| `mcp__monomind__swarm_status` | Swarm health and agent counts |
+| `mcp__monomind__swarm_health` | Swarm health check |
+| `mcp__monomind__agent_list` | All agents with metrics |
+| `mcp__monomind__agent_status` | Specific agent status |
+| `mcp__monomind__agent_health` | Agent health check |
+| `mcp__monomind__memory_stats` | Memory backend stats |
+| `mcp__monomind__task_summary` | Task counts by status |
+| `mcp__monomind__task_list` | All tasks with progress |
+| `mcp__monomind__system_health` | Full system health |
+| `mcp__monomind__system_metrics` | System performance metrics |
+| `mcp__monomind__mcp_status` | MCP server status |
+
+## See Also
+
+- `doctor` — comprehensive diagnostics (`npx monomind doctor`)
+- `hooks metrics` — learning and intelligence metrics
+- `performance` — performance profiling commands

package/packages/@monomind/cli/.claude/commands/monitoring/agent-metrics.md

@@ -0,0 +1,65 @@
+---
+name: monitoring:agent-metrics
+---
+
+# agent metrics
+
+Show agent performance metrics — tasks completed, success rate, and memory vectors by agent type.
+
+## Usage
+
+```bash
+npx monomind agent metrics [agentId] [options]
+```
+
+The optional `agentId` positional argument filters to a specific agent. Omit for all agents.
+
+## Options
+
+| Flag | Short | Type | Default | Description |
+|---|---|---|---|---|
+| `--period` | `-p` | string | `24h` | Time period: `1h`, `24h`, `7d`, `30d` |
+| `--format` | — | string | — | Output format: `json` |
+
+## Examples
+
+```bash
+# All agents — last 24 hours
+npx monomind agent metrics
+
+# Last hour
+npx monomind agent metrics --period 1h
+
+# Last 7 days
+npx monomind agent metrics -p 7d
+
+# Specific agent
+npx monomind agent metrics agent-001
+
+# JSON output
+npx monomind agent metrics --format json
+```
+
+## Output Sections
+
+**Summary table** — total agents, active agents, tasks completed, average success rate, memory vector count
+
+**By Agent Type table** — per-type breakdown: count, tasks completed, success rate
+
+**Memory** — vector count and search backend (HNSW-indexed once vectors exist)
+
+## Data Source
+
+Metrics are read from `.swarm/agents/` state files and `.swarm/swarm-activity.json`. If no agents have been spawned yet, the output will note this with a suggestion to run `agent spawn`.
+
+## MCP Tool
+
+```javascript
+mcp__monomind__agent_status({ agentId: "agent-001" })
+```
+
+## See Also
+
+- `status agents` — live agent status table
+- `agent health` — per-agent health check with `--watch` mode
+- `agent list` — list all agents