@monoes/monomindcli 2.16.3 → 2.16.5

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

@@ -1,6 +1,6 @@
 ---
 name: mastermind-agent-detail
-description: Mastermind agent-detail — deep per-agent inspection: show config, run history, budget usage, heartbeat status, assigned skills, and reset/reconfigure a single agent within an org.
+description: "Mastermind agent-detail — deep per-agent inspection: show config, run history, budget usage, heartbeat status, assigned skills, and reset/reconfigure a single agent within an org."
 type: domain-skill
 default_mode: auto
 pick: low

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

@@ -108,7 +108,14 @@ Prefer `mcp__monomind__pick({ task: "<task>", kind: "agents", top: 1 })` and use
 ```bash
 TASK_DESC="<one-line description of what this agent must do>"
 CATS="engineering core"
-# mmpick() as defined in the Standard Selection Block
+# 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; }
 best_agent=$(mmpick -t "$TASK_DESC" --categories "$CATS" --top 1 \
   | jq -r '.agents.ranked[0].name // .agents.ranked[0].id // empty' 2>/dev/null)
 best_agent="${best_agent:-coder}"   # fixed fallback: a real core agent
@@ -140,6 +147,14 @@ Prefer `mcp__monomind__pick({ task: "<task>", kind: "skills", top: 3 })`. Withou
 ```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.
+# Local only — never npx. Accept a binary only when its pick output is the
+# unified index (skill entries carry `source`).
+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; }
 mmpick -t "$PROMPT" --skills --top 3 | jq -c '[.skills.ranked[] | {id, source, invoke}]'
 ```
 

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

@@ -1,6 +1,6 @@
 ---
 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
@@ -44,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:
@@ -68,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:
 
@@ -114,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
 
@@ -148,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"
 ```
 
@@ -164,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-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,7 +71,7 @@ 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.**
 

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

@@ -82,18 +82,6 @@ echo "  namespace: org:${org_name}"
 npx monomind@latest memory list --namespace "org:${org_name}" 2>/dev/null | wc -l | xargs echo "  stored entries:"
 echo ""
 
-# LEGACY-ORG-V1: board_id/*_col_id only exist on the pre-v2 board-backed org shape
-# Board config
-echo "TASK BOARD"
-echo "──────────"
-board_id=$(jq -r '.board_id // "NOT CONFIGURED"' "$orgFile")
-echo "  board_id:    $board_id"
-echo "  todo_col:    $(jq -r '.todo_col_id // "NOT CONFIGURED"' "$orgFile")"
-echo "  doing_col:   $(jq -r '.doing_col_id // "NOT CONFIGURED"' "$orgFile")"
-echo "  done_col:    $(jq -r '.done_col_id // "NOT CONFIGURED"' "$orgFile")"
-echo ""
-# end LEGACY-ORG-V1 board block
-
 # Run config
 echo "RUN CONFIG"
 echo "──────────"
@@ -132,12 +120,10 @@ for key in ANTHROPIC_API_KEY; do
   fi
 done
 
-# LEGACY-ORG-V1: board_id belongs to the legacy v1 runner — see runorgv1. Org
-# Runtime v2 configs have no board_id at all, so this check only applies to
-# orgs still running the v1 board-backed shape.
-board_id=$(jq -r '.board_id // empty' "$orgFile")
-[ -z "$board_id" ] && { echo "  ✗ MISSING: board_id — boards belong to the legacy v1 runner, see runorgv1"; errors=$((errors + 1)); } || echo "  ✓ board_id"
-# end LEGACY-ORG-V1
+# Check the config against the runtime schema and structural invariants
+npx -y monomind@latest org validate "$org_name" >/dev/null 2>&1 \
+  && echo "  ✓ config valid (monomind org validate)" \
+  || { echo "  ✗ INVALID config — run: monomind org validate $org_name"; errors=$((errors + 1)); }
 
 # Check roles
 role_count=$(jq '.roles | length' "$orgFile")

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

@@ -1,6 +1,6 @@
 ---
 name: mastermind-inbox
-description: Mastermind inbox — unified view of everything that needs human attention across all orgs: pending approvals, running heartbeats, active task assignments, and budget alerts. The single place to check before starting work.
+description: "Mastermind inbox — unified view of everything that needs human attention across all orgs: pending tool approvals, running orgs, active task assignments, and budget alerts. The single place to check before starting work."
 type: domain-skill
 default_mode: auto
 pick: low
@@ -53,25 +53,20 @@ total_alerts=0
 for org in $orgs; do
   orgFile=".monomind/orgs/${org}.json"
   stateFile=".monomind/orgs/${org}-state.json"
-  approvalsFile=".monomind/orgs/${org}-approvals.json"
+  approvalsFile=".monomind/orgs/${org}/approvals.json"
+  rtFile=".monomind/orgs/${org}/runtime.json"
 
-  # LEGACY-ORG-V1: approvals files only exist for the v1 prompt-orchestrated
-  # runner — see runorgv1 / approvev1.
-  # 1. Pending approvals
+  # 1. Pending tool approvals (the runtime's queue — `monomind org approvals <org>`)
   if [ -f "$approvalsFile" ]; then
-    pending=$(jq '[(.approvals // [])[] | select(.status == "pending")] | length' "$approvalsFile" 2>/dev/null || echo 0)
+    pending=$(jq '[(.approvals // [])[] | select(.approved == null)] | length' "$approvalsFile" 2>/dev/null || echo 0)
     total_approvals=$((total_approvals + pending))
   fi
-  # end LEGACY-ORG-V1
-
-  # LEGACY-ORG-V1: state-file "heartbeats" are the v1 scheduler's running-agent
-  # tracking — v2 runs live under .monomind/orgs/<name>/run-*/bus.jsonl instead.
-  # 2. Running agents (active heartbeats)
-  if [ -f "$stateFile" ]; then
-    running=$(jq '[.agents // {} | to_entries[] | select(.value.status == "running")] | length' "$stateFile" 2>/dev/null || echo 0)
-    total_heartbeats=$((total_heartbeats + running))
+
+  # 2. Running orgs (runtime.json status "running" with a live pid)
+  rt_pid=$(jq -r 'if .status == "running" then (.pid // 0) else 0 end' "$rtFile" 2>/dev/null || echo 0)
+  if [ "$rt_pid" -gt 0 ] && kill -0 "$rt_pid" 2>/dev/null; then
+    total_heartbeats=$((total_heartbeats + 1))
   fi
-  # end LEGACY-ORG-V1
 
   # 3. Budget alerts
   budget=$(jq -r '.run_config.budget_tokens // 0' "$orgFile" 2>/dev/null || echo 0)
@@ -97,36 +92,32 @@ echo "║  MASTERMIND INBOX                                    ║"
 echo "╚══════════════════════════════════════════════════════╝"
 echo ""
 echo "  🔴 APPROVALS NEEDED:   $total_approvals"
-echo "  🟡 AGENTS RUNNING:     $total_heartbeats"
+echo "  🟡 ORGS RUNNING:       $total_heartbeats"
 echo "  🟠 BUDGET ALERTS:      $total_alerts"
 echo ""
 
 for org in $orgs; do
   orgFile=".monomind/orgs/${org}.json"
   stateFile=".monomind/orgs/${org}-state.json"
-  approvalsFile=".monomind/orgs/${org}-approvals.json"
+  approvalsFile=".monomind/orgs/${org}/approvals.json"
+  rtFile=".monomind/orgs/${org}/runtime.json"
 
   has_items=0
 
-  # LEGACY-ORG-V1: approvals belong to the v1 prompt-orchestrated runner
-  # Pending approvals
+  # Pending tool approvals
   if [ -f "$approvalsFile" ]; then
-    pending_approvals=$(jq -r '(.approvals // [])[] | select(.status == "pending") | "  [APPROVAL] [\(.id)] \(.agent_id): \(.title)  risk=\(.risk_level // "low")"' \
+    pending_approvals=$(jq -r '(.approvals // [])[] | select(.approved == null) | "  [APPROVAL] \(.roleId): \(.action)\(if .requestId then "  [\(.requestId)]" else "" end)"' \
       "$approvalsFile" 2>/dev/null)
     [ -n "$pending_approvals" ] && { has_items=1; echo "ORG: $org"; echo "$pending_approvals"; }
   fi
-  # end LEGACY-ORG-V1
-
-  # LEGACY-ORG-V1: state-file heartbeats are the v1 scheduler's tracking
-  # Running agents
-  if [ -f "$stateFile" ]; then
-    running_agents=$(jq -r '
-      .agents // {} | to_entries[] | select(.value.status == "running") |
-      "  [RUNNING]  [\(.key)]  since=\(.value.last_heartbeat // "unknown")"
-    ' "$stateFile" 2>/dev/null)
-    [ -n "$running_agents" ] && { has_items=1; [ $has_items -eq 1 ] || echo "ORG: $org"; echo "$running_agents"; }
+
+  # Running org
+  rt_pid=$(jq -r 'if .status == "running" then (.pid // 0) else 0 end' "$rtFile" 2>/dev/null || echo 0)
+  if [ "$rt_pid" -gt 0 ] && kill -0 "$rt_pid" 2>/dev/null; then
+    [ $has_items -eq 1 ] || echo "ORG: $org"
+    has_items=1
+    echo "  [RUNNING]  run=$(jq -r '.run // "?"' "$rtFile")  since=$(jq -r '.updated // "unknown"' "$rtFile")"
   fi
-  # end LEGACY-ORG-V1
 
   [ $has_items -eq 1 ] && echo ""
 done
@@ -138,34 +129,21 @@ fi
 
 ### filter: approvals only
 
-<!-- LEGACY-ORG-V1: approvals belong to the v1 prompt-orchestrated runner — see runorgv1 / approvev1. -->
 ```bash
 for org in $orgs; do
-  approvalsFile=".monomind/orgs/${org}-approvals.json"
-  [ -f "$approvalsFile" ] || continue
+  [ -f ".monomind/orgs/${org}/approvals.json" ] || continue
   echo "=== $org ==="
-  jq -r '(.approvals // [])[] | select(.status == "pending") |
-    "[\(.id)] \(.agent_id): \(.title)\n  Action: \(.action)\n  Risk: \(.risk_level // "low")\n  → /mastermind:approvev1 --org '"$org"' --action approve --approval-id \(.id)"
-  ' "$approvalsFile" 2>/dev/null || echo "  No pending approvals."
+  npx -y monomind@latest org approvals "$org"
   echo ""
 done
 ```
 
 ### filter: heartbeats only
 
-<!-- LEGACY-ORG-V1: state-file heartbeats are the v1 scheduler's running-agent tracking. -->
-Show currently running agent heartbeats across all orgs:
+Show the orgs that are running now:
 
 ```bash
-for org in $orgs; do
-  stateFile=".monomind/orgs/${org}-state.json"
-  [ -f "$stateFile" ] || continue
-  running=$(jq -r '
-    .agents // {} | to_entries[] | select(.value.status == "running") |
-    "  [\(.key)] since=\(.value.last_heartbeat // "?")"
-  ' "$stateFile" 2>/dev/null)
-  [ -n "$running" ] && { echo "=== $org ==="; echo "$running"; echo ""; }
-done
+npx -y monomind@latest org status
 ```
 
 ### filter: alerts only
@@ -193,11 +171,12 @@ done
 From the inbox, the user can directly:
 
 ```bash
-# Approve a pending request:
-/mastermind:approvev1 --org <org> --action approve --approval-id <id>
+# Approve or deny a pending tool request:
+monomind org approve <org> <role> "<action>"
+monomind org deny <org> <role> "<action>"
 
-# Stop a running agent:
-/mastermind-agents --org <org> --action pause --agent-id <id>
+# Stop a running org:
+monomind org stop <org>
 
 # Check costs:
 /mastermind:costs --org <org> --action report

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

@@ -85,8 +85,9 @@ echo "  Active orgs: $orgs"
 
 ### heartbeats
 
-<!-- LEGACY-ORG-V1: role-level heartbeat scheduling is a v1 org concept — v2 orgs run on `schedule` via the daemon instead. -->
-List all agents across all orgs that have scheduled heartbeats:
+The Org Runtime does not read role-level `heartbeat` fields — orgs run on their
+top-level `schedule` under `monomind org serve`. This lists any role `heartbeat`
+fields still present in org config files:
 
 ```bash
 echo "SCHEDULER HEARTBEATS"
@@ -118,13 +119,14 @@ for orgF in .monomind/orgs/*.json; do
   done
 done
 
-[ "$found" -eq 0 ] && echo "  No scheduled heartbeat agents found. Configure via /mastermind:heartbeatv1."
+[ "$found" -eq 0 ] && echo "  No role heartbeat fields found. Orgs run on their top-level schedule via: monomind org serve"
 ```
 
 ### toggle-heartbeat
 
-<!-- LEGACY-ORG-V1: role-level heartbeat scheduling is a v1 org concept. -->
-Enable or disable the scheduler heartbeat for a specific agent:
+Flip the role-level `heartbeat.enabled` field for a specific agent. The Org
+Runtime ignores this field — to change when an org runs, edit its `schedule`
+with `/mastermind-org-settings`:
 
 ```bash
 [ -z "$agent_id" ] && { echo "ERROR: --agent-id required."; exit 1; }

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

@@ -1,6 +1,6 @@
 ---
 name: mastermind-new-agent
-description: Mastermind new-agent — wizard to hire/create a new agent within an org. Configures runtime, model, role name, reports_to hierarchy, responsibilities, skill assignments (found with `monomind org skills search`), and budget. Writes a valid Org Runtime v2 role to the org config file and validates it.
+description: Mastermind new-agent — wizard to hire/create a new agent within an org. Configures runtime, model, role name, reports_to hierarchy, responsibilities, skill assignments (found with `monomind org skills search`), and budget. Writes a valid Org Runtime role to the org config file and validates it.
 type: domain-skill
 default_mode: confirm
 pick: low
@@ -10,7 +10,7 @@ pick: low
 
 This skill is invoked by `mastermind:new-agent` or directly via `/mastermind-new-agent`.
 
-It writes one role in the Org Runtime v2 shape (`RoleSchema` in `packages/@monomind/cli/src/orgrt/types.ts`) — the same shape `mastermind-createorg` produces — and runs `monomind org validate` on the result. There is no `adapter` object, heartbeat or per-role system prompt in v2: the runtime reads `runtime`, `adapter_config.model`, `responsibilities`, `skills` and `skill_pool`.
+It writes one role in the Org Runtime shape (`RoleSchema` in `packages/@monomind/cli/src/orgrt/types.ts`) — the same shape `mastermind-createorg` produces — and runs `monomind org validate` on the result. There is no `adapter` object, heartbeat or per-role system prompt in the org config: the runtime reads `runtime`, `adapter_config.model`, `responsibilities`, `skills` and `skill_pool`.
 
 ---
 
@@ -82,7 +82,7 @@ Pin 1–3 that define the role in `skills`; put the ones it needs only for some
 ### list-runtimes
 
 ```bash
-echo "ORG RUNTIME v2 RUNTIMES (latest model)"
+echo "ORG RUNTIME RUNTIMES (latest model)"
 echo "────────────────────────────────────────────────────────"
 cat <<'RUNTIMES'
   claude        claude-sonnet-5          (default; also claude-opus-5, claude-fable-5-1, claude-haiku-4-5-20251001)

package/.claude/skills/mastermind-org-settings/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: mastermind-org-settings
-description: Mastermind org-settings — edit Org Runtime v2 configuration (name, goal, schedule, budget_tokens, memory_namespace, max_turns_per_message), export org as portable JSON, and import an org from a previously exported file.
+description: Mastermind org-settings — edit Org Runtime configuration (name, goal, schedule, budget_tokens, memory_namespace, max_turns_per_message), export org as portable JSON, and import an org from a previously exported file.
 type: domain-skill
 default_mode: confirm
 pick: low
@@ -10,10 +10,9 @@ pick: low
 
 This skill is invoked by `mastermind:org-settings` or directly via `/mastermind-org-settings`.
 
-It edits `.monomind/orgs/<org_name>.json` in place, and only ever touches fields that `OrgDefSchema` (`packages/@monomind/cli/src/orgrt/types.ts`) actually defines — every field listed below is read by the daemon (`org.ts`/`daemon.ts`/`session.ts`) at `monomind org run`/`serve` time. Its primary edit flow targets v2 fields only: `name`, `goal`, `schedule`, and `run_config` (`budget_tokens`, `memory_namespace`, `max_turns_per_message`). Role edits are not yet supported by this skill's `edit` action — `roles` is shown read-only via `show`.
+It edits `.monomind/orgs/<org_name>.json` in place, and only ever touches fields that `OrgDefSchema` (`packages/@monomind/cli/src/orgrt/types.ts`) actually defines — every field listed below is read by the daemon (`org.ts`/`daemon.ts`/`session.ts`) at `monomind org run`/`serve` time. Its primary edit flow targets these fields only: `name`, `goal`, `schedule`, and `run_config` (`budget_tokens`, `memory_namespace`, `max_turns_per_message`). Role edits are not yet supported by this skill's `edit` action — `roles` is shown read-only via `show`.
 
-<!-- LEGACY-ORG-V1: remove this note when v1 orgs are gone -->
-There is no `topology`, `governance`, `alert_threshold`, or `ceo_adapter` in Org Runtime v2 — those were v1 board/prompt-orchestration fields with no runtime effect and have been removed from this skill's edit surface. Use `/mastermind-org-settings` only for v2-shaped orgs; v1 orgs must go through `monomind org migrate` first.
+There is no `topology`, `governance`, `alert_threshold`, or `ceo_adapter` in the org config — those are legacy fields with no runtime effect and are not part of this skill's edit surface. If an org's config file still carries them (the legacy format), convert it with `monomind org migrate <name>` first.
 
 ---
 

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

@@ -1,6 +1,6 @@
 ---
 name: mastermind-orgs
-description: Mastermind orgs — list all saved orgs with their status, schedule, and last/next run times. Shows stopped/active/paused state for scheduled orgs.
+description: Mastermind orgs — list all saved orgs with their runtime status, schedule, and last run time. Flags crashed runs and config files still in the legacy format.
 type: domain-skill
 default_mode: auto
 pick: low
@@ -43,10 +43,12 @@ fi
 
 ## Step 2 — Render Org Table
 
-For each org file (skip state/approvals files), extract and display. v2 orgs
-(Org Runtime v2, the default since 2026-07) carry `schedule` ("30m"/"2h") in the
-config and their live state in `.monomind/orgs/<name>/runtime.json`; only legacy
-v1 orgs have a `.loop` block.
+For each org file (skip state/approvals files), extract and display. An org
+carries `schedule` ("30m"/"2h") in the config and its live state in
+`.monomind/orgs/<name>/runtime.json`. A config file with a `.loop` block is in
+the legacy format — `monomind org run` converts it in memory (its
+`loop.poll_interval_minutes` becomes the schedule), and `monomind org migrate
+<name>` rewrites the file.
 
 ```bash
 echo ""
@@ -59,34 +61,25 @@ for f in $orgFiles; do
   schedule=$(jq -r '.schedule // empty' "$f" 2>/dev/null)
   loop_interval=$(jq -r '.loop.poll_interval_minutes // empty' "$f" 2>/dev/null)
 
-  if [ -z "$loop_interval" ]; then
-    # v2 org (default) — live state is in runtime.json (crashed = running record, dead pid)
-    interval="${schedule:-manual}"
-    rt=".monomind/orgs/${name}/runtime.json"
-    rt_status=$(jq -r '.status // "never run"' "$rt" 2>/dev/null || echo "never run")
-    rt_pid=$(jq -r '.pid // 0' "$rt" 2>/dev/null || echo 0)
-    if [ "$rt_status" = "running" ] && [ "$rt_pid" -gt 0 ] && ! kill -0 "$rt_pid" 2>/dev/null; then
-      indicator="✗ crashed"
-    elif [ "$rt_status" = "running" ]; then
-      indicator="● running"
-    elif [ "$rt_status" = "never run" ]; then
-      indicator="· never run"
-    else
-      indicator="○ ${rt_status}"
-    fi
-    last_run=$(jq -r '.updated // "—"' "$rt" 2>/dev/null | sed 's/T/ /;s/\..*Z//' || echo "—")
+  # legacy-format config: the runtime turns loop.poll_interval_minutes into the schedule
+  [ -z "$schedule" ] && [ -n "$loop_interval" ] && schedule="${loop_interval}m"
+  interval="${schedule:-manual}"
+  [ -n "$loop_interval" ] && interval="${interval} (legacy)"
+
+  # live state is in runtime.json (crashed = running record, dead pid)
+  rt=".monomind/orgs/${name}/runtime.json"
+  rt_status=$(jq -r '.status // "never run"' "$rt" 2>/dev/null || echo "never run")
+  rt_pid=$(jq -r '.pid // 0' "$rt" 2>/dev/null || echo 0)
+  if [ "$rt_status" = "running" ] && [ "$rt_pid" -gt 0 ] && ! kill -0 "$rt_pid" 2>/dev/null; then
+    indicator="✗ crashed"
+  elif [ "$rt_status" = "running" ]; then
+    indicator="● running"
+  elif [ "$rt_status" = "never run" ]; then
+    indicator="· never run"
   else
-    # LEGACY-ORG-V1: remove this branch when v1 orgs are gone
-    # legacy v1 scheduled org — state lives in the config's status field
-    interval="${loop_interval}m (v1)"
-    status=$(jq -r '.status // "—"' "$f" 2>/dev/null)
-    case "$status" in
-      active)  indicator="● active" ;;
-      paused)  indicator="⏸ paused" ;;
-      *)       indicator="○ stopped" ;;
-    esac
-    last_run=$(jq -r '.loop.last_run // "—"' "$f" 2>/dev/null | sed 's/T/ /;s/Z//')
+    indicator="○ ${rt_status}"
   fi
+  last_run=$(jq -r '.updated // "—"' "$rt" 2>/dev/null | sed 's/T/ /;s/\..*Z//' || echo "—")
 
   printf "%-28s %-14s %-12s %-22s\n" "$name" "$indicator" "$interval" "$last_run"
   echo "  └ $goal"
@@ -108,7 +101,8 @@ COMMANDS
   monomind org validate [name]           Check config against the runtime schema
   /mastermind:orgstatus --org <name>     Detailed status, last runs, activity
   /mastermind:createorg <goal>           Create a new org
-  /mastermind:runorg --org <name>        v2 delegator (auto-migrates v1 configs, then runs via the daemon)
+  /mastermind:runorg --org <name>        Validate and start an org (converts legacy-format configs first)
+  monomind org migrate <name>            Convert a legacy-format config file
 ```
 
 ---