monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/skills/mastermind/new-agent.md

@@ -0,0 +1,241 @@
+---
+name: mastermind-new-agent
+description: Mastermind new-agent — wizard to hire/create a new agent within an org. Configures adapter type, model, role name, reports_to hierarchy, governance policy, skill assignments, and budget. Writes the new role to the org config file.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind New Agent
+
+This skill is invoked by `mastermind:new-agent` or directly via `/mastermind:new-agent`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to add the agent to (required)
+- `action`: create | preview | list-roles | list-adapters
+- `agent_id`: unique slug for the new agent (required for create; auto-generated if omitted)
+- `title`: display title for the agent (required for create)
+- `adapter_type`: claude-local | gemini-local | codex-local | cursor | opencode | hermes | http | acpx (default: claude-local)
+- `model`: model identifier (e.g. claude-sonnet-4-6, claude-opus-4-7, gemini-2.0-flash)
+- `max_tokens`: max tokens per run (default: 8192)
+- `reports_to`: parent agent id in the hierarchy (null = top-level)
+- `governance`: auto | board | strict (default: inherit from org)
+- `skills`: comma-separated skill names to assign (e.g. mastermind:tasks,mastermind:goals)
+- `budget_tokens`: per-run token budget cap (optional)
+- `heartbeat_enabled`: true | false (default: false)
+- `heartbeat_interval`: heartbeat interval in seconds (default: 900)
+- `system_prompt`: brief system prompt override (optional)
+- `caller`: command | master
+
+---
+
+## Adapter Types
+
+| Type | Description | Default Model |
+|------|-------------|---------------|
+| `claude-local` | Claude via Anthropic API | claude-sonnet-4-6 |
+| `gemini-local` | Gemini via Google API | gemini-2.0-flash |
+| `codex-local` | OpenAI Codex | gpt-4o |
+| `cursor` | Cursor IDE agent | cursor-default |
+| `opencode` | OpenCode agent | opencode-default |
+| `hermes` | Hermes local model | hermes-3 |
+| `http` | Custom HTTP adapter | (custom) |
+| `acpx` | ACPX protocol | (custom) |
+
+---
+
+## 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."; exit 1; }
+```
+
+---
+
+## Step 2 — Execute Action
+
+### list-adapters
+
+```bash
+echo "AVAILABLE ADAPTERS"
+echo "────────────────────────────────────────────────────────"
+cat <<'ADAPTERS'
+  claude-local    Claude via Anthropic API   (recommended)
+    Models: claude-sonnet-4-6, claude-opus-4-7, claude-haiku-4-5
+  gemini-local    Gemini via Google AI
+    Models: gemini-2.0-flash, gemini-1.5-pro
+  codex-local     OpenAI Codex
+    Models: gpt-4o, gpt-4o-mini, o3-mini
+  cursor          Cursor IDE agent
+  opencode        OpenCode agent
+  hermes          Hermes local LLM (Ollama)
+  http            Custom HTTP adapter endpoint
+  acpx            ACPX protocol adapter
+ADAPTERS
+```
+
+### list-roles
+
+```bash
+echo "CURRENT ROLES IN ORG: $org_name"
+echo "────────────────────────────────────────────────────────"
+printf "%-22s %-20s %-14s %s\n" "ID" "TITLE" "ADAPTER" "REPORTS TO"
+echo "────────────────────────────────────────────────────────"
+jq -r '(.roles // [])[] |
+  [.id, (.title // "-"), (.adapter.type // "claude-local"), (.reports_to // "(root)")] | @tsv' \
+  "$orgFile" | while IFS=$'\t' read -r id title adapter rt; do
+  printf "%-22s %-20s %-14s %s\n" "$id" "$title" "$adapter" "$rt"
+done
+```
+
+### preview
+
+```bash
+[ -z "$title" ] && { echo "ERROR: --title required for preview."; exit 1; }
+
+adapterType="${adapter_type:-claude-local}"
+modelId="${model}"
+# Default model per adapter
+if [ -z "$modelId" ]; then
+  case "$adapterType" in
+    claude-local)  modelId="claude-sonnet-4-6" ;;
+    gemini-local)  modelId="gemini-2.0-flash" ;;
+    codex-local)   modelId="gpt-4o" ;;
+    cursor)        modelId="cursor-default" ;;
+    opencode)      modelId="opencode-default" ;;
+    hermes)        modelId="hermes-3" ;;
+    *)             modelId="(custom)" ;;
+  esac
+fi
+
+# Generate slug if not set
+agentIdPreview="${agent_id}"
+if [ -z "$agentIdPreview" ]; then
+  agentIdPreview=$(echo "$title" | tr '[:upper:]' '[:lower:]' | tr -cs 'a-z0-9' '-' | sed 's/^-//;s/-$//')
+fi
+
+echo "PREVIEW — new agent to be added to org '$org_name'"
+echo "────────────────────────────────────────────────────────"
+echo "  ID:          $agentIdPreview"
+echo "  Title:       $title"
+echo "  Adapter:     $adapterType / $modelId"
+echo "  Max tokens:  ${max_tokens:-8192}"
+echo "  Reports to:  ${reports_to:-(root/top-level)}"
+echo "  Governance:  ${governance:-inherit}"
+echo "  Skills:      ${skills:-(none)}"
+echo "  Budget:      ${budget_tokens:-(unlimited)}"
+echo "  Heartbeat:   ${heartbeat_enabled:-false} (${heartbeat_interval:-900}s)"
+[ -n "$system_prompt" ] && echo "  Prompt:      $system_prompt"
+echo ""
+echo "Run with --action create to add this agent to the org."
+```
+
+### create
+
+```bash
+[ -z "$title" ] && { echo "ERROR: --title required."; exit 1; }
+
+adapterType="${adapter_type:-claude-local}"
+modelId="${model}"
+if [ -z "$modelId" ]; then
+  case "$adapterType" in
+    claude-local)  modelId="claude-sonnet-4-6" ;;
+    gemini-local)  modelId="gemini-2.0-flash" ;;
+    codex-local)   modelId="gpt-4o" ;;
+    cursor)        modelId="cursor-default" ;;
+    opencode)      modelId="opencode-default" ;;
+    hermes)        modelId="hermes-3" ;;
+    *)             modelId="(custom)" ;;
+  esac
+fi
+
+# Generate id from title if not provided
+if [ -z "$agent_id" ]; then
+  agent_id=$(echo "$title" | tr '[:upper:]' '[:lower:]' | tr -cs 'a-z0-9' '-' | sed 's/^-//;s/-$//')
+fi
+
+# Check for duplicate id
+duplicate=$(jq -r --arg id "$agent_id" '[(.roles // [])[] | select(.id == $id)] | length' "$orgFile")
+[ "$duplicate" -gt 0 ] && { echo "ERROR: Agent id '$agent_id' already exists in org '$org_name'. Use --agent-id to specify a unique id."; exit 1; }
+
+# Validate reports_to if set
+if [ -n "$reports_to" ]; then
+  parentExists=$(jq -r --arg pid "$reports_to" '[(.roles // [])[] | select(.id == $pid)] | length' "$orgFile")
+  [ "$parentExists" -eq 0 ] && { echo "ERROR: Parent agent '$reports_to' not found in org '${org_name}'. Check the agent ID with /mastermind:org-chart --org ${org_name}."; exit 1; }
+fi
+
+# Build skills array
+skillsArray="[]"
+if [ -n "$skills" ]; then
+  skillsArray=$(echo "$skills" | tr ',' '\n' | jq -Rsc 'split("\n") | map(select(. != ""))')
+fi
+
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+tmp="${orgFile}.tmp"
+jq --arg id "$agent_id" \
+   --arg title "$title" \
+   --arg adapter "$adapterType" \
+   --arg model "$modelId" \
+   --argjson maxTok "${max_tokens:-8192}" \
+   --arg rt "${reports_to:-}" \
+   --arg gov "${governance:-}" \
+   --argjson skills "$skillsArray" \
+   --argjson budget "${budget_tokens:-null}" \
+   --argjson hbEnabled "${heartbeat_enabled:-false}" \
+   --argjson hbInterval "${heartbeat_interval:-900}" \
+   --arg prompt "${system_prompt:-}" \
+   --arg ts "$ts" \
+  '.roles += [{
+    "id": $id,
+    "title": $title,
+    "adapter": {"type": $adapter, "model": $model, "max_tokens": $maxTok},
+    "reports_to": (if $rt != "" then $rt else null end),
+    "governance": (if $gov != "" then $gov else null end),
+    "skills": $skills,
+    "budget_tokens": $budget,
+    "heartbeat": {"enabled": $hbEnabled, "interval": $hbInterval},
+    "system_prompt": (if $prompt != "" then $prompt else null end),
+    "created_at": $ts
+  }]' \
+  "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
+
+echo "Agent created: $agent_id"
+echo "  Title:    $title"
+echo "  Adapter:  $adapterType / $modelId"
+echo "  Reports:  ${reports_to:-(root)}"
+echo "  Skills:   ${skills:-(none)}"
+echo ""
+echo "Org '${org_name}' now has $(jq '.roles | length' "$orgFile") agent(s)."
+echo "View: /mastermind:agent-detail --org $org_name --agent-id $agent_id"
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+agent_id: <agent_id>
+adapter_type: <type>
+model: <model>
+```
+
+---
+
+## 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/ops.md

@@ -0,0 +1,168 @@
+---
+name: mastermind-ops
+description: Mastermind ops domain — workflow automation, reporting, process optimization. Spawns an Ops Manager coordinating automation and reporting agents in parallel.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Ops Domain
+
+This skill is invoked by `mastermind:master` or directly via `/mastermind:ops`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via _protocol.md brain load)
+- `prompt`: the operations goal for this run
+- `project_name`: monotask space name
+- `board_id`: monotask board ID (set by master, or created standalone)
+- `mode`: auto | confirm
+
+---
+
+## Complexity Assessment
+
+Assess the prompt to determine execution mode:
+
+**Simple (direct execution):** Single process or single report:
+- "Generate a weekly status report from the task board"
+- "Document this manual workflow as a runbook"
+→ Use a single Workflow Optimizer or Analytics Reporter agent. Skip manager delegation.
+
+**Complex (spawn Ops Manager agent):** Any of these:
+- End-to-end workflow automation design and implementation
+- Multi-system integration (CI/CD + monitoring + alerting)
+- Reporting dashboard requiring multiple data sources
+- Process audit and optimization across multiple teams
+→ Spawn Ops Manager agent with full briefing.
+
+---
+
+## Standalone Execution (when called without master)
+
+If this skill is invoked directly (not by master):
+
+1. Load brain context following _protocol.md Brain Load Procedure (namespace: `ops`)
+2. Run intake from _intake.md if prompt is vague
+3. Follow _protocol.md Monotask Space+Board Setup Procedure:
+   ```bash
+   project_name="${project_name:-$(basename "$PWD")}"
+   space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$project_name" '$2==n{print $1}' | head -1)
+   [ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+   [ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$project_name'"; exit 1; }
+   board_id=$(monotask board create "ops" --json 2>/dev/null | jq -r '.id // empty')
+   [ -z "$board_id" ] && echo "[ops] monotask board unavailable — board tracking skipped."
+   monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
+   todo_col=$(monotask column create "$board_id" "Todo"  --json | jq -r '.id')
+   doing_col=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
+   done_col=$(monotask column create "$board_id" "Done"  --json | jq -r '.id')
+   ```
+4. Proceed with complexity assessment below
+5. At end: follow _protocol.md Brain Write Procedure (namespace: `ops`)
+
+---
+
+## Complex Execution — Ops Manager Agent
+
+Spawn an Ops Manager agent via Task tool:
+
+```javascript
+Task({
+  subagent_type: "coordinator",
+  description: `You are the Ops Manager for project <project_name>.
+
+CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:ops
+
+BRAIN CONTEXT:
+<brain_context>
+
+YOUR BOARD: <board_id>
+YOUR GOAL: <prompt>
+
+STEP 1 — PLAN
+Decompose the ops goal into parallel workstreams. For each workstream, identify:
+- What process, system, or workflow it covers
+- Whether it's automation design, reporting, or optimization
+- What tools and integrations are involved
+- Dependencies between workstreams
+
+STEP 2 — CREATE TASKS
+For each workstream, create a monotask card on the project board. First look up column IDs and assign shell variables:
+```bash
+columns=$(monotask column list "$BOARD_ID" --json)
+COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Todo" or .title == "Backlog") | .id' | head -1)
+COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Done") | .id' | head -1)
+```
+Then create the card:
+```bash
+result=$(monotask card create "$BOARD_ID" "$COL_TODO_ID" "<short summary of workstream goal, ≤80 chars>" --json)
+CARD_ID=$(echo "$result" | jq -r '.id // empty')
+monotask card set-description "$BOARD_ID" "$CARD_ID" "[specific ops workstream goal]"
+monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Ops Manager
+BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
+SCOPE: [systems, tools, processes, integrations in scope]
+CONSTRAINTS: [existing tooling to preserve, compliance requirements, access restrictions]
+SUCCESS CRITERIA:
+- [ ] [checkable item — e.g. \"automation runs without manual intervention\"]
+AGENT: [Workflow Optimizer | Analytics Reporter | DevOps Automator | cicd-engineer]
+SWARM: star 4 parallel
+DEPENDENCIES: [task IDs or \"none\"]
+OUTPUT FORMAT: unified output schema"
+```
+
+STEP 3 — EXECUTE
+Spawn one Task agent per workstream (star topology — hub aggregates independent outputs):
+- Workflow design and automation: subagent_type "Workflow Optimizer"
+- Reporting and dashboards: subagent_type "Analytics Reporter"
+- Infrastructure automation: subagent_type "DevOps Automator"
+- CI/CD pipelines: subagent_type "cicd-engineer"
+
+Tasks are saved to `docs/tasks/` by default. To execute: `/mastermind:do --file <TASK_FILE>`. With monotask: `/mastermind:do --monotask --space $SPACE_ID --board $TASK_BOARD_ID`.
+
+STEP 4 — COLLECT AND RETURN
+Collect all agent outputs. Return to caller:
+
+domain: ops
+status: complete | partial | blocked
+artifacts:
+  - path: [automation scripts, runbooks, dashboard configs, reports]
+    type: config
+decisions:
+  - what: [automation approach, tooling decisions, process changes]
+    why: [reasoning]
+    confidence: [0.0-1.0]
+    outcome: shipped | pending
+lessons:
+  - what_worked: [what reduced toil or improved visibility most]
+  - what_didnt: [what required more manual intervention than expected]
+next_actions:
+  - [e.g. "run mastermind:review to audit the new automation"]
+  - [e.g. "run mastermind:release to deploy the ops changes"]
+board_url: monotask://<project_name>/ops
+run_id: <ISO8601-timestamp>`,
+  run_in_background: true
+})
+```
+
+---
+
+## Simple Execution
+
+For simple tasks (single agent, single deliverable):
+
+1. Spawn one Task agent with the ops request as a self-contained briefing
+2. Collect output
+3. Return unified output schema with `status: complete`
+
+---
+
+## Domain Swarm Defaults
+
+| Task Type | Agent | Swarm |
+|---|---|---|
+| Full workflow automation | coordinator + workflow + devops | star 4 parallel |
+| Reporting dashboard | Analytics Reporter + DevOps | star 3 parallel |
+| CI/CD pipeline setup | cicd-engineer | hierarchical 3 raft specialized |
+| Process audit | Workflow Optimizer | hierarchical 3 raft specialized |
+| Single report or runbook | Analytics Reporter | single agent |

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

@@ -0,0 +1,209 @@
+---
+name: mastermind-org-chart
+description: Mastermind org-chart — generates a text-based ASCII org chart for an org showing the agent hierarchy, adapter types, heartbeat status, and reports-to relationships. Supports tree view, flat list, and JSON export. Mirrors OrgChart.tsx canvas view as a CLI-friendly format.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Org Chart
+
+This skill is invoked by `mastermind:org-chart` or directly via `/mastermind:org-chart`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to chart (required)
+- `action`: show | flat | export | search
+- `query`: search term to filter agents in the chart (for search)
+- `output_file`: file path for JSON export (for export; default: stdout)
+- `depth`: max depth to render (default: unlimited)
+- `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 Roles
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
+
+roles=$(jq -r '.roles // []' "$orgFile")
+roleCount=$(echo "$roles" | jq 'length')
+
+# Load heartbeat state if available
+stateFile=".monomind/orgs/${org_name}-state.json"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### show (default)
+
+```bash
+echo "ORG CHART — $org_name"
+echo "════════════════════════════════════════════════════════"
+
+[ "$roleCount" -eq 0 ] && {
+  echo "  No agents in org '$org_name'."
+  echo "  Add one: /mastermind:new-agent --org $org_name --title 'My Agent'"
+  exit 0
+}
+
+# Build parent→children map using Python for recursive ASCII tree
+python3 - "$orgFile" "$stateFile" "${depth:-99}" <<'PYEOF'
+import json, sys, os
+
+orgFile = sys.argv[1]
+stateFile = sys.argv[2] if len(sys.argv) > 2 else None
+maxDepth = int(sys.argv[3]) if len(sys.argv) > 3 else 99
+
+with open(orgFile) as f:
+    org = json.load(f)
+
+roles = org.get("roles", [])
+
+# Load heartbeat state
+hb = {}
+if stateFile and os.path.exists(stateFile):
+    try:
+        with open(stateFile) as f:
+            state = json.load(f)
+        for r in state.get("roles", []):
+            hb[r.get("id", "")] = r.get("last_heartbeat")
+    except Exception:
+        pass
+
+# Build child map
+children = {}
+for r in roles:
+    pid = r.get("reports_to") or "__root__"
+    children.setdefault(pid, []).append(r)
+
+def render(nodes, prefix="", depth=0):
+    if depth > maxDepth:
+        return
+    for i, r in enumerate(nodes):
+        is_last = (i == len(nodes) - 1)
+        connector = "└── " if is_last else "├── "
+        child_prefix = prefix + ("    " if is_last else "│   ")
+        rid = r.get("id", "?")
+        title = r.get("title", rid)
+        adapter = r.get("adapter_config", r.get("adapter", {}))
+        model = adapter.get("model", "") if isinstance(adapter, dict) else ""
+        atype = model.split("-")[0] if model else "?"
+        hb_status = "♡" if rid not in hb or not hb[rid] else "♥"
+        gov = r.get("governance") or ""
+        gov_str = f" [{gov}]" if gov else ""
+        model_str = f"/{model}" if model else ""
+        print(f"{prefix}{connector}{title}  ({atype}{model_str}){gov_str}  {hb_status}")
+        kids = children.get(rid, [])
+        if kids:
+            render(kids, child_prefix, depth + 1)
+
+roots = children.get("__root__", [])
+# Include agents whose reports_to points to a non-existent id
+all_ids = {r.get("id") for r in roles}
+for r in roles:
+    pid = r.get("reports_to")
+    if pid and pid not in all_ids and r not in roots:
+        roots.append(r)
+
+render(roots)
+PYEOF
+
+echo ""
+echo "  $roleCount agent(s)  ·  ♥ heartbeat active  ♡ no heartbeat"
+echo "  Add agent:    /mastermind:new-agent --org $org_name --title 'Role Name'"
+echo "  Agent detail: /mastermind:agent-detail --org $org_name --agent-id <id>"
+```
+
+### flat
+
+```bash
+echo "AGENTS — $org_name (flat list)"
+echo "────────────────────────────────────────────────────────"
+printf "%-24s %-20s %-16s %-20s %s\n" "ID" "TITLE" "ADAPTER" "MODEL" "REPORTS TO"
+echo "────────────────────────────────────────────────────────"
+
+echo "$roles" | jq -r '.[] |
+  (((.adapter_config.model // .adapter.model) // "") | split("-") | .[0] | if . == "" then "?" else . end) as $atype |
+  [.id, (.title // "-"), $atype, ((.adapter_config.model // .adapter.model) // "-"),
+   (.reports_to // "(root)")] | @tsv' | \
+while IFS=$'\t' read -r id title adapter model rt; do
+  printf "%-24s %-20s %-16s %-20s %s\n" "$id" "$title" "$adapter" "$model" "$rt"
+done
+
+echo ""
+echo "Total: $roleCount"
+```
+
+### search
+
+```bash
+[ -z "$query" ] && { echo "ERROR: --query required."; exit 1; }
+
+echo "AGENT SEARCH — $org_name  query: '$query'"
+echo "────────────────────────────────────────────────────────"
+printf "%-24s %-20s %-16s %s\n" "ID" "TITLE" "ADAPTER" "REPORTS TO"
+echo "────────────────────────────────────────────────────────"
+
+ql=$(echo "$query" | tr '[:upper:]' '[:lower:]')
+echo "$roles" | jq -r --arg q "$ql" '.[] |
+  (((.adapter_config.model // .adapter.model) // "") | split("-") | .[0] | if . == "" then "?" else . end) as $atype |
+  select(
+    (.id | ascii_downcase | contains($q)) or
+    (.title // "" | ascii_downcase | contains($q)) or
+    ((.adapter_config.model // .adapter.model) // "" | ascii_downcase | contains($q)) or
+    (.agent_type // "" | ascii_downcase | contains($q))
+  ) |
+  [.id, (.title // "-"), $atype, (.reports_to // "(root)")] | @tsv' | \
+while IFS=$'\t' read -r id title adapter rt; do
+  printf "%-24s %-20s %-16s %s\n" "$id" "$title" "$adapter" "$rt"
+done
+```
+
+### export
+
+```bash
+outFile="${output_file:-}"
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+payload=$(jq --arg org "$org_name" --arg ts "$ts" \
+  '{org: $org, exportedAt: $ts, roles: (.roles // [])}' \
+  "$orgFile")
+
+if [ -n "$outFile" ]; then
+  mkdir -p "$(dirname "$outFile")"
+  echo "$payload" > "$outFile"
+  echo "Org chart exported: $outFile  ($roleCount agents)"
+else
+  echo "$payload" | jq .
+fi
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+agent_count: <N>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.