@monoes/monomindcli 1.9.16 → 1.10.0

package/.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 "WARNING: Parent agent '$reports_to' not found in org. Setting anyway."
+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/.claude/skills/mastermind/org-chart.md

@@ -0,0 +1,207 @@
+---
+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", {})
+        atype = adapter.get("type", "?") if isinstance(adapter, dict) else str(adapter)
+        model = adapter.get("model", "") if isinstance(adapter, dict) 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 '.[] |
+  [.id, (.title // "-"), (.adapter.type // "?"), (.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" '.[] |
+  select(
+    (.id | ascii_downcase | contains($q)) or
+    (.title // "" | ascii_downcase | contains($q)) or
+    (.adapter.type // "" | ascii_downcase | contains($q)) or
+    (.adapter.model // "" | ascii_downcase | contains($q))
+  ) |
+  [.id, (.title // "-"), (.adapter.type // "?"), (.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`.

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

@@ -0,0 +1,217 @@
+---
+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)
+    jq --arg v "$value" '.name = $v' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
+    echo "Updated: name → $value"
+    ;;
+  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}"
+
+# Merge all org data files into one export bundle
+jq -n \
+  --slurpfile config "$orgFile" \
+  --slurpfile goals ".monomind/orgs/${org_name}-goals.json" 2>/dev/null \
+  --slurpfile routines ".monomind/orgs/${org_name}-routines.json" 2>/dev/null \
+  --slurpfile projects ".monomind/orgs/${org_name}-projects.json" 2>/dev/null \
+  '{
+    exported_at: (now|todate),
+    format_version: "1.0",
+    config: ($config[0] // {}),
+    goals: ($goals[0].goals // []),
+    routines: ($routines[0].routines // []),
+    projects: ($projects[0].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
+jq '.config' "$import_path" > ".monomind/orgs/${targetOrg}.json"
+
+# Write goals if present
+goalsData=$(jq '.goals // []' "$import_path")
+[ "$goalsData" != "[]" ] && echo "{\"goals\":$goalsData}" > ".monomind/orgs/${targetOrg}-goals.json"
+
+# Write routines if present
+routinesData=$(jq '.routines // []' "$import_path")
+[ "$routinesData" != "[]" ] && echo "{\"routines\":$routinesData}" > ".monomind/orgs/${targetOrg}-routines.json"
+
+# Write projects if present
+projectsData=$(jq '.projects // []' "$import_path")
+[ "$projectsData" != "[]" ] && echo "{\"projects\":$projectsData}" > ".monomind/orgs/${targetOrg}-projects.json"
+
+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`.