monomind 1.19.0 → 2.0.1

package/.claude/commands/mastermind/specialagents.md

@@ -1,122 +0,0 @@
-<!-- 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:** `/mastermind:specialagents <slug>` — skip selection, activate immediately.
-
-**Interactive:** `/mastermind:specialagents` — guided category → agent selection.
-
-**Auto:** `/mastermind: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 `/mastermind:specialagents` to browse available agents."

package/.claude/commands/mastermind/stoporg.md

@@ -1,75 +0,0 @@
-<!-- Stop a running scheduled org loop. Sets status to "stopped" — the next scheduled wakeup reads the status, skips all work, and does not reschedule. Loop dies within one interval. -->
-
-**If $ARGUMENTS is empty:** Output the following and wait.
-
----
-
-**MASTERMIND: STOP ORG**
-
-Stops a scheduled org loop cleanly. The org's `status` is set to `"stopped"` — the next scheduled wakeup will read the status, skip all work, and not reschedule itself. The loop is guaranteed to die within one interval (no orphaned wakeups).
-
-**Usage:**
-
-```
-/mastermind:stoporg --org <name>
-```
-
-**Examples:**
-
-```
-/mastermind:stoporg --org livarto-issue-resolver
-/mastermind:stoporg --org research-pod
-```
-
-**Lifecycle:**
-```
-stopped  →  (runorg)   →  active
-active   →  (stoporg)  →  stopped
-active   →  (HIL)      →  paused    (set manually in .monomind/orgs/<name>.json)
-paused   →  (set active) →  active  (resume by setting status back to "active" in the JSON)
-```
-
-Your scheduled orgs:
-
-```bash
-ls .monomind/orgs/*.json 2>/dev/null | grep -v -- '-approvals\|-state\|-activity' | \
-  xargs -I{} sh -c 'name=$(jq -r ".name" "{}"); status=$(jq -r ".status // \"no-loop\"" "{}"); interval=$(jq -r "if .loop.poll_interval_minutes then \"\(.loop.poll_interval_minutes)m\" else \"—\" end" "{}"); echo "  $name  ($status, $interval)"' 2>/dev/null || echo "(none)"
-```
-
----
-
-**If $ARGUMENTS is non-empty:** Execute the flow below.
-
----
-
-Parse `$ARGUMENTS` for:
-- `--org <name>` → org_name = <name>
-
-If `--org` is not provided, list orgs with schedules and ask which to stop.
-
-Verify the org file exists:
-```bash
-[ -f ".monomind/orgs/${org_name}.json" ] || { echo "Org '${org_name}' not found."; exit 1; }
-```
-
-Generate a session ID:
-```bash
-REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-session_id="mm-$(date -u +%Y%m%dT%H%M%S)"
-CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-```
-
-Invoke `Skill("mastermind-skills:stoporg")` passing: org_name: `$org_name`, session_id: `$session_id`, caller: "command".
-
-After skill returns: emit `session:complete`:
-```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
-  -H "Content-Type: application/json" \
-  -d "$(jq -cn \
-    --arg session "$session_id" \
-    '{type:"session:complete",session:$session,domain:"ops",status:"complete",domains:["ops"],ts:(now*1000|floor)}')" || true
-```
-
-Follow _protocol.md Brain Write Procedure for domain `ops`.
-
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/swarm.md

@@ -1,158 +0,0 @@
-<!-- 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/monoes/monomind

package/.claude/commands/mastermind/taskdev.md

@@ -1,23 +0,0 @@
-<!-- Execute an implementation plan task-by-task using fresh subagents with two-stage review per task. Default mode: auto. -->
-
-**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 and intake below.
-
-Parse `$ARGUMENTS` for:
-- `--auto` flag → mode = auto
-- `--confirm` flag → mode = confirm
-- `--project <name>` → project_name = <name>
-- Remaining text = plan_file path (path to the plan `.md` file to execute)
-
-If plan_file is empty: ask "Which plan file should I execute? (provide an absolute path)"
-
-Load brain context (follow `_protocol.md` Brain Load Procedure).
-
-Default mode: **auto** (unless `--confirm` flag is present).
-
----
-
-Invoke `Skill("mastermind-skills:taskdev")` passing: brain_context, plan_file, project_name, mode.
-
-After skill returns: follow `_protocol.md` Brain Write Procedure.
-
-**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/.claude/commands/mastermind/tdd.md

@@ -1,19 +0,0 @@
-<!-- Implement a feature or bugfix using Test-Driven Development — Red-Green-Refactor with the Iron Law enforced. -->
-
-**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`.
-
-Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text = feature_or_bug.
-
-Load brain context for the `tdd` domain (follow `_protocol.md` Brain Load Procedure).
-
-If feature_or_bug is empty: ask "What feature or bug should be implemented with TDD?"
-
-Default mode: **auto**.
-
----
-
-Invoke `Skill("mastermind-skills:tdd")` passing: brain_context, feature_or_bug, project_name, mode.
-
-After skill returns: follow `_protocol.md` Brain Write Procedure for domain `tdd`.
-
-**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/.claude/commands/mastermind/techport.md

@@ -1,27 +0,0 @@
-<!-- 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-skills:techport")` passing: source_path, focus_hint, mode.
-
-After skill returns: follow `_protocol.md` Brain Write Procedure for domain `techport`.
-
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/understand.md

@@ -1,136 +0,0 @@
-<!-- "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/.claude/commands/mastermind/verify.md

@@ -1,19 +0,0 @@
-<!-- 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-skills:verify")` passing: brain_context, claim_or_task, project_name, mode.
-
-After skill returns: follow `_protocol.md` Brain Write Procedure for domain `verify`.
-
-**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/.claude/commands/mastermind/worktree.md

@@ -1,17 +0,0 @@
-<!-- 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-skills:worktree")` passing: brain_context, params, mode.
-
-After skill returns: follow `_protocol.md` Brain Write Procedure.
-
-Invoke `Skill("mastermind-skills:_repeat")` now. Required — do not skip.