monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/skills/mastermind/org-settings.md

@@ -0,0 +1,254 @@
+---
+name: mastermind-org-settings
+description: Mastermind org-settings — edit org configuration (name, goal, topology, governance, budget), export org as portable JSON, and import an org from a previously exported file.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Org Settings
+
+This skill is invoked by `mastermind:org-settings` or directly via `/mastermind:org-settings`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to configure (required)
+- `action`: show | edit | export | import
+- `field`: field to edit (name, goal, topology, governance, budget_tokens, alert_threshold, ceo_adapter)
+- `value`: new value for the field
+- `export_path`: path to write exported JSON (default: `.monomind/exports/<org_name>-<timestamp>.json`)
+- `import_path`: path to JSON file to import from
+- `caller`: command | master
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — Resolve Org
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found. Run /mastermind:createorg first."; exit 1; }
+```
+
+---
+
+## Step 2 — Execute Action
+
+### show (default)
+
+Display current org config in a readable format:
+
+```bash
+echo "ORG SETTINGS — ${org_name}"
+echo "──────────────────────────────────────────"
+jq -r '
+  "  Name:         \(.name // .org_name // "-")",
+  "  Goal:         \(.goal // "-")",
+  "  Topology:     \(.topology // "hierarchical")",
+  "  Max Agents:   \(.max_agents // 8)",
+  "  Governance:   \(.governance.policy // "auto")",
+  "  Budget:       \(.run_config.budget_tokens // 0) tokens",
+  "  Alert at:     \((.run_config.alert_threshold // 0.8) * 100 | floor)%",
+  "  CEO Adapter:  \(.run_config.ceo_adapter // "claude-sonnet-4-6")",
+  "  Roles:        \(.roles | length) agents"
+' "$orgFile"
+echo ""
+echo "  Run /mastermind:org-settings --org ${org_name} --action edit --field <field> --value <value>"
+echo "  Fields: name | goal | topology | governance | budget_tokens | alert_threshold | ceo_adapter"
+```
+
+### edit
+
+Update a single field in the org config:
+
+```bash
+field="${field}"
+value="${value}"
+tmp="${orgFile}.tmp"
+
+case "$field" in
+  name)
+    # Validate new name slug
+    echo "$value" | grep -qE '^[a-z0-9][a-z0-9-]{0,63}$' || { echo "ERROR: name must match ^[a-z0-9][a-z0-9-]{0,63}$"; exit 1; }
+    newOrgFile=".monomind/orgs/${value}.json"
+    [ -f "$newOrgFile" ] && { echo "ERROR: An org named '${value}' already exists."; exit 1; }
+    # Update the name field inside the JSON
+    jq --arg v "$value" '.name = $v' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
+    # Rename the main config file
+    mv "$orgFile" "$newOrgFile"
+    # Rename all side-car data files
+    for suffix in -state -goals -routines -approvals -activity -issues -members -projects -workspaces -worktrees -environments -plugins -adapters -threads -budgets -project-workspaces -approval-comments -bootstrap -secrets; do
+      old_file=".monomind/orgs/${org_name}${suffix}.json"
+      [ -f "$old_file" ] && mv "$old_file" ".monomind/orgs/${value}${suffix}.json" || true
+      old_jsonl=".monomind/orgs/${org_name}${suffix}.jsonl"
+      [ -f "$old_jsonl" ] && mv "$old_jsonl" ".monomind/orgs/${value}${suffix}.jsonl" || true
+    done
+    # Rename loop prompt file if present (scheduled orgs)
+    old_loop=".monomind/loops/${org_name}.md"
+    [ -f "$old_loop" ] && mv "$old_loop" ".monomind/loops/${value}.md" || true
+    # Rename stop file if present
+    old_stop=".monomind/orgs/.stops/${org_name}.stop"
+    [ -f "$old_stop" ] && mv "$old_stop" ".monomind/orgs/.stops/${value}.stop" || true
+    echo "Renamed org '${org_name}' → '${value}'"
+    org_name="$value"
+    orgFile="$newOrgFile"
+    ;;
+  goal)
+    jq --arg v "$value" '.goal = $v' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
+    echo "Updated: goal → $value"
+    ;;
+  topology)
+    case "$value" in hierarchical|mesh|hierarchical-mesh|adaptive|star|ring) : ;; *)
+      echo "ERROR: topology must be one of: hierarchical, mesh, hierarchical-mesh, adaptive, star, ring"; exit 1 ;;
+    esac
+    jq --arg v "$value" '.topology = $v' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
+    echo "Updated: topology → $value"
+    ;;
+  governance)
+    case "$value" in auto|board|strict) : ;; *)
+      echo "ERROR: governance must be one of: auto, board, strict"; exit 1 ;;
+    esac
+    jq --arg v "$value" '.governance.policy = $v' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
+    echo "Updated: governance → $value"
+    ;;
+  budget_tokens)
+    [[ "$value" =~ ^[0-9]+$ ]] || { echo "ERROR: budget_tokens must be a positive integer"; exit 1; }
+    jq --argjson v "$value" '.run_config.budget_tokens = $v' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
+    echo "Updated: budget_tokens → $value"
+    ;;
+  alert_threshold)
+    # accept 0.0–1.0 or 0–100
+    if [[ "$value" =~ ^[0-9]+$ ]] && [ "$value" -gt 1 ]; then
+      value=$(awk "BEGIN{printf \"%.2f\",$value/100}")
+    fi
+    jq --argjson v "$value" '.run_config.alert_threshold = $v' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
+    echo "Updated: alert_threshold → $value"
+    ;;
+  ceo_adapter)
+    case "$value" in claude-sonnet-4-6|claude-opus-4-7|claude-haiku-4-5) : ;; *)
+      echo "ERROR: ceo_adapter must be one of: claude-sonnet-4-6, claude-opus-4-7, claude-haiku-4-5"; exit 1 ;;
+    esac
+    jq --arg v "$value" '.run_config.ceo_adapter = $v' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
+    echo "Updated: ceo_adapter → $value"
+    ;;
+  *)
+    echo "ERROR: Unknown field '$field'. Valid fields: name, goal, topology, governance, budget_tokens, alert_threshold, ceo_adapter"
+    exit 1
+    ;;
+esac
+```
+
+Emit `org:settings:updated` event:
+
+```bash
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn --arg org "$org_name" --arg field "$field" --arg value "$value" \
+    '{type:"org:settings:updated",org:$org,field:$field,value:$value,ts:(now*1000|floor)}')" || true
+```
+
+### export
+
+Export the full org config (minus secrets) to a portable JSON:
+
+```bash
+mkdir -p ".monomind/exports"
+timestamp=$(date +%Y%m%d-%H%M%S)
+outPath="${export_path:-.monomind/exports/${org_name}-${timestamp}.json}"
+
+# Pre-read optional side-car files (--slurpfile aborts jq when the file is missing)
+goals_json=$([ -f ".monomind/orgs/${org_name}-goals.json" ]    && jq -c '.' ".monomind/orgs/${org_name}-goals.json"    || echo 'null')
+routines_json=$([ -f ".monomind/orgs/${org_name}-routines.json" ] && jq -c '.' ".monomind/orgs/${org_name}-routines.json" || echo 'null')
+projects_json=$([ -f ".monomind/orgs/${org_name}-projects.json" ] && jq -c '.' ".monomind/orgs/${org_name}-projects.json" || echo 'null')
+
+# Merge all org data files into one export bundle
+jq -n \
+  --slurpfile config "$orgFile" \
+  --argjson goals     "$goals_json" \
+  --argjson routines  "$routines_json" \
+  --argjson projects  "$projects_json" \
+  '{
+    exported_at: (now|todate),
+    format_version: "1.0",
+    config: ($config[0] // {}),
+    goals: ($goals.goals // []),
+    routines: ($routines.routines // []),
+    projects: ($projects.projects // [])
+  }' > "$outPath"
+
+echo "Exported: $outPath"
+echo "$(wc -c < "$outPath") bytes — share this file to recreate the org on another machine."
+echo "Import with: /mastermind:org-settings --action import --import-path $outPath"
+```
+
+### import
+
+Import an org from a previously exported bundle:
+
+```bash
+[ ! -f "$import_path" ] && { echo "ERROR: Import file not found: $import_path"; exit 1; }
+
+# Validate format
+fmt=$(jq -r '.format_version // "unknown"' "$import_path" 2>/dev/null || echo "unknown")
+[ "$fmt" != "1.0" ] && echo "Warning: format_version '$fmt' — attempting import anyway."
+
+importedName=$(jq -r '.config.name // .config.org_name // "unnamed"' "$import_path")
+targetOrg="${org_name:-$importedName}"
+mkdir -p ".monomind/orgs"
+
+# Write config — update the name field to match targetOrg (in case file was exported under a different name)
+tmpConfig=".monomind/orgs/${targetOrg}.json.tmp"
+jq --arg n "$targetOrg" '.config | .name = $n' "$import_path" > "$tmpConfig" && mv "$tmpConfig" ".monomind/orgs/${targetOrg}.json" || { rm -f "$tmpConfig"; echo "ERROR: Failed to write org config from import."; exit 1; }
+
+# Write goals if present (atomic write)
+goalsData=$(jq -c '.goals // []' "$import_path" 2>/dev/null || echo '[]')
+if [ "$goalsData" != "[]" ]; then
+  tmp=".monomind/orgs/${targetOrg}-goals.json.tmp"
+  jq -n --argjson data "$goalsData" '{"goals":$data}' > "$tmp" && mv "$tmp" ".monomind/orgs/${targetOrg}-goals.json" || rm -f "$tmp"
+fi
+
+# Write routines if present (atomic write)
+routinesData=$(jq -c '.routines // []' "$import_path" 2>/dev/null || echo '[]')
+if [ "$routinesData" != "[]" ]; then
+  tmp=".monomind/orgs/${targetOrg}-routines.json.tmp"
+  jq -n --argjson data "$routinesData" '{"routines":$data}' > "$tmp" && mv "$tmp" ".monomind/orgs/${targetOrg}-routines.json" || rm -f "$tmp"
+fi
+
+# Write projects if present (atomic write)
+projectsData=$(jq -c '.projects // []' "$import_path" 2>/dev/null || echo '[]')
+if [ "$projectsData" != "[]" ]; then
+  tmp=".monomind/orgs/${targetOrg}-projects.json.tmp"
+  jq -n --argjson data "$projectsData" '{"projects":$data}' > "$tmp" && mv "$tmp" ".monomind/orgs/${targetOrg}-projects.json" || rm -f "$tmp"
+fi
+
+echo "Imported org '${targetOrg}' from ${import_path}"
+echo "Agents: $(jq '.config.roles | length' "$import_path")"
+echo "Run /mastermind:env --org ${targetOrg} --action validate to check provider keys."
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+field: <field if edit>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/packages/@monomind/cli/.claude/skills/mastermind/orgs.md

@@ -0,0 +1,98 @@
+---
+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.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Orgs
+
+This skill is invoked by `mastermind:orgs` or directly via `/mastermind:orgs`.
+
+Lists all saved orgs from `.monomind/orgs/*.json`.
+
+---
+
+## Inputs
+
+- `caller`: command | master (controls whether brain load runs here)
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — List Orgs
+
+```bash
+orgsDir=".monomind/orgs"
+orgFiles=$(ls "$orgsDir"/*.json 2>/dev/null | grep -vE -- '-approvals|-state|-activity|-goals|-routines|-projects|-members|-issues|-workspaces|-worktrees|-environments|-plugins|-adapters|-bootstrap|-threads|-budgets|-project-workspaces|-approval-comments')
+
+if [ -z "$orgFiles" ]; then
+  echo "No saved orgs found."
+  echo "Create one: /mastermind:createorg <goal>"
+  exit 0
+fi
+```
+
+---
+
+## Step 2 — Render Org Table
+
+For each org file (skip state/approvals files), extract and display:
+
+```bash
+echo ""
+printf "%-28s %-10s %-12s %-22s %-22s\n" "ORG" "STATUS" "SCHEDULE" "LAST RUN" "NEXT RUN"
+printf "%-28s %-10s %-12s %-22s %-22s\n" "---" "------" "--------" "--------" "--------"
+
+for f in $orgFiles; do
+  name=$(jq -r '.name // "(unnamed)"' "$f" 2>/dev/null)
+  goal=$(jq -r '.goal // ""' "$f" 2>/dev/null | cut -c1-55)
+  status=$(jq -r '.status // "—"' "$f" 2>/dev/null)
+  interval=$(jq -r 'if .loop.poll_interval_minutes then "\(.loop.poll_interval_minutes)m" else "manual" end' "$f" 2>/dev/null)
+  last_run=$(jq -r '.loop.last_run // "—"' "$f" 2>/dev/null | sed 's/T/ /;s/Z//')
+  next_run=$(jq -r '.loop.next_run // "—"' "$f" 2>/dev/null | sed 's/T/ /;s/Z//')
+  
+  # Status indicator — distinguish non-scheduled (manual) from scheduled loop states
+  if [ "$interval" = "manual" ]; then
+    indicator="■ persistent"
+  else
+    case "$status" in
+      active)  indicator="● active" ;;
+      stopped) indicator="○ stopped" ;;
+      paused)  indicator="⏸ paused" ;;
+      *)       indicator="— unknown" ;;
+    esac
+  fi
+  
+  printf "%-28s %-10s %-12s %-22s %-22s\n" "$name" "$indicator" "$interval" "$last_run" "$next_run"
+  echo "  └ $goal"
+  echo ""
+done
+```
+
+---
+
+## Step 3 — Show Summary and Commands
+
+```
+COMMANDS
+────────
+  /mastermind:orgstatus --org <name>     Detailed status, last runs, activity
+  /mastermind:runorg --org <name>        Start (or restart) a scheduled org
+  /mastermind:stoporg --org <name>       Stop a running scheduled org
+  /mastermind:createorg <goal>           Create a new org
+```
+
+---
+
+## Step 4 — Return Output
+
+```yaml
+domain: ops
+status: complete
+```

package/packages/@monomind/cli/.claude/skills/mastermind/orgstatus.md

@@ -0,0 +1,194 @@
+---
+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.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Org Status
+
+This skill is invoked by `mastermind:orgstatus` or directly via `/mastermind:orgstatus`.
+
+---
+
+## Inputs
+
+- `org_name`: name of the org to inspect (required)
+- `caller`: command | master
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — Load Org
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && {
+  echo "ERROR: Org '${org_name}' not found."
+  echo "Available: $(ls .monomind/orgs/*.json 2>/dev/null | grep -vE -- '-approvals|-state|-activity|-goals|-routines|-projects|-members|-issues|-workspaces|-worktrees|-environments|-plugins|-adapters|-bootstrap|-threads|-budgets|-project-workspaces|-approval-comments' | xargs -I{} basename {} .json | tr '\n' ' ')"
+  exit 1
+}
+```
+
+---
+
+## Step 2 — Extract Fields
+
+```bash
+name=$(jq -r '.name // "(unnamed)"' "$orgFile")
+goal=$(jq -r '.goal // "(no goal set)"' "$orgFile")
+status=$(jq -r '.status // "no-schedule"' "$orgFile")
+topology=$(jq -r '.topology // "hierarchical"' "$orgFile")
+role_count=$(jq '.roles | length' "$orgFile")
+created_at=$(jq -r '.created_at // "-"' "$orgFile")
+
+# Loop fields (scheduled orgs only)
+has_schedule=$(jq -r 'if .loop.poll_interval_minutes then "yes" else "no" end' "$orgFile")
+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")
+```
+
+---
+
+## Step 3 — Render Status
+
+```bash
+echo ""
+echo "ORG: $name"
+echo "════════════════════════════════════════════════"
+echo "  Goal:      $goal"
+echo "  Created:   $created_at"
+echo "  Topology:  $topology  |  Roles: $role_count"
+echo ""
+
+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 "ROLES"
+echo "─────"
+jq -r '(.roles // [])[] | "  • [\(.id)] \(.title)  →  \(.agent_type)  (\(.reports_to // "top"))"' "$orgFile"
+echo ""
+
+echo "HEALTH"
+echo "──────"
+
+# 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
+
+# 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:approve --org ${name} --action list" \
+    || echo "  Approvals: ✓ none pending"
+else
+  echo "  Approvals: ✓ no approvals file"
+fi
+
+# Stop file (pending stop signal)
+stopFile=".monomind/orgs/.stops/${org_name}.stop"
+[ -f "$stopFile" ] && echo "  Stop file: ⚠ PRESENT — a stop signal is queued for this org"
+
+# 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
+echo ""
+```
+
+---
+
+## Step 4 — Show Recent Activity (if available)
+
+```bash
+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
+```
+
+---
+
+## Step 5 — Show Lifecycle Commands
+
+```bash
+if [ "$has_schedule" = "yes" ]; then
+  echo "ACTIONS"
+  echo "───────"
+  case "$status" in
+    active|paused)
+      echo "  Stop loop:    /mastermind:stoporg --org $name"
+      ;;
+    stopped)
+      echo "  Start loop:   /mastermind:runorg --org $name"
+      ;;
+  esac
+  echo "  Edit prompt:  \$EDITOR $run_prompt_file"
+  echo "  All orgs:     /mastermind:orgs"
+else
+  echo "ACTIONS"
+  echo "───────"
+  echo "  Run org:      /mastermind:runorg --org $name"
+  echo "  All orgs:     /mastermind:orgs"
+fi
+echo ""
+```
+
+---
+
+## Step 6 — Return Output
+
+```yaml
+domain: ops
+status: complete
+```
+
+---
+
+## Step 7 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/packages/@monomind/cli/.claude/skills/mastermind/plan-to-tasks.md

@@ -0,0 +1,136 @@
+---
+name: mastermind-plan-to-tasks
+description: Mastermind plan-to-tasks — converts a written plan (prose, outline, or structured doc) into assigned org issues with correct specialties, dependency wiring, and parallelization. Mirrors Paperclip's plan-to-tasks skill. Use when breaking down a project plan into executable issue trees.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Plan to Tasks
+
+This skill is invoked by `mastermind:plan-to-tasks` or directly via `/mastermind:plan-to-tasks`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to create issues in (required)
+- `plan`: the plan text (required — paste inline or pipe in)
+- `project_id`: assign all issues to this project (optional)
+- `workspace_id`: assign all issues to this workspace (optional)
+- `dry_run`: true | false (default: false — if true, print plan without creating issues)
+- `caller`: command | master
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — Validate Inputs
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org required."; exit 1; }
+[ -z "$plan"     ] && { echo "ERROR: --plan required (the plan text to decompose)."; exit 1; }
+
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
+```
+
+---
+
+## Step 2 — Load Agents for Specialty Matching
+
+```bash
+echo "PLAN-TO-TASKS — $org_name"
+echo "────────────────────────────────────────────────────────"
+echo ""
+echo "AGENTS IN ORG:"
+jq -r '(.roles // [])[] | "  \(.id)  \(.title // "-")  [\(.adapter.type // "?")]"' "$orgFile"
+echo ""
+```
+
+---
+
+## Step 3 — Decompose Plan into Issues
+
+Read the plan carefully and apply these rules:
+
+**Planning principles (from Paperclip plan-to-tasks):**
+
+1. **Plan deeply.** Capture real detail: goals, constraints, unknowns, success criteria, risks. A shallow plan becomes rework.
+2. **Know your team.** Read the org's agents and their specialties (titles, roles, adapters) before assigning anything.
+3. **Assign for specialty.** Hand each piece of work to the most relevant agent. If no agent fits, flag the gap.
+4. **Take responsibility.** When you (the AI) are best-suited for a piece, assign it to yourself instead of delegating.
+5. **Use the dependency tree.** Express every concrete deliverable as an issue. Wire real blockers via `blockedByIssueIds`. When done, dependents auto-wake.
+6. **Order, then parallelize.** Sequence by real dependencies. Independent branches start in parallel.
+7. **Enough is enough.** Plans unblock execution. Don't re-plan already clear work.
+
+**Decomposition output:**
+
+For each issue extracted from the plan, produce:
+```
+ISSUE: <title>
+  assignee:    <agent-id or UNASSIGNED>
+  priority:    low | medium | high | urgent
+  blockedBy:   <issue-title> (or none)
+  description: <1-2 sentence summary of the deliverable>
+```
+
+**Quality checklist before creating:**
+- [ ] Enough detail that assignees can act without re-asking
+- [ ] Every concrete deliverable is an issue
+- [ ] Each issue has a deliberate, specialty-matched assignee
+- [ ] Each issue's real blockers are declared
+- [ ] Independent branches can start in parallel
+- [ ] Gaps (missing skills, decisions, external inputs) are surfaced, not hidden
+
+---
+
+## Step 4 — Create Issues (unless dry_run=true)
+
+```bash
+issuesFile=".monomind/orgs/${org_name}-issues.json"
+[ ! -f "$issuesFile" ] && echo '{"issues":[]}' > "$issuesFile"
+
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+# Issues are created from the decomposition above
+# Each issue gets:
+#   id: issue-<timestamp>-<N>
+#   title, description, priority, status: open
+#   assigneeId (from matched agent)
+#   projectId, workspaceId (if provided)
+#   blockedByIssueIds (resolved after all issues are created)
+#   createdAt, updatedAt
+
+echo ""
+if [ "${dry_run:-false}" = "true" ]; then
+  echo "DRY RUN — no issues were created."
+  echo "Remove --dry-run to create these issues."
+else
+  echo "CREATED ISSUES:"
+  # (issue creation happens inline above as each issue is decomposed)
+fi
+```
+
+---
+
+## Step 5 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: plan-to-tasks
+org_name: <org_name>
+issues_created: <N>
+dry_run: <true|false>
+```
+
+---
+
+## Step 6 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.