@monoes/monomindcli 2.16.2 → 2.16.4

package/.claude/commands/mastermind/createtask.md

@@ -122,7 +122,7 @@ Spawn a `planner` agent. Provide analysis + `FULL_CONTEXT`.
 4. **Test Colocation**: Never create standalone "write tests" tasks — only exception is integration/e2e tests spanning multiple components.
 5. **Prerequisite Chains**: Use `prerequisites` to enforce ordering. Same agent picks up the chain in sequence.
 6. **Chain Size Limit**: Max 4 tasks per chain. Split larger chains into two sub-chains linked by prerequisite.
-7. **Agent Capability**: Agent type must match the domain (no frontend agent on DB migrations, no backend-dev on CSS).
+7. **Agent Capability**: Agent type must match the domain (no frontend agent on DB migrations, no Backend Architect on CSS). Choose each `agent_type` with `mcp__monomind__pick({ task: "<task title>", kind: "agents", top: 1 })` → `agents.ranked[0].name` (no MCP: `monomind pick` per `mastermind-agent-select/SKILL.md`; nothing returned: `coder`) — it must be an installed agent name, never an invented one.
 
 ### Task Card Format
 
@@ -306,7 +306,7 @@ Mode selection: **parallel** = mostly independent tasks; **minimal** = mixed; **
 
 ## Step 8: Final Dependency Review
 
-Spawn a fresh `Code Reviewer` agent. Provide the complete `TASKS` array and `REPO_NAME`.
+Spawn a fresh `reviewer` agent. Provide the complete `TASKS` array and `REPO_NAME`.
 
 The agent MUST check:
 - **Prerequisite integrity**: all referenced prerequisites exist, no circular deps, no orphans

package/.claude/commands/mastermind/do.md

@@ -117,7 +117,7 @@ Group tasks by `context_group`:
 [mastermind:do] Found N tasks: X in context groups, Y independent.
 
 Context groups:
-  - <group-1>: 3 tasks (agent: backend-dev, sequential)
+  - <group-1>: 3 tasks (agent: Backend Architect, sequential)
   - <group-2>: 2 tasks (agent: Frontend Developer, sequential)
   - independent: 4 tasks (mixed agents, parallelizable)
 
@@ -200,6 +200,8 @@ Spawn ALL agents in ONE message using the Agent tool:
 
 All agents run concurrently via `run_in_background: true`.
 
+**Agent type:** use the task's assigned agent only when it is an installed agent name. When it is missing or unknown, pick one: the prompt's `[PICK]` line, else `mcp__monomind__pick({ task: "<task title>", kind: "agents", top: 1 })` → `agents.ranked[0].name`, else local `monomind pick` (see `mastermind-agent-select/SKILL.md`), else `coder`.
+
 **Agent prompt template for chain execution:**
 ```
 You have N tasks to execute in order. Complete each one before moving to the next.
@@ -210,25 +212,15 @@ You have full access to the Agent tool (Claude Code: Task tool) to spawn
 sub-agents for any specialized subtask. This capability is recursive —
 sub-agents you spawn also receive it.
 
-Available agent categories:
-  CORE      coder · reviewer · tester · planner · researcher
-  BACKEND   backend-dev · Backend Architect · DB Optimizer · API Tester
-  FRONTEND  Frontend Developer · mobile-dev · Mobile App Builder
-  ARCH      Software Architect · system-architect
-  SECURITY  Security Engineer · security-architect
-  AI/ML     AI Engineer · ml-developer · Data Engineer
-  DEVOPS    DevOps Automator · SRE · cicd-engineer
-  DOCS      Technical Writer · api-docs
-  PRODUCT   Product Manager · Launch Strategist · CRO Specialist
-  MARKETING Content Creator · SEO Specialist · Growth Hacker
-  SOCIAL    TikTok · LinkedIn · Twitter · Instagram Strategist
-  SALES     Deal Strategist · Sales Coach · Outbound Strategist
-  BUSINESS  Finance Tracker · Legal Compliance Checker · Analytics Reporter
-  DESIGN    Monodesign (UI/UX · brand · CSS · animation · design systems)
+To choose the subagent_type: use the prompt's [PICK] line if present, else
+mcp__monomind__pick({ task: "<subtask>", kind: "agents", top: 3 }) -> an
+agents.ranked[].name (no MCP: monomind pick -t "<subtask>" --top 3 --json).
+Fallbacks if nothing is returned: coder · tester · reviewer · researcher ·
+planner. Do NOT invent agent names.
 
 Delegate when: a subtask needs deeper expertise, parallel work speeds things up,
 or a subtask is outside your domain but blocks your progress.
-How: Agent({ subagent_type: "slug", prompt: `full briefing + this delegation block`, run_in_background: true })
+How: Agent({ subagent_type: "<picked agent>", prompt: `full briefing + this delegation block`, run_in_background: true })
 =================================
 
 TASK 1 of N: <title>
@@ -266,25 +258,15 @@ You have full access to the Agent tool (Claude Code: Task tool) to spawn
 sub-agents for any specialized subtask. This capability is recursive —
 sub-agents you spawn also receive it.
 
-Available agent categories:
-  CORE      coder · reviewer · tester · planner · researcher
-  BACKEND   backend-dev · Backend Architect · DB Optimizer · API Tester
-  FRONTEND  Frontend Developer · mobile-dev · Mobile App Builder
-  ARCH      Software Architect · system-architect
-  SECURITY  Security Engineer · security-architect
-  AI/ML     AI Engineer · ml-developer · Data Engineer
-  DEVOPS    DevOps Automator · SRE · cicd-engineer
-  DOCS      Technical Writer · api-docs
-  PRODUCT   Product Manager · Launch Strategist · CRO Specialist
-  MARKETING Content Creator · SEO Specialist · Growth Hacker
-  SOCIAL    TikTok · LinkedIn · Twitter · Instagram Strategist
-  SALES     Deal Strategist · Sales Coach · Outbound Strategist
-  BUSINESS  Finance Tracker · Legal Compliance Checker · Analytics Reporter
-  DESIGN    Monodesign (UI/UX · brand · CSS · animation · design systems)
+To choose the subagent_type: use the prompt's [PICK] line if present, else
+mcp__monomind__pick({ task: "<subtask>", kind: "agents", top: 3 }) -> an
+agents.ranked[].name (no MCP: monomind pick -t "<subtask>" --top 3 --json).
+Fallbacks if nothing is returned: coder · tester · reviewer · researcher ·
+planner. Do NOT invent agent names.
 
 Delegate when: a subtask needs deeper expertise, parallel work speeds things up,
 or a subtask is outside your domain but blocks your progress.
-How: Agent({ subagent_type: "slug", prompt: `full briefing + this delegation block`, run_in_background: true })
+How: Agent({ subagent_type: "<picked agent>", prompt: `full briefing + this delegation block`, run_in_background: true })
 =================================
 
 TASK: <title>
@@ -391,9 +373,9 @@ Do NOT attempt to execute remaining chain tasks in either mode.
 
 After execution completes (DONE or DONE_WITH_CONCERNS), run a review session BEFORE moving the card.
 
-### 8a: Spawn a Code Reviewer
+### 8a: Spawn a reviewer
 
-Spawn a `feature-dev:code-reviewer` agent via the Agent tool. Provide:
+Spawn a `reviewer` agent via the Agent tool. Provide:
 - The list of files modified (from the implementer's report)
 - The `TASK_CONTEXT` (so the reviewer knows what was intended)
 - The `PROJECT_CONTEXT`
@@ -466,7 +448,7 @@ Output a status summary:
 
 | Task                          | Status         | Agent        | Review     |
 |-------------------------------|----------------|-------------|------------|
-| <title>                       | Review         | backend-dev | approved   |
+| <title>                       | Review         | coder       | approved   |
 | <title>                       | Review         | coder       | approved   |
 | <title>                       | Human in Loop  | coder       | blocked    |
 ```

package/.claude/commands/mastermind/finance.md

@@ -16,8 +16,14 @@ Run intake if prompt is vague (follow mastermind-intake/SKILL.md — stop at Q3,
 
 Default mode for this command: **confirm** (unless `--auto` flag present or intake Q4 says auto).
 
-Invoke `Skill("mastermind-finance")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+Pick the specialist (there is no `mastermind-finance` skill package — the work is done by a picked agent). In order, per `mastermind-agent-select/SKILL.md`:
+1. The prompt's `[PICK]` line, if it fits this finance task.
+2. `mcp__monomind__pick({ task: prompt, kind: "both", categories: ["specialized", "core"], top: 3 })` — use `agents.ranked[0].name`; if `skills.ranked[0]` clearly fits, load it with its `invoke`.
+3. No MCP: the Standard Selection Block from `mastermind-agent-select/SKILL.md` with `CATEGORIES="specialized core"`, `TOP_N=3`.
+4. Nothing returned: `general-purpose`.
 
-After skill returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `finance`.
+Spawn the picked agent via the Task tool, passing: brain_context, prompt, project_name, board_id (create if needed), mode — as a briefing that follows the Monotask Task Briefing Standard in `mastermind-protocol/SKILL.md` and includes the AGENT DELEGATION CAPABILITY block from `mastermind-delegation/SKILL.md`. In `confirm` mode, show the agent's plan or draft to the user before anything is published or sent.
+
+After the agent returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `finance`.
 
 Invoke `Skill("mastermind-repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/help.md

@@ -18,23 +18,17 @@ Quick reference for all Mastermind skills and CLI commands available in this pro
 | `mastermind:swarm` | Swarm coordination reference — topologies, strategies, init patterns |
 | `mastermind:memory` | Memory CLI quick reference |
 
-## Org Runtime (v2 default)
+## Org Runtime
 
 | Command | Description |
 |-------|-------------|
-| `/mastermind:createorg` | Define and save an org (always v2-shaped) |
-| `/mastermind:runorg` | Start a saved org via the Org Runtime v2 daemon (`monomind org run`/`serve`) — auto-migrates v1-shaped configs first |
-| `/mastermind:stoporg` | Stop a running scheduled org loop |
+| `/mastermind:createorg` | Define and save an org |
+| `/mastermind:runorg` | Start a saved org via the Org Runtime daemon (`monomind org run`/`serve`) — converts legacy-format config files first |
+| `/mastermind:stoporg` | Stop a running org (`monomind org stop`) |
 | `/mastermind:orgstatus` | Detailed status for a single org |
 | `/mastermind:orgs` | List all saved orgs |
 
-### Legacy v1 (marker `LEGACY-ORG-V1` — reachable only under these explicit names)
-
-| Command | Description |
-|-------|-------------|
-| `/mastermind:runorgv1` | Legacy prompt-orchestrated org runner — superseded by `/mastermind:runorg` |
-| `/mastermind:approvev1` | Legacy approval queue for v1 orgs — v2 approvals arrive as dashboard question events instead |
-| `/mastermind:heartbeatv1` | Legacy manual agent wake-up for v1 orgs — v2 roles are live SDK sessions with no wake cycle |
+Pending tool approvals from a running org: `monomind org approvals <org>`, then `monomind org approve` / `monomind org deny` (or the dashboard's Human Input tab).
 
 ## Core CLI Commands
 

package/.claude/commands/mastermind/ideate.md

@@ -128,7 +128,7 @@ If zero ideas were generated after deduplication, report "No ideas generated by
 
 ## Step 4: Evaluator -- Assess Each Idea
 
-Spawn a single `Product Manager` agent via the Agent tool. Provide it with:
+Spawn a single `general-purpose` agent as the Product Manager evaluator via the Agent tool. Provide it with:
 - All ideas (titles + descriptions)
 - The `PROJECT_CONTEXT`
 - The user's original prompt: `$ARGUMENTS`
@@ -223,7 +223,7 @@ Output a summary table:
 ```
 | # | Idea                        | Category           | Status   | Subtasks | Total Effort | Agents |
 |---|-----------------------------|--------------------|----- ----|----------|--------------|--------|
-| 1 | <title>                     | feature            | Tasked   | 4        | 18/40        | coder, backend-dev, tester |
+| 1 | <title>                     | feature            | Tasked   | 4        | 18/40        | coder, Backend Architect, tester |
 | 2 | <title>                     | technical-baseline | Iced     | --       | --           | --     |
 | 3 | <title>                     | feature            | Rejected | --       | --           | --     |
 ```
@@ -245,12 +245,12 @@ If there are todo tasks:
 
 *File mode:*
 ```
-Skill("mastermind-do", "--file <TASK_FILE> --mode <parallel|minimal|sequential>")
+Skill("mastermind:do", "--file <TASK_FILE> --mode <parallel|minimal|sequential>")
 ```
 
 *Monotask mode:*
 ```
-Skill("mastermind-do", "--monotask --space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
+Skill("mastermind:do", "--monotask --space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
 ```
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.

package/.claude/commands/mastermind/improve.md

@@ -203,7 +203,7 @@ If zero improvements were generated, report "No improvement opportunities found
 
 ## Step 5: Evaluate and Prioritize
 
-Spawn a single `Product Manager` agent via the Agent tool. Provide it with:
+Spawn a single `general-purpose` agent as the Product Manager evaluator via the Agent tool. Provide it with:
 - All improvement ideas (titles, descriptions, and all comments)
 - The `COMPONENT_ANALYSIS`
 - The `PROJECT_CONTEXT`
@@ -329,12 +329,12 @@ If there are todo tasks:
 
 *File mode:*
 ```
-Skill("mastermind-do", "--file <TASK_FILE> --mode <parallel|minimal|sequential>")
+Skill("mastermind:do", "--file <TASK_FILE> --mode <parallel|minimal|sequential>")
 ```
 
 *Monotask mode:*
 ```
-Skill("mastermind-do", "--monotask --space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
+Skill("mastermind:do", "--monotask --space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
 ```
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.

package/.claude/commands/mastermind/marketing.md

@@ -16,8 +16,14 @@ Run intake if prompt is vague (follow mastermind-intake/SKILL.md — stop at Q3,
 
 Default mode for this command: **confirm** (unless `--auto` flag present or intake Q4 says auto).
 
-Invoke `Skill("mastermind-marketing")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+Pick the specialist (there is no `mastermind-marketing` skill package — the work is done by a picked agent). In order, per `mastermind-agent-select/SKILL.md`:
+1. The prompt's `[PICK]` line, if it fits this marketing task.
+2. `mcp__monomind__pick({ task: prompt, kind: "both", categories: ["marketing", "specialized"], top: 3 })` — use `agents.ranked[0].name`; if `skills.ranked[0]` clearly fits, load it with its `invoke`.
+3. No MCP: the Standard Selection Block from `mastermind-agent-select/SKILL.md` with `CATEGORIES="marketing specialized"`, `TOP_N=3`.
+4. Nothing returned: `Launch Strategist`.
 
-After skill returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `marketing`.
+Spawn the picked agent via the Task tool, passing: brain_context, prompt, project_name, board_id (create if needed), mode — as a briefing that follows the Monotask Task Briefing Standard in `mastermind-protocol/SKILL.md` and includes the AGENT DELEGATION CAPABILITY block from `mastermind-delegation/SKILL.md`. In `confirm` mode, show the agent's plan or draft to the user before anything is published or sent.
+
+After the agent returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `marketing`.
 
 Invoke `Skill("mastermind-repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/master.md

@@ -97,8 +97,8 @@ digraph mastermind_routing {
 | Execute a written plan step-by-step with stop-on-blocker | `Skill("mastermind-execute")` |
 | Execute a plan via fresh subagents with 2-stage review | `Skill("mastermind-execute")` |
 | Fix or investigate 2+ independent problems concurrently (different files, subsystems, or bugs) | dispatch parallel subagents in one message — one per independent domain; use `Skill("mastermind-execute")` for plan-driven parallel work |
-| Ingest a prompt/spec/folder and generate agent-optimized tasks | `Skill("mastermind-createtask")` |
-| Execute tasks from a task file or monotask board (parallel/sequential/minimal modes, review cycles, loop) | `Skill("mastermind-do")` |
+| Ingest a prompt/spec/folder and generate agent-optimized tasks | `Skill("mastermind:createtask")` |
+| Execute tasks from a task file or monotask board (parallel/sequential/minimal modes, review cycles, loop) | `Skill("mastermind:do")` |
 | Design first — spec, approaches, approval gate before code | `Skill("mastermind-design")` |
 | Build a feature, fix a bug, implement anything | `Skill("mastermind-plan")` then `Skill("mastermind-execute")` |
 | Code review, content critique, strategy audit | `Skill("mastermind-review")` |
@@ -106,31 +106,32 @@ digraph mastermind_routing {
 | System architecture, DDD, technical design | `Skill("mastermind-design")` |
 | Market research, competitive analysis, user insights | `Skill("mastermind-research")` |
 | Ideas, feature generation, opportunity framing | `Skill("mastermind-idea")` |
-| Research ideas, evaluate with PM lens, decompose into subtasks | `Skill("mastermind-ideate")` |
-| Analyze a component, research improvements, generate improvement tasks | `Skill("mastermind-improve")` |
-| Marketing campaign, copy, SEO | `Skill("mastermind-marketing")` |
-| Sales outreach, proposals, pipeline | `Skill("mastermind-sales")` |
-| Blog, docs, newsletters, threads | `Skill("mastermind-content")` |
+| Research ideas, evaluate with PM lens, decompose into subtasks | `Skill("mastermind:ideate")` |
+| Analyze a component, research improvements, generate improvement tasks | `Skill("mastermind:improve")` |
+| Marketing campaign, copy, SEO | `Skill("mastermind:marketing")` |
+| Sales outreach, proposals, pipeline | `Skill("mastermind:sales")` |
+| Blog, docs, newsletters, threads | `Skill("mastermind:content")` |
 | Versioning, changelogs, deployment | `Skill("mastermind-release")` |
 | Finish a branch — tests, options menu, merge/PR/discard | `Skill("mastermind-review")` |
-| Workflow, process, reporting | `Skill("mastermind-ops")` |
-| Invoicing, forecasting, cost | `Skill("mastermind-finance")` |
-| Inspect or manage brain memory | `Skill("mastermind-brain")` |
+| Workflow, process, reporting | `Skill("mastermind:ops")` |
+| Invoicing, forecasting, cost | `Skill("mastermind:finance")` |
+| Inspect or manage brain memory | `Skill("mastermind:brain")` |
 | Technical portfolio, project state assessment | `Skill("mastermind-techport")` |
 | Define/run an agent organization | `Skill("mastermind-createorg")` / `Skill("mastermind-runorg")` |
 | Autonomous build + review until clean | `Skill("mastermind-execute")` |
 | Isolate work in a git worktree | `Skill("mastermind-worktree")` |
 | Write or improve a mastermind skill | `Skill("mastermind-skill-builder")` |
+| Choose the specialist agent (`subagent_type`) or skill for any task | the prompt's `[PICK]` line, else `mcp__monomind__pick` — see `mastermind-agent-select/SKILL.md`; never a hardcoded roster |
 
 ### Skill Execution Order
 
 When multiple skills could apply to a **single-skill invocation** (not a full mastermind:master multi-domain run):
 
-1. **Process skills first** — debug (`mastermind:debug`), brainstorming (`mastermind:idea`), architecture (`mastermind:architect`), research (`mastermind:research`) determine HOW to approach the work
+1. **Process skills first** — debug (`mastermind:debug`), brainstorming (`mastermind:idea`), architecture (`mastermind:design`), research (`mastermind:research`) determine HOW to approach the work
 2. **Execution skills second** — build, review, release execute the approach
 
-"Let's build X" → `mastermind:architect` first if approach is unclear, then `mastermind:build`.
-"Fix this" → `mastermind:debug` to find root cause first, then `mastermind:build` to fix.
+"Let's build X" → `mastermind:design` first if approach is unclear, then `mastermind:plan` → `mastermind:execute`.
+"Fix this" → `mastermind:debug` to find root cause first, then `mastermind:execute` to fix.
 "Ship it" → `mastermind:review` to verify clean, then `mastermind:release`.
 
 **Multi-domain runs (Steps 4–7 of this command):** Domain manager agents for different domains run concurrently — there is no enforced serial order between `build` and `architect` domain managers when both are active. The order above applies when you (the master) are choosing which single skill to invoke directly.
@@ -219,19 +220,15 @@ Describe your goal. Mastermind identifies the relevant domains, spawns specialis
 
 **Debug & quality**
 `/mastermind:debug` — systematic root-cause investigation before any fix attempt
-`/mastermind:verify` — confirm claims with evidence: tests pass, feature works, fix resolved
-`/mastermind:tdd` — enforce Red-Green-Refactor; no production code before failing test
+`Skill("verification-quality")` — confirm claims with evidence: tests pass, feature works, fix resolved
 
 **Plan & execute**
 `/mastermind:design` — brainstorm, propose approaches, write approved spec before building
 `/mastermind:plan` — write a complete implementation plan (no placeholders, exact file paths)
 `/mastermind:execute` — run a written plan step-by-step with stop-on-blocker discipline
-`/mastermind:taskdev` — execute a plan via fresh subagents with two-stage per-task review
-`/mastermind:finish` — complete a branch: verify tests → options menu → merge/PR/keep/discard
 
 **Build & ship**
-`/mastermind:build` — code, features, bug fixes, test suites
-`/mastermind:architect` — system structure, DDD, deduplication, migration (`--scope review|design|deduplicate|migrate|all`)
+`/mastermind:do` — execute tasks from a task file or monotask board (code, features, bug fixes, test suites)
 `/mastermind:idea` — products, features, pivots, opportunity framing
 `/mastermind:content` — blog, threads, documentation, newsletters
 
@@ -252,11 +249,10 @@ Describe your goal. Mastermind identifies the relevant domains, spawns specialis
 
 **Persistent agent orgs** — named teams that coordinate across sessions
 `/mastermind:createorg` — define an org: roles, hierarchy, goal
-`/mastermind:runorg` — start a saved org via the Org Runtime v2 daemon (auto-migrates v1 configs); legacy prompt-orchestrated path: `/mastermind:runorgv1`
-`/mastermind:approvev1` — review and action pending approval requests from running org agents (v1 orgs only — v2 approvals arrive in the dashboard Human Input tab)
+`/mastermind:runorg` — start a saved org via the Org Runtime daemon (converts legacy-format config files first); pending tool approvals: `monomind org approvals <org>` or the dashboard Human Input tab
 
 **Autonomous & advanced**
-`/mastermind:autodev` — research → build → review loop until clean (`--tillend` supported)
+`/mastermind:repeat` — wrap any mastermind command in a loop (`--tillend` supported)
 `/mastermind:techport` — technical portfolio assessment; port capabilities from other projects
 `/mastermind:worktree` — isolate work in a git worktree safely
 `/mastermind:skill-builder` — write or improve a mastermind skill with TDD discipline
@@ -607,9 +603,11 @@ echo "Session state saved to current.json"
 
 Skipping any of these steps produces an incomplete pipeline run — card content is generated but no evaluation, elaboration, or task breakdown occurs.
 
-**Before spawning**, select the best domain manager agent type from the registry for each active domain. Do not hardcode `coordinator` — pick the agent whose expertise best fits the domain goal.
+**Before spawning**, pick the best domain manager agent for each active domain. Do not hardcode `coordinator` — pick the agent whose expertise best fits the domain goal. Pick order (see `mastermind-agent-select/SKILL.md`): the prompt's `[PICK]` line → `mcp__monomind__pick` → local `monomind pick` → registry keyword scorer → `coordinator`.
 
-**BASH TOOL REQUIREMENT:** Domain managers must run `monotask` CLI commands. Only use subagent_types that include Bash in their tool list. If the registry returns an agent without Bash (e.g. `Product Manager`, `Backend Architect`), override it with `general-purpose` (which has all tools). Agents without Bash cannot create cards, emit curl events, or write session files — they will silently produce degraded output.
+**If `mcp__monomind__pick` is available**, call it once per active domain before Phase A — `{ task: "<domain goal>", kind: "agents", categories: <the domain's categories from the case table below, as an array>, top: 1 }` — and put the answers into Phase A as `MCP_PICKS='{"<domain>":"<agents.ranked[0].name>", ...}'` on the first line of the Bash call. Phase A uses those first.
+
+**BASH TOOL REQUIREMENT:** Domain managers must run `monotask` CLI commands. Only use subagent_types that include Bash in their tool list. If the picked agent's definition restricts `tools:` and leaves out Bash, override it with `general-purpose` (which has all tools). Agents without Bash cannot create cards, emit curl events, or write session files — they will silently produce degraded output.
 
 **Phase A — Registry selection** (run as one Bash call; must complete before Phase C):
 
@@ -629,27 +627,46 @@ fi
 domains_needed=$(jq -r '.domains_needed[]? // empty' "$SESSION_STATE" | grep -v '^idea$' | tr '\n' ' ')
 [ -z "$domains_needed" ] && { echo "INFO: no non-idea domains to spawn as Task agents"; }  # idea-only runs are valid
 
-# Returns: best agent name from registry for the given domain+goal
+# MCP_PICKS: optional JSON {domain: agent name} from mcp__monomind__pick (see above)
+[ -n "$MCP_PICKS" ] || MCP_PICKS='{}'
+
+# Local only — never npx. Accept a binary only when its pick output is the
+# unified index (skill entries carry `source`); see mastermind-agent-select.
+mmpick() { for c in monomind ./node_modules/.bin/monomind; do
+    command -v "$c" >/dev/null 2>&1 || continue
+    out=$("$c" pick "$@" --json 2>/dev/null) || continue
+    printf '%s' "$out" | jq -e '[.skills.ranked[]? | has("source")] | (length > 0 and all)' \
+      >/dev/null 2>&1 && { printf '%s\n' "$out"; return 0; }
+  done; return 127; }
+
+# Returns: best agent name for the given domain+goal
 pick_domain_manager() {
   local domain="$1"
   local goal="$2"
   local kw cats result
-  kw=$(echo "$goal" | tr '[:upper:]' '[:lower:]' | grep -oE '[a-z]{5,}' | sort -u | tr '\n' ' ')
+  kw=$(echo "$goal" | tr '[:upper:]' '[:lower:]' | grep -oE '[a-z]{4,}' | sort -u | tr '\n' ' ')
+  # Real registry categories (the .claude/agents/ folder names)
   case "$domain" in
-    build)     cats="engineering development architecture" ;;
-    marketing) cats="marketing paid-media strategy" ;;
-    sales)     cats="sales strategy" ;;
-    research)  cats="academic specialized strategy" ;;
+    build)     cats="engineering core architecture design specialized" ;;
+    marketing) cats="marketing specialized" ;;
+    sales)     cats="marketing specialized" ;;
+    research)  cats="core specialized specialists" ;;
     content)   cats="marketing specialized" ;;
-    ops)       cats="project-management strategy support" ;;
-    release)   cats="devops github engineering" ;;
-    review)    cats="engineering testing analysis" ;;
-    finance)   cats="strategy specialized" ;;
+    ops)       cats="specialized engineering core" ;;
+    release)   cats="github engineering" ;;
+    review)    cats="engineering testing core design specialized" ;;
+    finance)   cats="specialized core" ;;
     architect) cats="architecture engineering" ;;
-    idea)      cats="product strategy marketing" ;;
-    *)         cats="core strategy" ;;
+    idea)      cats="marketing specialized design" ;;
+    *)         cats="core" ;;
   esac
-  result=$(jq -r \
+  # 1. mcp__monomind__pick answer passed in by the caller
+  result=$(echo "$MCP_PICKS" | jq -r --arg d "$domain" '.[$d] // empty' 2>/dev/null)
+  # 2. local monomind pick
+  [ -z "$result" ] && result=$(mmpick -t "$domain manager: $goal" --categories "$cats" --top 1 \
+    | jq -r '.agents.ranked[0].name // .agents.ranked[0].id // empty' 2>/dev/null)
+  # 3. registry keyword scorer
+  [ -z "$result" ] && result=$(jq -r \
     --arg cats "$cats" \
     --arg kw "$kw" \
     '[ .agents[] | select(.deprecated != true)
@@ -657,7 +674,8 @@ pick_domain_manager() {
        | {name: .name,
           score: (
             (.name | ascii_downcase) as $n |
-            (.description // "" | ascii_downcase) as $desc |
+            ([.description, (.capabilities // [] | join(" ")), (.tags // [] | join(" ")), (.whenToUse // "")]
+             | map(. // "") | join(" ") | ascii_downcase) as $desc |
             # Score keyword matches against both name (weight 2) and description (weight 1) —
             # name match is a stronger signal. Bind each word to $w before contains(): piping
             # into contains(.) rebinds "." to the piped value, which would silently match everything.
@@ -672,7 +690,7 @@ pick_domain_manager() {
      ] | sort_by(-.score) | .[0].name // empty' \
     "$REGISTRY" 2>/dev/null)
   if [ -z "$result" ]; then
-    echo "WARN: registry lookup failed for domain=$domain, using coordinator fallback" >&2
+    echo "WARN: agent pick failed for domain=$domain, using coordinator fallback" >&2
     echo "coordinator"
   else
     echo "$result"
@@ -764,7 +782,7 @@ Each Task call must include a complete briefing following the Monotask Task Brie
 - The specific goal for this domain
 - The project name and run context
 - Instruction to create monotask cards directly using `monotask card create $BOARD_ID $COL_TODO_ID "<title>" --json` for all sub-tasks
-- Instruction to use `Skill("mastermind-do")` to execute tasks (Task agents have Skill tool access — do NOT use slash command syntax)
+- Instruction to use `Skill("mastermind:do")` to execute tasks (Task agents have Skill tool access — do NOT use slash command syntax)
 - Instruction to spawn specialized agents using the domain-appropriate swarm topology
 - **For the `build` domain only:** instruct the manager: "Use `Skill("mastermind-execute")`. This was resolved in the Step 3.6 Plan Gate (or Step 5)." If `build_plan` is set in `current.json`, include the plan path and instruct the manager to execute THAT plan task-by-task rather than re-deriving tasks from the goal.
 - Instruction to return the unified output schema when done
@@ -797,11 +815,10 @@ Task({
     "1. Break this goal into discrete tasks using:\n" +
     "   monotask card create <board_build> <todo_col_build> '<title>' --json\n" +
     "   Each card description MUST include: context, goal, scope, constraints, success criteria, agent, dependencies.\n\n" +
-    "2. Spawn specialized agents for each task using the Task tool:\n" +
-    "   - Backend work: subagent_type 'backend-dev'\n" +
-    "   - Frontend work: subagent_type 'frontend-dev'\n" +
-    "   - Testing: subagent_type 'tester'\n" +
-    "   - Code review: subagent_type 'reviewer'\n" +
+    "2. Spawn specialized agents for each task using the Task tool. Pick each subagent_type with\n" +
+    "   mcp__monomind__pick({task: '<card title>', kind: 'agents', top: 1}) -> agents.ranked[0].name\n" +
+    "   (no MCP: monomind pick -t '<card title>' --top 1 --json, see mastermind-agent-select).\n" +
+    "   Fallbacks if picking returns nothing: implementation 'coder', testing 'tester', code review 'reviewer'\n" +
     "   Default swarm: hierarchical 6 agents raft\n\n" +
     "3. BEFORE spawning each agent, emit agent:spawn via curl (NOT WebFetch — use jq for correct ms timestamps):\n" +
     "   REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)\n" +
@@ -1088,7 +1105,7 @@ Log this as a decision in the cycle's output schema with `confidence` set accord
 
 #### 12c — Execute
 
-Execute the chosen activity by invoking the appropriate domain skill via the `Skill` tool (Steps 4–10 of the main flow, condensed). Use `Skill("mastermind-<domain>")` — do NOT use slash command syntax (`/<name>`), which only works when typed interactively in the Claude Code CLI, not within an executing command or skill:
+Execute the chosen activity by invoking the appropriate domain skill via the `Skill` tool (Steps 4–10 of the main flow, condensed). Use the domain's skill — `Skill("mastermind-<domain>")` for a skill package, `Skill("mastermind:<domain>")` for a command — do NOT use slash command syntax (`/<name>`), which only works when typed interactively in the Claude Code CLI, not within an executing command or skill:
 
 - Test → `Skill("mastermind-debug")` Phase 4 with the untested artifacts as prompt (write the failing test first, enforce Red-Green-Refactor)
 - Debug/Fix → `Skill("mastermind-debug")` with the failing test or error as prompt (root-cause first, then fix)
@@ -1096,7 +1113,7 @@ Execute the chosen activity by invoking the appropriate domain skill via the `Sk
 - Improve/Refactor → `Skill("mastermind-plan")` then `Skill("mastermind-execute")` with refactor prompt
 - Add feature → `Skill("mastermind-plan")` then `Skill("mastermind-execute")` with the next feature from the `next_actions` array printed by the Step 12a output above
 - Research → `Skill("mastermind-research")` with the open question as prompt
-- Content/Docs → `Skill("mastermind-content")` with scope = new artifacts
+- Content/Docs → `Skill("mastermind:content")` with scope = new artifacts
 - Release → `Skill("mastermind-release")` with project scope
 
 Always pass: the current brain_context, project_name (from the `project_name` field above), the relevant board_id, and mode = auto (iteration cycles never pause for confirmation).

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

@@ -130,11 +130,13 @@ mcp__monomind__monoswarm_shutdown({})
 | 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 |
+| Feature | coordinator, Software Architect, coder, tester, reviewer | hierarchical |
+| Refactor | coordinator, Software Architect, coder, reviewer | hierarchical |
+| Performance | coordinator, Performance Benchmarker, coder | hierarchical |
+| Security | coordinator, Security Engineer, reviewer | hierarchical |
+| Research | coordinator, researcher x4, scout-explorer x2 | mesh |
+
+These are real agent names (Task `subagent_type`). For a task-specific pick use the prompt's `[PICK]` line or `mcp__monomind__pick`.
 
 ## See Also
 

package/.claude/commands/mastermind/ops.md

@@ -16,8 +16,14 @@ Run intake if prompt is vague (follow mastermind-intake/SKILL.md — stop at Q3,
 
 Default mode for this command: **auto** (unless `--confirm` flag present or intake Q4 says confirm).
 
-Invoke `Skill("mastermind-ops")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+Pick the specialist (there is no `mastermind-ops` skill package — the work is done by a picked agent). In order, per `mastermind-agent-select/SKILL.md`:
+1. The prompt's `[PICK]` line, if it fits this ops task.
+2. `mcp__monomind__pick({ task: prompt, kind: "both", categories: ["specialized", "engineering", "core"], top: 3 })` — use `agents.ranked[0].name`; if `skills.ranked[0]` clearly fits, load it with its `invoke`.
+3. No MCP: the Standard Selection Block from `mastermind-agent-select/SKILL.md` with `CATEGORIES="specialized engineering core"`, `TOP_N=3`.
+4. Nothing returned: `Workflow Optimizer`.
 
-After skill returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.
+Spawn the picked agent via the Task tool, passing: brain_context, prompt, project_name, board_id (create if needed), mode — as a briefing that follows the Monotask Task Briefing Standard in `mastermind-protocol/SKILL.md` and includes the AGENT DELEGATION CAPABILITY block from `mastermind-delegation/SKILL.md`. In `confirm` mode, show the agent's plan or draft to the user before anything is published or sent.
+
+After the agent returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.
 
 Invoke `Skill("mastermind-repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/orgs.md

@@ -1,4 +1,4 @@
-<!-- List all saved orgs with their status, schedule interval, and last/next run times. Shows stopped/active/paused state for scheduled orgs. -->
+<!-- List all saved orgs with their runtime status, schedule, and last run time. Flags crashed runs and legacy-format config files. -->
 
 **If $ARGUMENTS is empty:** Execute the listing below directly.
 

package/.claude/commands/mastermind/orgstatus.md

@@ -1,4 +1,4 @@
-<!-- Show detailed status for a single org — lifecycle state, schedule, last/next run, recent activity, and roles. For scheduled orgs shows loop health. -->
+<!-- Show detailed status for a single org — runtime state, schedule, config health, pending approvals, recent activity, and roles. -->
 
 **If $ARGUMENTS is empty:** Output the following and wait.
 

package/.claude/commands/mastermind/runorg.md

@@ -1,4 +1,4 @@
-<!-- Start a saved org via the Org Runtime v2 daemon (monomind org run/serve). Validates the config, auto-migrates v1-shaped configs, starts the daemon, and confirms liveness. The legacy prompt-orchestrated path lives at /mastermind:runorgv1. -->
+<!-- Start a saved org via the Org Runtime daemon (monomind org run/serve). Validates the config, converts legacy-format config files, starts the daemon, and confirms liveness. -->
 
 **If $ARGUMENTS is empty:** Output the following and wait.
 
@@ -6,7 +6,7 @@
 
 **MASTERMIND: RUN ORG**
 
-Running an org starts it through the Org Runtime v2 daemon. Every role becomes
+Running an org starts it through the Org Runtime daemon. Every role becomes
 a live SDK session; the daemon forwards dashboard events itself — no boss
 agent, no monotask board, no manual curl emissions.
 

package/.claude/commands/mastermind/sales.md

@@ -16,8 +16,14 @@ Run intake if prompt is vague (follow mastermind-intake/SKILL.md — stop at Q3,
 
 Default mode for this command: **confirm** (unless `--auto` flag present or intake Q4 says auto).
 
-Invoke `Skill("mastermind-sales")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+Pick the specialist (there is no `mastermind-sales` skill package — the work is done by a picked agent). In order, per `mastermind-agent-select/SKILL.md`:
+1. The prompt's `[PICK]` line, if it fits this sales task.
+2. `mcp__monomind__pick({ task: prompt, kind: "both", categories: ["marketing", "specialized"], top: 3 })` — use `agents.ranked[0].name`; if `skills.ranked[0]` clearly fits, load it with its `invoke`.
+3. No MCP: the Standard Selection Block from `mastermind-agent-select/SKILL.md` with `CATEGORIES="marketing specialized"`, `TOP_N=3`.
+4. Nothing returned: `Email Marketing Specialist`.
 
-After skill returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `sales`.
+Spawn the picked agent via the Task tool, passing: brain_context, prompt, project_name, board_id (create if needed), mode — as a briefing that follows the Monotask Task Briefing Standard in `mastermind-protocol/SKILL.md` and includes the AGENT DELEGATION CAPABILITY block from `mastermind-delegation/SKILL.md`. In `confirm` mode, show the agent's plan or draft to the user before anything is published or sent.
+
+After the agent returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `sales`.
 
 Invoke `Skill("mastermind-repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.