@monoes/monomindcli 2.16.2 → 2.16.4

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

@@ -1,13 +1,14 @@
 ---
 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.
+description: Mastermind agents — list, inspect, hire, and remove agents in an org, and pause or resume the org. Shows each role, its adapter config, and the org's live runtime status.
 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`.
 
 ---
 
@@ -43,23 +44,18 @@ If no orgs exist, print: "No orgs found. Run /mastermind:createorg to define one
 
 ### list (default)
 
-Display all agents in the org with status from state file:
+Display all agents in the org, then the org's live runtime status:
 
 ```bash
 orgFile=".monomind/orgs/${org_name}.json"
-stateFile=".monomind/orgs/${org_name}-state.json"
-
-jq -r '(.roles // [])[] | "• [\(.id)] \(.title)  agent=\(.agent_type)  reports_to=\(.reports_to // "none")"' "$orgFile"
-
-# LEGACY-ORG-V1: the state file's per-agent heartbeat tracking is a v1 concept —
-# v2 orgs report live status via `monomind org status`/`org report` instead.
-# Overlay runtime status from state file if present
-if [ -f "$stateFile" ]; then
-  echo ""
-  echo "RUNTIME STATUS:"
-  jq -r '.agents // {} | to_entries[] | "  \(.key): \(.value.status // "unknown")  last_beat=\(.value.last_heartbeat // "never")"' "$stateFile" 2>/dev/null || true
-fi
-# end LEGACY-ORG-V1
+
+jq -r '(.roles // [])[] | "• [\(.id)] \(.title)  type=\(.type // "specialist")  reports_to=\(.reports_to // "none")"' "$orgFile"
+
+# Live runtime status (running/stopped/crashed, current run) — per-role
+# activity for a run is in `monomind org report <org>`.
+echo ""
+echo "RUNTIME STATUS:"
+npx -y monomind@latest org status "$org_name" 2>/dev/null || echo "  (not available — is monomind installed?)"
 ```
 
 Render as table:
@@ -67,26 +63,28 @@ Render as table:
 ```
 AGENTS — org: <org_name>
 ──────────────────────────────────────────────────────
-ID              TITLE              AGENT TYPE          STATUS        LAST HEARTBEAT
-boss            CEO / Boss         coordinator         running       2 min ago
-content-writer  Content Writer     Content Creator     idle          8 min ago
-reviewer        Content Reviewer   reviewer            waiting       8 min ago
+ID              TITLE              TYPE                REPORTS TO
+boss            CEO / Boss         boss                none
+content-writer  Content Writer     specialist          boss
+reviewer        Content Reviewer   reviewer            boss
 ...
 ```
 
 ### inspect
 
-Show full config + responsibilities + communication edges for a single agent:
+Show the full role config (responsibilities, adapter config) and who it reports to / who reports to it:
 
 ```bash
 jq --arg id "$agent_id" '(.roles // [])[] | select(.id == $id)' "$orgFile"
-jq --arg id "$agent_id" '(.communication // [])[] | select(.from == $id or .to == $id)' "$orgFile"
+jq -r --arg id "$agent_id" '(.roles // [])[] | select(.reports_to == $id) | "  direct report: \(.id)"' "$orgFile"
 ```
 
 ### hire
 
 Add a new role to the org. Prompt the user for:
-- `id` (slug, e.g. `seo-lead`), `title` (display name), `agent_type` (from mapping table in createorg.md), `responsibilities` (comma-separated), `reports_to` (role id or null)
+- `id` (slug, e.g. `seo-lead`), `title` (display name), `role_type` → the role's `type` (`specialist`, or a domain synonym such as `reviewer` / `researcher` — free text; only `boss` is special, and an org has exactly one root), `responsibilities` (comma-separated), `reports_to` (an existing role id — a hired role is never the root)
+
+Write the Org Runtime role shape (`RoleSchema` in `packages/@monomind/cli/src/orgrt/types.ts`): `type`, never the legacy `agent_type` key — a role carrying `agent_type` makes the whole config read as the retired v1 format.
 
 **Adapter/model selection** — present this picker:
 
@@ -113,33 +111,29 @@ adapter_model="${selected_model:-claude-sonnet-5}"
 tmp="${orgFile}.tmp"
 jq --arg id "$agent_id" \
    --arg title "$title" \
-   --arg agent_type "$agent_type" \
-   --arg reports_to "${reports_to:-}" \
+   --arg type "${role_type:-specialist}" \
+   --arg reports_to "$reports_to" \
    --arg model "$adapter_model" \
    --argjson resp "$(echo "$responsibilities" | jq -R 'split(",") | map(ltrimstr(" "))')" \
-   '.roles += [{"id":$id,"title":$title,"agent_type":$agent_type,
+   '.roles += [{"id":$id,"title":$title,"type":$type,
      "responsibilities":$resp,
-     "reports_to":($reports_to|if .=="" then null else . end),
+     "reports_to":$reports_to,
      "adapter_config":{"model":$model,"max_tokens":8192}}]' \
    "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
-echo "Hired: $title ($agent_type) → adapter: $adapter_model"
+echo "Hired: $title (${role_type:-specialist}) → adapter: $adapter_model"
+npx -y monomind@latest org validate "$org_name"
 ```
 
 ### pause / resume
 
-<!-- LEGACY-ORG-V1: the agent state/heartbeat file this pauses is a v1 concept. -->
-Update state file:
+The Org Runtime pauses and resumes a whole org, not a single role — message
+delivery is suspended while it is paused:
 
 ```bash
-stateFile=".monomind/orgs/${org_name}-state.json"
-[ ! -f "$stateFile" ] && echo '{"agents":{}}' > "$stateFile"
-tmp="${stateFile}.tmp"
-jq --arg id "$agent_id" --arg status "paused" \
-  '.agents[$id].status = $status | .agents[$id].updated_at = (now|todate)' \
-  "$stateFile" > "$tmp" && mv "$tmp" "$stateFile"
+npx -y monomind@latest org pause "$org_name"    # or: org resume "$org_name"
 ```
 
-Emit `org:agent:paused` / `org:agent:resumed` event.
+To take one role out of the org, use `remove`.
 
 ### remove
 
@@ -147,7 +141,7 @@ Confirm with user, then remove role from org config:
 
 ```bash
 tmp="${orgFile}.tmp"
-jq --arg id "$agent_id" '.roles = [(.roles // [])[] | select(.id != $id)] | .communication = [(.communication // [])[] | select(.from != $id and .to != $id)]' \
+jq --arg id "$agent_id" '.roles = [(.roles // [])[] | select(.id != $id)]' \
   "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
 ```
 
@@ -163,7 +157,7 @@ org: <org_name>
 agents_count: <N>
 ```
 
-Print summary and any suggested next actions (e.g. "Run /mastermind:heartbeatv1 to trigger a manual heartbeat for this agent").
+Print summary and any suggested next actions (e.g. "Check live status with `monomind org status <org_name>`").
 
 ---
 

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

@@ -1,6 +1,6 @@
 ---
 name: mastermind-createorg
-description: Mastermind createorg — design and persist an autonomous agent organization (Org Runtime v2) as a `.monomind/orgs/<name>.json` config that `monomind org run/serve` loads directly. Supports optional --schedule flag for daemon-scheduled orgs.
+description: Mastermind createorg — design and persist an autonomous agent organization (Org Runtime) as a `.monomind/orgs/<name>.json` config that `monomind org run/serve` loads directly. Supports optional --schedule flag for daemon-scheduled orgs.
 type: domain-skill
 default_mode: confirm
 ---
@@ -9,7 +9,7 @@ default_mode: confirm
 
 This skill is invoked by `mastermind:createorg` or directly via `/mastermind:createorg`.
 
-Org Runtime v2 (`packages/@monomind/cli/src/orgrt/`) is a Node daemon, not a Task-tool-spawned boss agent. Every role in the config becomes a live SDK agent session (`@anthropic-ai/claude-agent-sdk` `query()`) the moment the org starts — there is no task board, no per-role generated `.claude/agents/*.md` file, and no communication-topology array. Roles address each other directly with the `org_send` tool using their `id` (or `<org>:<id>` cross-org). This skill's only job is to produce a config that validates against `OrgDefSchema` (`packages/@monomind/cli/src/orgrt/types.ts`).
+The Org Runtime (`packages/@monomind/cli/src/orgrt/`) is a Node daemon, not a Task-tool-spawned boss agent. Every role in the config becomes a live SDK agent session (`@anthropic-ai/claude-agent-sdk` `query()`) the moment the org starts — there is no task board, no per-role generated `.claude/agents/*.md` file, and no communication-topology array. Roles address each other directly with the `org_send` tool using their `id` (or `<org>:<id>` cross-org). This skill's only job is to produce a config that validates against `OrgDefSchema` (`packages/@monomind/cli/src/orgrt/types.ts`).
 
 ---
 
@@ -71,16 +71,32 @@ Exactly one role must have `reports_to: null`. If the user's role list has none,
 
 A role is **persona-based** if its title is a named real person, a well-known fictional character, or a celebrity/historical figure referred to by name. An org is persona-based if ≥50% of its roles are character names, or the goal/prompt contains `panel`, `debate`, `simulation`, `roleplay`, `celebrity`, `character`, `virtual [name]`, `impersonate`, `as [name]`.
 
-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.
+Persona roles work the same as any other role — 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