@monoes/monomindcli 2.16.3 → 2.16.4

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
 ```
 
 ---

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

@@ -1,6 +1,6 @@
 ---
 name: mastermind-orgstatus
-description: Mastermind orgstatus — show detailed status for a single org including lifecycle state, schedule, last/next run, recent activity, and roles. For scheduled orgs shows loop health and time until next iteration.
+description: Mastermind orgstatus — show detailed status for a single org including runtime state, schedule, config health, pending approvals, recent activity, and roles.
 type: domain-skill
 default_mode: auto
 pick: low
@@ -40,32 +40,20 @@ orgFile=".monomind/orgs/${org_name}.json"
 
 ## Step 2 — Extract Fields
 
-An org is **v2** (Org Runtime v2 — the default since 2026-07) when it has no
-`.loop` block; its schedule is the top-level `schedule` field and its live state
-is `.monomind/orgs/<name>/runtime.json`. Only legacy v1 orgs have `.loop`,
-`topology`, `board_id`, or `agent_type` on roles.
+An org's schedule is the top-level `schedule` field and its live state is
+`.monomind/orgs/<name>/runtime.json`. A config file that still carries
+`topology`, `board_id`, `loop`, or `agent_type` on roles is in the legacy
+format: `monomind org run` converts it in memory (with a deprecation warning),
+and `monomind org migrate <name>` rewrites the file.
 
 ```bash
 name=$(jq -r '.name // "(unnamed)"' "$orgFile")
 goal=$(jq -r '.goal // "(no goal set)"' "$orgFile")
-status=$(jq -r '.status // "no-schedule"' "$orgFile")
 role_count=$(jq '.roles | length' "$orgFile")
 created_at=$(jq -r '.created_at // "-"' "$orgFile")
-
-has_schedule=$(jq -r 'if .loop.poll_interval_minutes then "yes" else "no" end' "$orgFile")
-
-# v2 fields
-is_v2=$([ "$has_schedule" = "no" ] && echo yes || echo no)
-v2_schedule=$(jq -r '.schedule // empty' "$orgFile")
+schedule=$(jq -r '.schedule // empty' "$orgFile")
 budget=$(jq -r '.run_config.budget_tokens // 1000000' "$orgFile")
-
-# LEGACY-ORG-V1: remove this block when v1 orgs are gone
-# v1 loop fields (legacy scheduled orgs only)
-poll_interval=$(jq -r '.loop.poll_interval_minutes // ""' "$orgFile")
-last_run=$(jq -r '.loop.last_run // "never"' "$orgFile")
-next_run=$(jq -r '.loop.next_run // "not scheduled"' "$orgFile")
-run_prompt_file=$(jq -r '.loop.run_prompt_file // ""' "$orgFile")
-# end LEGACY-ORG-V1 loop-fields block
+legacy_format=$(jq -r 'if has("topology") or has("board_id") or has("loop") or ([.roles[]? | has("agent_type")] | any) then "yes" else "no" end' "$orgFile")
 
 rtFile=".monomind/orgs/${org_name}/runtime.json"
 rt_status=$(jq -r '.status // "never run"' "$rtFile" 2>/dev/null || echo "never run")
@@ -90,88 +78,36 @@ echo "  Created:   $created_at"
 echo "  Roles:     $role_count"
 echo ""
 
-if [ "$is_v2" = "yes" ]; then
-  echo "RUNTIME (Org Runtime v2)"
-  echo "────────────────────────"
-  echo "  Status:    $rt_status${rt_run:+  (run $rt_run)}"
-  echo "  Updated:   $rt_updated"
-  echo "  Schedule:  ${v2_schedule:-manual — run with: monomind org run $name}"
-  echo "  Budget:    $budget tokens (split across roles)"
-  echo ""
-fi
-
-# LEGACY-ORG-V1: remove this block when v1 orgs are gone
-if [ "$has_schedule" = "yes" ]; then
-  echo "SCHEDULED LOOP"
-  echo "──────────────"
-  
-  case "$status" in
-    active)  echo "  Status:    ● ACTIVE — loop is running" ;;
-    stopped) echo "  Status:    ○ STOPPED — loop is not running" ;;
-    paused)  echo "  Status:    ⏸ PAUSED — loop is alive but skipping iterations (HIL gate)" ;;
-    *)       echo "  Status:    ? $status" ;;
-  esac
-  
-  echo "  Interval:  every ${poll_interval} minutes"
-  echo "  Last run:  $last_run"
-  echo "  Next run:  $next_run"
-  echo "  Prompt:    $run_prompt_file"
-  echo ""
-fi
+echo "RUNTIME"
+echo "───────"
+echo "  Status:    $rt_status${rt_run:+  (run $rt_run)}"
+echo "  Updated:   $rt_updated"
+echo "  Schedule:  ${schedule:-manual — run with: monomind org run $name}"
+echo "  Budget:    $budget tokens (split across roles)"
+echo ""
 
 echo "ROLES"
 echo "─────"
-jq -r '(.roles // [])[] | "  • [\(.id)] \(.title // .id)  →  \(.agent_type // .type // "specialist")  (reports to: \(.reports_to // "top"))"' "$orgFile"
+jq -r '(.roles // [])[] | "  • [\(.id)] \(.title // .id)  →  \(.type // .agent_type // "specialist")  (reports to: \(.reports_to // "top"))"' "$orgFile"
 echo ""
 
 echo "HEALTH"
 echo "──────"
-
-if [ "$is_v2" = "yes" ]; then
-  # v2 health = does the config still start? (schema + structural invariants)
-  npx -y monomind@latest org validate "$name" >/dev/null 2>&1 \
-    && echo "  Config:    ✓ valid (monomind org validate)" \
-    || echo "  Config:    ✗ INVALID — run: monomind org validate $name"
-else
-  # LEGACY-ORG-V1: remove this branch when v1 orgs are gone
-  # v1 health: board / column IDs
-  board_id=$(jq -r '.board_id // ""' "$orgFile")
-  todo_col=$(jq -r '.todo_col_id // ""' "$orgFile")
-  doing_col=$(jq -r '.doing_col_id // ""' "$orgFile")
-  done_col=$(jq -r '.done_col_id // ""' "$orgFile")
-  if [ -n "$board_id" ] && [ -n "$todo_col" ] && [ -n "$doing_col" ] && [ -n "$done_col" ]; then
-    echo "  Board:     ✓ task board configured (${board_id})"
-  else
-    echo "  Board:     ✗ task board IDs missing — re-run /mastermind:createorg --name ${name} to rebuild"
-  fi
-fi
-
-# LEGACY-ORG-V1: remove this branch when v1 orgs are gone
-# Pending approvals
-approvalsFile=".monomind/orgs/${org_name}-approvals.json"
-if [ -f "$approvalsFile" ]; then
-  pending=$(jq '(.approvals // []) | map(select(.status == "pending")) | length' "$approvalsFile")
-  [ "$pending" -gt 0 ] \
-    && echo "  Approvals: ⚠ ${pending} pending — /mastermind:approvev1 --org ${name} --action list" \
-    || echo "  Approvals: ✓ none pending"
-else
-  echo "  Approvals: ✓ no approvals file"
-fi
-
-# Stop file (pending stop signal) — v2 daemons poll <org>/stop; v1 used .stops/
-[ -f ".monomind/orgs/${org_name}/stop" ] && echo "  Stop file: ⚠ PRESENT (v2) — daemon will exit within 2s of seeing it"
-# LEGACY-ORG-V1: remove this check when v1 orgs are gone
-[ -f ".monomind/orgs/.stops/${org_name}.stop" ] && echo "  Stop file: ⚠ PRESENT (v1 legacy path)"
-
-# LEGACY-ORG-V1: remove this block when v1 orgs are gone
-# Loop prompt file (scheduled orgs)
-if [ "$has_schedule" = "yes" ]; then
-  if [ -n "$run_prompt_file" ] && [ -f "$run_prompt_file" ]; then
-    echo "  Loop prompt: ✓ exists (${run_prompt_file})"
-  else
-    echo "  Loop prompt: ✗ MISSING — scheduled org cannot self-perpetuate; re-create org or write prompt to ${run_prompt_file}"
-  fi
-fi
+# health = does the config still start? (schema + structural invariants)
+npx -y monomind@latest org validate "$name" >/dev/null 2>&1 \
+  && echo "  Config:    ✓ valid (monomind org validate)" \
+  || echo "  Config:    ✗ INVALID — run: monomind org validate $name"
+[ "$legacy_format" = "yes" ] \
+  && echo "  Format:    ⚠ legacy config format — convert with: monomind org migrate $name"
+
+# Pending tool approvals (the runtime's queue: .monomind/orgs/<name>/approvals.json)
+pending=$(jq '[(.approvals // [])[] | select(.approved == null)] | length' ".monomind/orgs/${org_name}/approvals.json" 2>/dev/null || echo 0)
+[ "$pending" -gt 0 ] \
+  && echo "  Approvals: ⚠ ${pending} pending — monomind org approvals ${name}" \
+  || echo "  Approvals: ✓ none pending"
+
+# Stop file (pending stop signal) — the daemon polls <org>/stop
+[ -f ".monomind/orgs/${org_name}/stop" ] && echo "  Stop file: ⚠ PRESENT — daemon will exit within 2s of seeing it"
 echo ""
 ```
 
@@ -180,31 +116,15 @@ echo ""
 ## Step 4 — Show Recent Activity (if available)
 
 ```bash
-if [ "$is_v2" = "yes" ]; then
-  # v2: the durable record is bus.jsonl inside the most recent run directory
-  latest_bus=$(ls -t .monomind/orgs/"${org_name}"/run-*/bus.jsonl 2>/dev/null | head -1)
-  if [ -n "$latest_bus" ]; then
-    echo "RECENT ACTIVITY (last 5 bus events — $(dirname "$latest_bus" | xargs basename))"
-    echo "────────────────────────"
-    tail -5 "$latest_bus" | while IFS= read -r line; do
-      echo "$line" | jq -r '"  \(.ts // "" | if type=="number" then (./1000 | todate) else . end)  \(.type // "")  \(.from // "")\(if .to then " → " + .to else "" end)  \(.msg // .tool // "" | tostring | .[0:60])"' 2>/dev/null
-    done
-    echo ""
-  fi
-else
-  # LEGACY-ORG-V1: remove this branch when v1 orgs are gone
-  activityFile=".monomind/orgs/${org_name}-activity.jsonl"
-  if [ -f "$activityFile" ]; then
-    echo "RECENT ACTIVITY (last 5)"
-    echo "────────────────────────"
-    tail -5 "$activityFile" | while IFS= read -r line; do
-      ts=$(echo "$line" | jq -r '.ts // ""')
-      type=$(echo "$line" | jq -r '.type // ""')
-      pending=$(echo "$line" | jq -r '.pending // ""')
-      echo "  $ts  $type  ${pending:+pending=$pending}"
-    done
-    echo ""
-  fi
+# the durable record is bus.jsonl inside the most recent run directory
+latest_bus=$(ls -t .monomind/orgs/"${org_name}"/run-*/bus.jsonl 2>/dev/null | head -1)
+if [ -n "$latest_bus" ]; then
+  echo "RECENT ACTIVITY (last 5 bus events — $(dirname "$latest_bus" | xargs basename))"
+  echo "────────────────────────"
+  tail -5 "$latest_bus" | while IFS= read -r line; do
+    echo "$line" | jq -r '"  \(.ts // "" | if type=="number" then (./1000 | todate) else . end)  \(.type // "")  \(.from // "")\(if .to then " → " + .to else "" end)  \(.msg // .tool // "" | tostring | .[0:60])"' 2>/dev/null
+  done
+  echo ""
 fi
 ```
 
@@ -215,26 +135,15 @@ fi
 ```bash
 echo "ACTIONS"
 echo "───────"
-if [ "$is_v2" = "yes" ]; then
-  case "$rt_status" in
-    running*) echo "  Stop:         monomind org stop $name" ;;
-    crashed*) echo "  Close out:    monomind org mark-complete $name" ;;
-    *)        echo "  Run:          monomind org run $name${v2_schedule:+   (or host on schedule: monomind org serve)}" ;;
-  esac
-  echo "  Logs:         monomind org logs $name --follow"
-  echo "  Report:       monomind org report $name   (add --all for run history)"
-  echo "  Validate:     monomind org validate $name"
-  echo "  Settings:     /mastermind-org-settings --org $name"
-# LEGACY-ORG-V1: remove the next two branches when v1 orgs are gone
-elif [ "$has_schedule" = "yes" ]; then
-  case "$status" in
-    active|paused) echo "  Stop loop:    /mastermind:stoporg --org $name" ;;
-    stopped)       echo "  Start loop:   /mastermind:runorg --org $name  (v1 config — will auto-migrate)" ;;
-  esac
-  echo "  Edit prompt:  \$EDITOR $run_prompt_file"
-else
-  echo "  Run org:      /mastermind:runorg --org $name  (v1 config — will auto-migrate)"
-fi
+case "$rt_status" in
+  running*) echo "  Stop:         monomind org stop $name" ;;
+  crashed*) echo "  Close out:    monomind org mark-complete $name" ;;
+  *)        echo "  Run:          monomind org run $name${schedule:+   (or host on schedule: monomind org serve)}" ;;
+esac
+echo "  Logs:         monomind org logs $name --follow"
+echo "  Report:       monomind org report $name   (add --all for run history)"
+echo "  Validate:     monomind org validate $name"
+echo "  Settings:     /mastermind-org-settings --org $name"
 echo "  All orgs:     /mastermind:orgs"
 echo ""
 ```

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

@@ -1,13 +1,13 @@
 ---
 name: mastermind-runorg
-description: Start a saved org via the Org Runtime v2 daemon (monomind org run/serve). Migrates v1-shaped configs first. The legacy prompt-orchestrated path lives in runorgv1.
+description: Start a saved org via the Org Runtime daemon (monomind org run/serve). Converts legacy-format config files with monomind org migrate first.
 type: domain-skill
 default_mode: auto
 ---
 
-# Mastermind Runorg (v2)
+# Mastermind Runorg
 
-Starts orgs exclusively through the v2 SDK daemon. Every role becomes a live
+Starts orgs through the Org Runtime SDK daemon. Every role becomes a live
 SDK session; events reach the dashboard through the daemon's own forwarder —
 no curl emissions, no delivery gaps.
 
@@ -15,17 +15,18 @@ no curl emissions, no delivery gaps.
 
 1. **Resolve the org.** `org_name` from params. List available orgs when missing:
    `monomind org list`.
-2. **Shape-detect v1.** Do NOT rely on `monomind org validate` to catch v1
-   configs — a v1-shaped config with no structural violations (unique role
-   ids, one root, resolvable `reports_to`, parseable schedule) *passes*
-   schema validation even though it's still v1. Detect v1-ness directly:
+2. **Detect the legacy config format.** Do NOT rely on `monomind org validate`
+   to catch legacy-format config files — one with no structural violations
+   (unique role ids, one root, resolvable `reports_to`, parseable schedule)
+   *passes* schema validation even though it still carries legacy fields.
+   Detect them directly:
    `jq 'has("topology") or has("board_id") or has("loop") or ([.roles[]? | has("agent_type")] | any)' .monomind/orgs/<name>.json`
    - `true` → step 3 (migrate first).
    - `false` → step 4 (validate as-is).
-3. **Migrate (v1 configs).** `monomind org migrate <name>` — original is kept
-   as `<name>.v1.json`. In confirm mode ask first; in auto mode migrate and
-   state it. If migration fails, stop and surface the error — do NOT fall back
-   to runorgv1 silently.
+3. **Migrate (legacy-format configs).** `monomind org migrate <name>` rewrites
+   the file in the current format — the original is kept as `<name>.v1.json`.
+   In confirm mode ask first; in auto mode migrate and state it. If migration
+   fails, stop and surface the error.
 4. **Validate.** Run `monomind org validate <name>` on the config (post-migration
    if step 3 ran).
    - Valid → step 5.
@@ -55,8 +56,7 @@ no curl emissions, no delivery gaps.
    `running`. Surface the dashboard link (`<CTRL_URL>/orgs`) and
    `monomind org logs <name> --follow` as the tail command.
 8. **Never** spawn a boss Task agent, create monotask boards, or emit
-   dashboard events manually. If the user explicitly asks for the legacy
-   behavior, direct them to `/mastermind:runorgv1` (deprecated).
+   dashboard events manually. The org daemon is the only way an org runs.
 
 The org runtime does not read `<org>-issues.json`. Work is driven by the org
 definition's roles and goal plus an optional `--task` string.

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

@@ -1,6 +1,6 @@
 ---
 name: mastermind-stoporg
-description: Mastermind stoporg — stop a running scheduled org loop by setting its status to "stopped". The next scheduled wakeup will read the status, skip all work, and not reschedule. Loop dies within one interval — no orphaned wakeups.
+description: Mastermind stoporg — stop a running org. Wraps monomind org stop, which writes the stop file the org daemon polls; the daemon exits within about 2 seconds.
 type: domain-skill
 default_mode: auto
 pick: low
@@ -37,15 +37,8 @@ orgFile=".monomind/orgs/${org_name}.json"
 }
 ```
 
-Read current status:
-```bash
-current_status=$(jq -r '.status // "no-schedule"' "$orgFile")
-has_schedule=$(jq -r 'if .loop.poll_interval_minutes then "yes" else "no" end' "$orgFile")
-```
-
-If `has_schedule == "no"` — this is a **v2 org** (Org Runtime v2 has `schedule`,
-never `.loop`). Its daemon polls `.monomind/orgs/<name>/stop` every 2s, which is
-exactly what `monomind org stop` writes — use the CLI, not the v1 `.stops/` path:
+The org daemon polls `.monomind/orgs/<name>/stop` every 2s, which is exactly
+what `monomind org stop` writes — use the CLI:
 
 ```bash
 REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
@@ -54,67 +47,19 @@ npx -y monomind@latest org stop "${org_name}" \
   || { mkdir -p ".monomind/orgs/${org_name}"; date -u +%Y-%m-%dT%H:%M:%SZ > ".monomind/orgs/${org_name}/stop"; }
 # Also POST to the control server in case a dashboard-started instance is running
 curl -s -X POST -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" "${CTRL_URL}/api/orgs/${org_name}/stop" >/dev/null 2>&1 || true
-echo "Stop requested for org '${org_name}' (v2 daemon exits within 2s)."
-```
-- Exit.
-
-<!-- LEGACY-ORG-V1: remove this branch when v1 orgs are gone -->
-Everything below this point only runs for v1 orgs — v2 orgs already exited above.
-
-If `current_status == "stopped"`:
-- Print: "Org '<org_name>' is already stopped."
-- Exit.
-
----
-
-<!-- LEGACY-ORG-V1: remove this step when v1 orgs are gone -->
-## Step 2 — Set Status to Stopped and Clear next_run (v1 only)
-
-```bash
-orgFile=".monomind/orgs/${org_name}.json"
-tmp="${orgFile}.tmp"
-# Clear next_run to avoid showing a stale future timestamp in orgstatus
-jq '.status = "stopped" | if .loop then .loop.next_run = null else . end' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
-```
-
----
-
-<!-- LEGACY-ORG-V1: remove this step when v1 orgs are gone -->
-## Step 3 — Write Stop File (for any running boss agents, v1 only)
-
-Any persistent boss agent checks for this file at the start of each loop iteration:
-
-```bash
-mkdir -p .monomind/orgs/.stops
-touch ".monomind/orgs/.stops/${org_name}.stop"
-```
-
----
-
-<!-- LEGACY-ORG-V1: remove this step when v1 orgs are gone -->
-## Step 5 — Report to User (v1 only)
-
-```
-✓ Org "<org_name>" stopped.
-
-  Current status: stopped
-  The loop will exit at its next scheduled wakeup without rescheduling.
-  Loop fully dead within: ≤$(jq -r '.loop.poll_interval_minutes // "?"' "$orgFile") minutes
-
-  To restart: /mastermind:runorg --org <org_name>
-  Status:     /mastermind:orgstatus --org <org_name>
+echo "Stop requested for org '${org_name}' (the daemon exits within 2s)."
 ```
 
 ---
 
-## Step 6 — Return Output
+## Step 2 — Return Output
 
 ```yaml
 domain: ops
 status: complete
 decisions:
   - what: "Org <org_name> stopped"
-    why: "status set to 'stopped'; next wakeup exits without rescheduling"
+    why: "stop file written; the org daemon exits within 2s"
     confidence: 1.0
     outcome: shipped
 next_actions:
@@ -124,6 +69,6 @@ next_actions:
 
 ---
 
-## Step 7 — Brain Write (standalone only)
+## Step 3 — Brain Write (standalone only)
 
 If `caller` is not "command", follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.

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

@@ -6,10 +6,10 @@ default_mode: auto
 pick: low
 ---
 
-> **LEGACY-ORG-V1 — writes to a monotask board, not to `<org>-issues.json`.** This skill's
-> `parent_id`, `status` (`todo | doing | done`), and card model belong to the pre-v2
-> board-backed runner. For v2 issue tracking — including sub-issues — use
-> `/mastermind-issues --action create --parent-id <id>`.
+> **Writes to a monotask board, not to `<org>-issues.json`.** This skill only works
+> on an org config that still carries a monotask `board_id` (the legacy config
+> format); the Org Runtime never reads that board. For org issue tracking —
+> including sub-issues — use `/mastermind-issues --action create --parent-id <id>`.
 
 # Mastermind Tasks
 
@@ -41,16 +41,14 @@ If `caller` is not "command", load brain context following mastermind-protocol/S
 ## Step 1 — Load Org Config
 
 ```bash
-# LEGACY-ORG-V1: this whole board/column lookup is the pre-v2 board-backed
-# task model — boards belong to the legacy v1 runner, see runorgv1.
+# board/column ids only exist on legacy-format org configs
 orgFile=".monomind/orgs/${org_name}.json"
 board_id=$(jq -r '.board_id // empty' "$orgFile")
 todo_col=$(jq -r '.todo_col_id // empty' "$orgFile")
 doing_col=$(jq -r '.doing_col_id // empty' "$orgFile")
 done_col=$(jq -r '.done_col_id // empty' "$orgFile")
 
-[ -z "$board_id" ] && { echo "ERROR: org config missing board_id — boards belong to the legacy v1 runner, see runorgv1."; exit 1; }
-# end LEGACY-ORG-V1
+[ -z "$board_id" ] && { echo "ERROR: org config has no board_id — the Org Runtime does not use monotask boards. Use /mastermind-issues for org issues."; exit 1; }
 ```
 
 ---