monomind 1.18.15 → 2.0.0

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

@@ -1,254 +0,0 @@
----
-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/.claude/skills/mastermind-skills/orgs.md

@@ -1,98 +0,0 @@
----
-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/.claude/skills/mastermind-skills/orgstatus.md

@@ -1,194 +0,0 @@
----
-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/.claude/skills/mastermind-skills/plan-to-tasks.md

@@ -1,136 +0,0 @@
----
-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`.