@monoes/monomindcli 2.16.2 → 2.16.3

package/.claude/skills/mastermind-agent-select/SKILL.md

@@ -6,7 +6,19 @@ type: helper
 
 # Agent Selection from Registry
 
-Use this pattern whenever a mastermind skill needs to select specialist agents. The registry lives at `.monomind/registry.json` and contains all 257+ available agent types with their category labels.
+Use this pattern whenever a mastermind skill or command needs to select specialist agents. Never hardcode a roster: the agent set differs per install, and a `subagent_type` that is not installed fails at spawn time.
+
+## The pick order (always in this order)
+
+1. **`[PICK]` line.** When the user prompt carries a hook-injected line `[PICK] agent: <name> · skill: <invoke>`, use that agent/skill unless it is clearly wrong for the task.
+2. **MCP tool `mcp__monomind__pick`** (when the monomind MCP server is connected):
+   `mcp__monomind__pick({ task: "<task>", kind: "agents", categories: ["engineering"], top: 3 })`
+   → same JSON as `monomind pick --json`; each `agents.ranked[].name` is a spawnable `subagent_type`, and `summary` is a one-line recap. Use `kind: "skills"` or `"both"` for skills.
+3. **Local CLI `monomind pick`** — the Standard Selection Block below (local binary only, never npx).
+4. **Registry keyword scorer** — the fallback inside the same block, when no usable CLI is installed.
+5. **Fixed fallback defaults** (bottom of this file) — real agent names only.
+
+The shared index behind 2 and 3 ranks the agent registry (`.monomind/registry.json`, built from `.claude/agents/`) and every skill — Claude skills plus the Org skill library — in one call.
 
 ---
 
@@ -17,69 +29,57 @@ Use this pattern whenever a mastermind skill needs to select specialist agents.
 # Set these before the block:
 #   REGISTRY=".monomind/registry.json"
 #   PROMPT="<the user's prompt or idea description>"
-#   CATEGORIES="marketing strategy product"   # space-separated; adjust per domain
+#   CATEGORIES="marketing specialized"        # space-separated; see Category Map
 #   TOP_N=6                                   # how many agents to return
 
 REGISTRY="${REGISTRY:-.monomind/registry.json}"
 
-# 0. Decision model first. `monomind pick` asks Jev/OpenJev when configured
-#    (MONOMIND_JEV_URL, or TYPESAFE_API_KEY + MONOMIND_JEV_HOSTED=1) and
-#    otherwise ranks by keywords.
-# Local only — never npx (no registry egress). A globally installed monomind may
-# predate `pick`, so each candidate must prove it supports the command.
-mm() { for c in monomind ./node_modules/.bin/monomind; do
-         command -v "$c" >/dev/null 2>&1 || [ -x "$c" ] || continue
-         "$c" pick --help >/dev/null 2>&1 && { "$c" "$@"; return $?; }
-       done; return 127; }
-selected_agents=$(mm pick -t "$PROMPT" --agents --categories "$CATEGORIES" \
-  --top "$TOP_N" --json 2>/dev/null \
+# Local only — never npx (no registry egress). A candidate binary is accepted
+# only when its output is the unified index: every skill entry carries a
+# `source` field. Installs without `pick`, and pick builds that predate the
+# unified index, never emit it — so the call deliberately ranks skills too
+# (no --agents), and that output doubles as the version check.
+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; }
+
+selected_agents=$(mmpick -t "$PROMPT" --categories "$CATEGORIES" --top "$TOP_N" \
   | jq -c '[.agents.ranked[] | {name: (.name // .id), slug: .id, category}]' 2>/dev/null)
 
-# Fallback when the CLI is unavailable: the registry keyword scorer below.
-if [ -z "$selected_agents" ] || [ "$selected_agents" = "[]" ]; then
-
-# 1. Extract candidates from the registry filtered by category
-candidates=$(jq -r \
-  --arg cats "$CATEGORIES" \
-  '[ (.agents // [])[]
-     | select(.deprecated != true)
-     | select(
-         .category as $c |
-         ($cats | split(" ") | any(. == $c))
-       )
-     | {name: .name, slug: .slug, category: .category}
-   ] | unique_by(.slug) | .[]' \
-  "$REGISTRY")
-
-# 2. Score each candidate by keyword overlap with the prompt
-# Extract keywords from prompt (words ≥5 chars, lowercase)
-keywords=$(echo "$PROMPT" | tr '[:upper:]' '[:lower:]' | grep -oE '[a-z]{5,}' | sort -u | tr '\n' ' ')
-
-selected_agents=$(echo "$candidates" | jq -Rs \
-  --arg kw "$keywords" \
-  --argjson n "$TOP_N" \
-  '
-  [ split("\n")[] | select(length > 0) | fromjson ] |
-  map(
-    . as $agent |
-    ($kw | split(" ")) as $keywords |
-    ($agent.name | ascii_downcase) as $name |
-    ($agent.category | ascii_downcase) as $cat |
-    {
-      agent: $agent,
-      score: ([$keywords[] | if (($name | contains(.)) or ($cat | contains(.))) then 1 else 0 end] | add // 0)
-    }
-  ) |
-  sort_by(-.score) |
-  .[0:$n] |
-  map(.agent)
-  ')
+# Fallback when no usable CLI: score the registry against name + description +
+# capabilities + tags + whenToUse (keywords of 4+ letters from the prompt).
+if { [ -z "$selected_agents" ] || [ "$selected_agents" = "[]" ]; } && [ -f "$REGISTRY" ]; then
+  keywords=$(echo "$PROMPT" | tr '[:upper:]' '[:lower:]' | grep -oE '[a-z]{4,}' | sort -u | tr '\n' ' ')
+  selected_agents=$(jq -c \
+    --arg cats "$CATEGORIES" \
+    --arg kw "$keywords" \
+    --argjson n "$TOP_N" \
+    '($kw | split(" ") | map(select(length > 0))) as $keywords
+     | [ (.agents // [])[]
+         | select(.deprecated != true)
+         | select(($cats | length) == 0 or (.category as $c | $cats | split(" ") | any(. == $c)))
+         | . as $a
+         | ([ $a.name, $a.description, ($a.capabilities // [] | join(" ")),
+              ($a.tags // [] | join(" ")), ($a.whenToUse // "") ]
+            | map(. // "") | join(" ") | ascii_downcase) as $text
+         | {name: $a.name, slug: $a.slug, category: $a.category,
+            score: ([ $keywords[] | select(. as $k | $text | contains($k)) ] | length)}
+       ]
+     | unique_by(.slug)
+     | map(select(.score > 0))
+     | sort_by(-.score)
+     | .[0:$n]
+     | map({name, slug, category})' \
+    "$REGISTRY" 2>/dev/null)
 fi
 
-echo "$selected_agents"
+echo "${selected_agents:-[]}"
 ```
 
-The output is a JSON array of `{name, slug, category}` objects. Use `.name` as the `subagent_type` in Task calls, `.slug` for display.
+The output is a JSON array of `{name, slug, category}` objects. Use `.name` as the `subagent_type` in Task calls and `.slug` for display. An empty array means: use the fixed fallback defaults below.
 
 ---
 
@@ -87,74 +87,73 @@ The output is a JSON array of `{name, slug, category}` objects. Use `.name` as t
 
 | Domain / purpose | Categories to include |
 |---|---|
-| **Idea — user/market angles** | `marketing strategy product academic` |
-| **Idea — technical angles** | `engineering development architecture` |
-| **Idea — ops/business angles** | `sales strategy product project-management` |
-| **Build** | `engineering development architecture devops testing` |
-| **Marketing** | `marketing paid-media strategy` |
-| **Sales** | `sales strategy product` |
-| **Research** | `academic specialized strategy` |
-| **Content** | `marketing specialized` |
-| **Ops** | `project-management strategy support` |
-| **Release** | `devops github engineering` |
-| **Review** | `engineering testing analysis` |
-| **Finance** | `strategy specialized` |
+| **Idea — user/market angles** | `marketing specialized design testing` |
+| **Idea — technical angles** | `engineering architecture core specialized` |
+| **Build** | `core engineering architecture design specialized testing` |
+| **Marketing / Content / Sales** | `marketing specialized` |
+| **Research** | `core specialized specialists` |
+| **Release** | `github engineering` |
+| **Review** | `engineering testing core design specialized` |
+| **Ops / Finance** | `specialized engineering core` |
+| **Coordination** | `core monoswarm consensus` |
+
+Registry categories are the `.claude/agents/` folder names: `architecture consensus core design engineering github goal marketing monoswarm optimization specialists specialized templates testing`. Pass an empty `CATEGORIES` to rank every agent.
 
 ---
 
 ## Quick Pattern: pick ONE best agent for a specific task
 
+Prefer `mcp__monomind__pick({ task: "<task>", kind: "agents", top: 1 })` and use `agents.ranked[0].name`. Without MCP:
+
 ```bash
-# Pick the single best agent for a task description
 TASK_DESC="<one-line description of what this agent must do>"
-CATS="engineering development"
-
-# Local only — never npx (no registry egress). A globally installed monomind may
-# predate `pick`, so each candidate must prove it supports the command.
-mm() { for c in monomind ./node_modules/.bin/monomind; do
-         command -v "$c" >/dev/null 2>&1 || [ -x "$c" ] || continue
-         "$c" pick --help >/dev/null 2>&1 && { "$c" "$@"; return $?; }
-       done; return 127; }
-best_agent=$(mm pick -t "$TASK_DESC" --agents --categories "$CATS" --top 1 --json 2>/dev/null \
+CATS="engineering core"
+# mmpick() as defined in the Standard Selection Block
+best_agent=$(mmpick -t "$TASK_DESC" --categories "$CATS" --top 1 \
   | jq -r '.agents.ranked[0].name // .agents.ranked[0].id // empty' 2>/dev/null)
-
-if [ -z "$best_agent" ]; then
-best_agent=$(jq -r \
-  --arg cats "$CATS" \
-  --arg task "$(echo "$TASK_DESC" | tr '[:upper:]' '[:lower:]')" \
-  '[ (.agents // [])[]
-     | select(.deprecated != true)
-     | select(.category as $c | ($cats | split(" ") | any(. == $c)))
-     | {name: .name, slug: .slug,
-        score: (.name | ascii_downcase | if contains($task) then 2 else 0 end)}
-   ]
-   | sort_by(-.score)
-   | .[0].name // "coder"' \
-  "$REGISTRY")
-fi
+best_agent="${best_agent:-coder}"   # fixed fallback: a real core agent
 ```
 
 ---
 
 ## Fallback
 
-If the registry is missing or empty, fall back to these safe defaults per domain:
+If the pick tool, the CLI and the registry all come up empty, use these safe defaults per domain (all real agent names):
 
 | Domain | Fallback agents |
 |---|---|
-| idea specialists | `researcher`, `Trend Researcher`, `Growth Hacker` |
+| idea specialists | `researcher`, `Launch Strategist`, `CRO Specialist` |
 | dev decomp | `Software Architect` |
-| ops decomp | `Product Manager` |
+| ops decomp | `Launch Strategist` |
 | build | `coder`, `tester`, `reviewer` |
-| marketing | `Content Creator`, `SEO Specialist` |
-| sales | `Outbound Strategist`, `Deal Strategist` |
+| marketing / content / sales | `Competitive Content Strategist`, `Email Marketing Specialist`, `Launch Strategist` |
+| review | `reviewer`, `Security Engineer` |
+| research | `researcher` |
+| release | `release-manager` |
+| anything else | `general-purpose` |
+---
+
+## Skills from the same index
+
+Prefer `mcp__monomind__pick({ task: "<task>", kind: "skills", top: 3 })`. Without MCP:
+
+```bash
+# Best skills for a task: Claude skills (source "platform") and Org-library
+# skills (source "org") ranked together. `invoke` says how to load each one.
+mmpick -t "$PROMPT" --skills --top 3 | jq -c '[.skills.ranked[] | {id, source, invoke}]'
+```
+
+A `platform` skill loads with its `invoke` through the Skill tool (a `Skill(...)` call or a
+`/command`). An `org` skill's `invoke` is `mcp__monomind__org_skill_show {"name":"<name>"}`: call
+that MCP tool with that input to read it, or run `npx -y monomind org skills show <name>` when the
+tool is unavailable. An org skill can also be named in an org role's `skills` / `skill_pool`.
 
 ---
 
 ## Usage in a domain skill
 
-1. Set `REGISTRY`, `PROMPT`, `CATEGORIES`, `TOP_N`
-2. Run the Standard Selection Block
-3. Parse `selected_agents` JSON array
+1. If the prompt has a `[PICK]` line, start from it
+2. Else call `mcp__monomind__pick` with the task and the domain's categories
+3. Else set `REGISTRY`, `PROMPT`, `CATEGORIES`, `TOP_N` and run the Standard Selection Block
 4. Spawn Task agents using `.name` as `subagent_type`, one per entry
-5. If `selected_agents` is empty or registry missing: use the fallback list above
+5. If every step came back empty: use the fallback list above

package/.claude/skills/mastermind-agents/SKILL.md

@@ -3,11 +3,12 @@ name: mastermind-agents
 description: Mastermind agents — list, inspect, hire, pause, and remove agents in a running org. Shows status, last heartbeat, adapter config, and burn rate per agent.
 type: domain-skill
 default_mode: confirm
+pick: low
 ---
 
 # Mastermind Agents
 
-This skill is invoked by `mastermind:agents` or directly via `/mastermind:agents`.
+This skill is invoked by `mastermind:agents` or directly via `/mastermind-agents`.
 
 ---
 

package/.claude/skills/mastermind-approval-detail/SKILL.md

@@ -3,11 +3,12 @@ name: mastermind-approval-detail
 description: Mastermind approval-detail — deep inspection and action on a single approval request. View approval metadata, payload, comments, linked issues, and perform approve/reject/revision/resubmit actions. Mirrors ApprovalDetail.tsx.
 type: domain-skill
 default_mode: confirm
+pick: low
 ---
 
 # Mastermind Approval Detail
 
-This skill is invoked by `mastermind:approval-detail` or directly via `/mastermind:approval-detail`.
+This skill is invoked by `mastermind:approval-detail` or directly via `/mastermind-approval-detail`.
 
 ---
 

package/.claude/skills/mastermind-backup/SKILL.md

@@ -3,11 +3,12 @@ name: mastermind-backup
 description: Mastermind backup — create, list, and restore compressed org backups. Archives all org data files (config, goals, routines, approvals, projects, members, issues, workspaces, worktrees, environments, plugins, adapters, threads, budgets, bootstrap, and activity log) into a timestamped tarball.
 type: domain-skill
 default_mode: confirm
+pick: low
 ---
 
 # Mastermind Backup
 
-This skill is invoked by `mastermind:backup` or directly via `/mastermind:backup`.
+This skill is invoked by `mastermind:backup` or directly via `/mastermind-backup`.
 
 ---
 

package/.claude/skills/mastermind-bootstrap/SKILL.md

@@ -7,7 +7,7 @@ default_mode: confirm
 
 # Mastermind Bootstrap
 
-This skill is invoked by `mastermind:bootstrap` or directly via `/mastermind:bootstrap`.
+This skill is invoked by `mastermind:bootstrap` or directly via `/mastermind-bootstrap`.
 
 ---
 
@@ -54,7 +54,7 @@ if [ -f "$bootstrapFile" ]; then
     "  Token used:  \(.token_used // false)"
   ' "$bootstrapFile"
 else
-  echo "Not bootstrapped. Run /mastermind:bootstrap --org ${org_name} --action init"
+  echo "Not bootstrapped. Run /mastermind-bootstrap --org ${org_name} --action init"
 fi
 ```
 

package/.claude/skills/mastermind-budgets/SKILL.md

@@ -3,11 +3,12 @@ name: mastermind-budgets
 description: Mastermind budgets — view, set, and track token/cost budgets for agents and the entire org. Shows current spend vs. limits, alerts on overages, and lets board members adjust per-agent or org-wide budgets. Reads from -budgets.json org state files.
 type: domain-skill
 default_mode: auto
+pick: low
 ---
 
 # Mastermind Budgets
 
-This skill is invoked by `mastermind:budgets` or directly via `/mastermind:budgets`.
+This skill is invoked by `mastermind:budgets` or directly via `/mastermind-budgets`.
 
 ---
 
@@ -131,8 +132,8 @@ if not roles:
 PYEOF
 
 echo ""
-echo "  Set limit: /mastermind:budgets --org $org_name --action set --agent-id <id> --limit-usd 5.00"
-echo "  Reset:     /mastermind:budgets --org $org_name --action reset"
+echo "  Set limit: /mastermind-budgets --org $org_name --action set --agent-id <id> --limit-usd 5.00"
+echo "  Reset:     /mastermind-budgets --org $org_name --action reset"
 ```
 
 ### set

package/.claude/skills/mastermind-createorg/SKILL.md

@@ -73,14 +73,30 @@ A role is **persona-based** if its title is a named real person, a well-known fi
 
 Persona roles work the same as any other role in v2 — there is no separate `agent_type`/subagent registry to resolve against. Put the character depth directly into `responsibilities` (fed into the agent's role briefing by `buildRolePrompt` in `orgrt/session.ts`, alongside the role's `skills` and `instructions_file`, if set — see Step 2.3): write 3-6 specific, voice-defining responsibilities drawn from the character's known career, positions, and communication style, not generic duties. For a living public figure, base it on documented public behavior — do not invent positions they haven't taken.
 
+**Step 2.2b — Seed each non-persona role from the agent registry.**
+
+The project's agent registry (`.monomind/registry.json`, the `.claude/agents/**` personas) often already describes the job. For every role that is not persona-based, ask for the best-fitting registry agent with the role's title and a one-line summary of its job:
+
+```bash
+npx monomind pick -t "<role title>: <one-line summary of what it does>" --agents --top 1 --json \
+  | jq -r '.agents.ranked[0] // empty | "\(.id)\t\(.description)"'
+# Read that persona's body for concrete duties and practices:
+jq -r --arg s "<id from above>" '.agents[] | select(.slug == $s) | .filePath' .monomind/registry.json
+```
+
+(If the monomind MCP server in this session exposes an `mcp__monomind__pick` tool, it answers the same question; the CLI works everywhere.) When a hit genuinely fits, read its file and use it to write sharper `responsibilities` for the role — adapted to this org's goal, in your own words, never pasted wholesale; the org config has no field that links to the persona. When nothing is returned or the hit is a poor fit, write the responsibilities from the goal alone.
+
+Write `responsibilities` that tell roles apart: `org_task` with `assignee: "auto"` routes each task to the role whose title and responsibilities match it best (words every role shares count for nothing), so a role whose duties are only boilerplate never gets auto-assigned work.
+
 ---
 
 ## Step 2.3 — Skills (pick per role from the skill library)
 
-Every role can draw on the **org skill library**: ~380 curated skills (engineering practice, languages and frameworks, design, product, marketing, sales, finance, legal, ops, research) from monomind and MIT/Apache-2.0 open-source repos. Find candidates for each role by searching with its title and responsibilities:
+Every role can draw on the **org skill library**: ~380 curated skills (engineering practice, languages and frameworks, design, product, marketing, sales, finance, legal, ops, research) from monomind and MIT/Apache-2.0 open-source repos. For **each** role, search with its title plus its responsibilities (the ones written in Step 2.2b) and choose only from the hits — never invent a skill name, and never use slash-command names such as `mastermind:tasks`, which are not org skills:
 
 ```bash
-npx monomind org skills search "backend engineer API design postgres" --limit 8
+npx monomind org skills search "<role title> <responsibilities>" --limit 8 --format json \
+  | jq -r '.skills[] | "\(.name)\t\(.description)"'
 npx monomind org skills search "landing page conversion copy" --tag marketing
 npx monomind org skills show <name>   # read one before choosing it
 ```
@@ -92,7 +108,9 @@ Give each role two fields:
 
 Match skills to the work, not to a vague fit: a copywriter gets marketing/writing skills, never code skills. **Tools follow skills automatically** — a skill that declares monomind tools (`monograph_*` for code roles, `monodesign_*` for UI roles) gives its role exactly those tools, so only roles that work on software get the code graph and only UI roles get design tooling. For roles that write or review code, include `monograph-code-navigation` (and `monolean-minimal-change` for implementers); for roles that build or review web UI, include `monodesign-ui-quality`.
 
-`ui.icon` is only the role's picture on the canvas — it has no effect on the prompt. Leave `skills` off when nothing in the library fits cleanly; `responsibilities` alone is a complete role. `org validate` fails on an unknown skill name.
+At run time each task dispatch names the `skill_pool` skills that fit that task, and a role can look beyond its pool with `org_skill_search` (loading stays limited to its own `skills`/`skill_pool`), so a well-chosen pool matters more than a long pinned list.
+
+`ui.icon` is only the role's picture on the canvas — it has no effect on the prompt. Leave `skills` off when nothing in the library fits cleanly; `responsibilities` alone is a complete role. `org validate` fails on an unknown skill name, so the Step 5 validation is what proves every chosen name is real — fix and re-save until it passes.
 
 ---
 
@@ -304,7 +322,7 @@ next_actions:
   - "After hand-editing the config, re-check it with `monomind org validate <org_name>`"
   - "While running: `monomind org logs <org_name> --follow`; afterwards: `monomind org report <org_name>` for outcome, per-role activity, and token usage"
   - "Or `monomind org serve` to host it (and any other scheduled orgs) as a background daemon"
-  - "Edit .monomind/orgs/<org_name>.json directly, or use /mastermind:org-settings, to change goal/budget/roles"
+  - "Edit .monomind/orgs/<org_name>.json directly, or use /mastermind-org-settings, to change goal/budget/roles"
   - "`monomind org status <org_name>` to check runtime state; `monomind org stop <org_name>` to stop a running org"
 ```
 
@@ -325,7 +343,7 @@ In **auto** mode (where Step 4's plan/model confirmation was skipped), always al
     boss                claude-sonnet-5
     content-writer      claude-sonnet-5
     content-reviewer    claude-sonnet-5
-  Adjust with: /mastermind:org-settings, or edit .monomind/orgs/<org_name>.json directly
+  Adjust with: /mastermind-org-settings, or edit .monomind/orgs/<org_name>.json directly
 ```
 In **confirm** mode this table was already shown and accepted in Step 4 — do not repeat it here.
 

package/.claude/skills/mastermind-delegation/SKILL.md

@@ -26,24 +26,16 @@ 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 (use the exact slug or name — all of these exist on disk):
-
-  CORE      coder · reviewer · tester · planner · researcher
-  BACKEND   Backend Architect · Database Optimizer · API Tester
-  FRONTEND  Frontend Developer · mobile-dev · Mobile App Builder
-  ARCH      Software Architect · system-architect · Backend Architect
-  SECURITY  Security Engineer · Compliance Auditor · Blockchain Security Auditor · Threat Detection Engineer
-  AI/ML     AI Engineer · Data Engineer · AI Data Remediation Engineer · Model QA Specialist
-  DEVOPS    DevOps Automator · SRE (Site Reliability Engineer) · Git Workflow Master · Incident Response Commander
-  DOCS      Technical Writer
-  MARKETING Competitive Content Strategist · CRO Specialist · Email Marketing Specialist · Launch Strategist · Pricing Strategist
-  SPECIALIZED  MCP Builder · Document Generator · LSP/Index Engineer · Embedded Firmware Engineer · Solidity Smart Contract Engineer
-  GITHUB    pr-manager · issue-tracker · code-review-swarm · release-manager
-  DESIGN    Monodesign (UI/UX · brand · CSS · animation · design systems)
-  SWARM     mesh-coordinator · coordinator · Agents Orchestrator
-
-The authoritative list is the filesystem — run `ls .claude/agents/` for the full
-~98-agent set. Do NOT invent agent names; only delegate to agents that exist.
+To choose the subagent_type for a subtask, in this order:
+  1. The prompt's [PICK] line (`[PICK] agent: <name> · skill: <invoke>`),
+     unless it is clearly wrong for the subtask.
+  2. mcp__monomind__pick({ task: "<subtask>", kind: "agents", top: 3 })
+     -> use an agents.ranked[].name.
+  3. No MCP: monomind pick -t "<subtask>" --top 3 --json | jq -r '.agents.ranked[].name'
+     (local binary only, never npx).
+  4. Nothing returned: coder (implementation) · tester · reviewer ·
+     researcher · planner · general-purpose.
+Picked names always exist on disk. Do NOT invent agent names.
 
 WHEN to delegate:
 - A subtask needs deeper expertise than your primary role
@@ -52,7 +44,7 @@ WHEN to delegate:
 
 HOW to delegate:
   Agent({
-    subagent_type: "agent-slug",
+    subagent_type: "Agent Name",   // a name returned by the pick
     description: "Short task label",
     prompt: `Full self-contained briefing — treat every sub-agent as cold-start.
              Include: context, scope, success criteria, and this AGENT DELEGATION

package/.claude/skills/mastermind-diagnose/SKILL.md

@@ -7,7 +7,7 @@ default_mode: confirm
 
 # Mastermind Diagnose
 
-This skill is invoked by `mastermind:diagnose` or directly via `/mastermind:diagnose`.
+This skill is invoked by `mastermind:diagnose` or directly via `/mastermind-diagnose`.
 
 ---
 
@@ -148,7 +148,7 @@ else
 fi
 
 echo ""
-echo "  For deep diagnosis: /mastermind:diagnose --org $org_name --action diagnose --issue-id <id>"
+echo "  For deep diagnosis: /mastermind-diagnose --org $org_name --action diagnose --issue-id <id>"
 ```
 
 ### diagnose
@@ -224,7 +224,7 @@ echo "  1. Productive work continues:  [check heartbeats + open issues]"
 echo "  2. Only real blockers stop:    [check stall candidates above]"
 echo "  3. No infinite loops:          [check activity log for repeat patterns]"
 echo ""
-echo "  Run scan first: /mastermind:diagnose --org $org_name --action scan"
+echo "  Run scan first: /mastermind-diagnose --org $org_name --action scan"
 ```
 
 ---

package/.claude/skills/mastermind-env/SKILL.md

@@ -3,11 +3,12 @@ name: mastermind-env
 description: Mastermind env — audit and configure the runtime environment for an org. Shows LLM provider config, memory backend, agent JWT settings, logging, and storage — highlighting missing or misconfigured values.
 type: domain-skill
 default_mode: auto
+pick: low
 ---
 
 # Mastermind Env
 
-This skill is invoked by `mastermind:env` or directly via `/mastermind:env`.
+This skill is invoked by `mastermind:env` or directly via `/mastermind-env`.
 
 ---
 

package/.claude/skills/mastermind-environments/SKILL.md

@@ -3,11 +3,12 @@ name: mastermind-environments
 description: Mastermind environments — manage execution environments (local, SSH, sandbox) for an org. Controls where agent workloads run, SSH connection details, and which environment is the default.
 type: domain-skill
 default_mode: confirm
+pick: low
 ---
 
 # Mastermind Environments
 
-This skill is invoked by `mastermind:environments` or directly via `/mastermind:environments`.
+This skill is invoked by `mastermind:environments` or directly via `/mastermind-environments`.
 
 ---
 

package/.claude/skills/mastermind-execute/SKILL.md

@@ -53,7 +53,7 @@ For each task in the plan:
 
 ```javascript
 Task({
-  subagent_type: "coder", // pick per task, per the plan's agent recommendation
+  subagent_type: "coder", // the plan's agent recommendation if installed, else the [PICK] line, else mcp__monomind__pick({task: "<task title>", kind: "agents", top: 1}).agents.ranked[0].name (no MCP: mmpick from mastermind-agent-select), else "coder"
   description: "<task title from plan>",
   run_in_background: false, // true only when running independently alongside other parallel tasks
   prompt: `You are executing one task from an implementation plan for project "${project_name}".

package/.claude/skills/mastermind-export/SKILL.md

@@ -3,11 +3,12 @@ name: mastermind-export
 description: Mastermind export — full org portability. Export an org to a compressed archive (tar.gz or zip) with file tree selection, and import from an archive with collision strategy and adapter override. Mirrors Paperclip's CompanyExport/CompanyImport pages.
 type: domain-skill
 default_mode: confirm
+pick: low
 ---
 
 # Mastermind Export
 
-This skill is invoked by `mastermind:export` or directly via `/mastermind:export`.
+This skill is invoked by `mastermind:export` or directly via `/mastermind-export`.
 
 ---
 

package/.claude/skills/mastermind-goal-detail/SKILL.md

@@ -3,11 +3,12 @@ name: mastermind-goal-detail
 description: Mastermind goal-detail — deep per-goal inspection and management. Show sub-goal tree, linked projects, edit title/status/description/priority, add child goals, and close or reopen a single goal within an org.
 type: domain-skill
 default_mode: auto
+pick: low
 ---
 
 # Mastermind Goal Detail
 
-This skill is invoked by `mastermind:goal-detail` or directly via `/mastermind:goal-detail`.
+This skill is invoked by `mastermind:goal-detail` or directly via `/mastermind-goal-detail`.
 
 ---
 
@@ -51,7 +52,7 @@ orgFile=".monomind/orgs/${org_name}.json"
 [ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
 
 goalsFile=".monomind/orgs/${org_name}-goals.json"
-[ ! -f "$goalsFile" ] && { echo "ERROR: No goals file for org '$org_name'. Create goals via /mastermind:goals."; exit 1; }
+[ ! -f "$goalsFile" ] && { echo "ERROR: No goals file for org '$org_name'. Create goals via /mastermind-goals."; exit 1; }
 
 goalDef=$(jq -r --arg id "$goal_id" '(.goals // [])[] | select(.id == $id or .slug == $id)' "$goalsFile")
 [ -z "$goalDef" ] && { echo "ERROR: Goal '$goal_id' not found in org '$org_name'."; exit 1; }

package/.claude/skills/mastermind-goals/SKILL.md

@@ -3,11 +3,12 @@ name: mastermind-goals
 description: Mastermind goals — define, track, and visualize hierarchical goals for an org. Goals link to tasks, have progress metrics, and form a goal tree.
 type: domain-skill
 default_mode: confirm
+pick: low
 ---
 
 # Mastermind Goals
 
-This skill is invoked by `mastermind:goals` or directly via `/mastermind:goals`.
+This skill is invoked by `mastermind:goals` or directly via `/mastermind-goals`.
 
 ---
 
@@ -140,7 +141,7 @@ goal_id: <goal_id if applicable>
 goals_file: .monomind/orgs/<org_name>-goals.json
 ```
 
-Suggest next: "Link tasks to this goal with /mastermind:tasks link or /mastermind:goals link --goal-id <id> --task-id <card_id>"
+Suggest next: "Link tasks to this goal with /mastermind-tasks link or /mastermind-goals link --goal-id <id> --task-id <card_id>"
 
 ---