@monoes/monomindcli 1.8.0 → 1.9.0

package/.claude/skills/mastermind/build.md

@@ -0,0 +1,158 @@
+---
+name: mastermind-build
+description: Mastermind build domain — development automation for features, bugs, refactors, and code review. Spawns a Development Manager agent who creates monotask tasks and coordinates specialized sub-agent swarms.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Build Domain
+
+This skill is invoked by `mastermind:master` or directly via `/mastermind:build`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via _protocol.md brain load)
+- `prompt`: the goal for this build 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 skill execution):** Single task, single agent, one file:
+- "Fix the typo in /src/auth.ts line 42"
+- "Add a console.log to debug X"
+→ Use the Edit tool or Task with a single coder agent. Skip manager delegation.
+
+**Complex (spawn Development Manager agent):** Any of these:
+- 3+ files to create/modify
+- Requires frontend + backend + testing
+- New feature with architecture decisions
+- Performance optimization across modules
+- Security fix with audit trail needed
+→ Spawn Development 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: `build`)
+2. Run intake from _intake.md if prompt is vague
+3. Create or find monotask space `<project_name>`, create board `development`
+4. Proceed with complexity assessment below
+5. At end: follow _protocol.md Brain Write Procedure (namespace: `build`)
+
+---
+
+## Complex Execution — Development Manager Agent
+
+Spawn a Development Manager agent via Task tool:
+
+```javascript
+Task({
+  subagent_type: "coordinator",
+  description: `You are the Development Manager for project <project_name>.
+
+CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:build
+
+BRAIN CONTEXT:
+<brain_context>
+
+YOUR BOARD: <board_id>
+YOUR GOAL: <prompt>
+
+STEP 1 — PLAN
+Decompose the goal into discrete development tasks. For each task, identify:
+- Which files are affected
+- What type of work it is (backend, frontend, test, review)
+- Dependencies between tasks
+- Estimated complexity
+
+STEP 2 — CREATE TASKS
+For each task, 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(.name == "Todo" or .name == "Backlog") | .id' | head -1)
+COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.name == "Done") | .id' | head -1)
+```
+Then create the card:
+```bash
+result=$(monotask card create "$BOARD_ID" "$COL_TODO_ID" "<short summary of task goal, ≤80 chars>" --json)
+CARD_ID=$(echo "$result" | jq -r '.id // empty')
+monotask card set-description "$BOARD_ID" "$CARD_ID" "[specific task goal]"
+monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Development Manager
+BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
+SCOPE: [exact file paths in scope]
+CONSTRAINTS: [must-not-break items, existing APIs to preserve]
+SUCCESS CRITERIA:
+- [ ] [checkable item]
+AGENT: [backend-dev | frontend-dev | tester | reviewer | sparc-coder]
+SWARM: hierarchical 4 raft
+DEPENDENCIES: [task IDs or \"none\"]
+OUTPUT FORMAT: unified output schema"
+```
+
+STEP 3 — EXECUTE
+Spawn one Task agent per task (all in parallel where dependencies allow):
+- Backend tasks: subagent_type "backend-dev"
+- Frontend tasks: subagent_type "frontend-dev"
+- Testing tasks: subagent_type "tester"
+- Code review: subagent_type "reviewer"
+- TDD/SPARC work: subagent_type "sparc-coder"
+
+Also run /monomind:do --board <board_id> to track execution.
+
+STEP 4 — COLLECT AND RETURN
+Collect all agent output schemas. Return to caller:
+
+domain: build
+status: complete | partial | blocked
+artifacts:
+  - path: [each file created/modified]
+    type: code
+decisions:
+  - what: [architectural decisions made]
+    why: [reasoning]
+    confidence: [0.0-1.0]
+    outcome: shipped | pending
+lessons:
+  - what_worked: [what helped]
+  - what_didnt: [what didn't]
+next_actions:
+  - [suggested follow-ups like "run mastermind:review"]
+board_url: monotask://<project_name>/development
+run_id: <ISO8601-timestamp>`,
+  run_in_background: true
+})
+```
+
+---
+
+## Simple Execution
+
+For simple tasks (single agent, single file):
+
+1. Spawn one Task agent with the task as a self-contained briefing
+2. Collect output
+3. Return unified output schema with `status: complete`
+
+---
+
+## Domain Swarm Defaults
+
+| Task Type | Agent | Swarm |
+|---|---|---|
+| Feature development | coordinator | hierarchical 6 raft specialized |
+| Bug fix | coder + tester | hierarchical 4 raft specialized |
+| Refactor | coordinator | hierarchical 5 raft specialized |
+| Performance | perf-analyzer + coder | star 4 parallel |
+| Security fix | security-architect + auditor | hive-mind hierarchical-mesh byzantine 6 |
+| Code review | reviewer | mesh 4 gossip balanced |

package/.claude/skills/mastermind/content.md

@@ -0,0 +1,185 @@
+---
+name: mastermind-content
+description: Mastermind content domain — blog posts, threads, docs, newsletters. Spawns a Content Manager who runs a ring pipeline (research→draft→edit→publish) for polished output.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Content Domain
+
+This skill is invoked by `mastermind:master` or directly via `/mastermind:content`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via _protocol.md brain load)
+- `prompt`: the content goal for this run
+- `project_name`: monotask space name
+- `board_id`: monotask board ID (set by master, or created standalone)
+- `mode`: auto | confirm
+
+---
+
+## Reference Library
+
+Before generating or editing any prose, identify which reference files apply and inject them into the agent briefing.
+
+| Reference | When to include |
+|---|---|
+| `.claude/skills/stop-slop/SKILL.md` | Stage 3 (Edit) and Stage 4 (Review) — not Draft |
+| `.claude/skills/stop-slop/references/phrases.md` | Full edit pass — check for banned phrases |
+| `.claude/skills/stop-slop/references/structures.md` | Full edit pass — check structural patterns |
+| `.claude/skills/stop-slop/references/examples.md` | When the agent needs before/after context |
+
+In each Edit/Review stage briefing (Stage 3), add:
+```
+REFERENCE FILES: Read these before editing:
+- .claude/skills/stop-slop/SKILL.md
+- .claude/skills/stop-slop/references/phrases.md
+- .claude/skills/stop-slop/references/structures.md
+```
+
+---
+
+## Complexity Assessment
+
+Assess the prompt to determine execution mode:
+
+**Simple (direct execution):** Single short piece, one agent:
+- "Write a one-paragraph product description"
+- "Draft a 280-character tweet about the release"
+→ Use a single Content Creator agent. Skip manager delegation.
+
+**Complex (spawn Content Manager agent):** Any of these:
+- Blog post or article (research + draft + edit)
+- Newsletter issue requiring multiple sections
+- Documentation rewrite or new doc set
+- Thread series across multiple posts
+- Content requiring subject matter research before writing
+→ Spawn Content Manager agent with ring pipeline.
+
+---
+
+## 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: `content`)
+2. Run intake from _intake.md if prompt is vague
+3. Create or find monotask space `<project_name>`, create board `content`
+4. Proceed with complexity assessment below
+5. At end: follow _protocol.md Brain Write Procedure (namespace: `content`)
+
+---
+
+## Complex Execution — Content Manager Agent
+
+Spawn a Content Manager agent via Task tool:
+
+```javascript
+Task({
+  subagent_type: "coordinator",
+  description: `You are the Content Manager for project <project_name>.
+
+CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:content
+
+BRAIN CONTEXT:
+<brain_context>
+
+YOUR BOARD: <board_id>
+YOUR GOAL: <prompt>
+
+STEP 1 — PLAN
+Decompose content production into sequential pipeline stages. The ring topology means output from each stage feeds the next:
+Stage 1: Research — gather facts, sources, angles
+Stage 2: Draft — produce first draft from research
+Stage 3: Edit — refine, fact-check, tone-align
+Stage 4: Format — structure for target platform
+
+Identify for each stage:
+- What input it receives from the prior stage
+- What deliverable it produces
+- Which specialist handles it
+
+STEP 2 — CREATE TASKS
+For each pipeline stage, 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 pipeline stage goal, ≤80 chars>" --json)
+CARD_ID=$(echo "$result" | jq -r '.id // empty')
+monotask card set-description "$BOARD_ID" "$CARD_ID" "[this stage's specific production goal]"
+monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Content Manager
+BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
+SCOPE: [content type, target audience, platform, word count, tone]
+CONSTRAINTS: [brand voice, SEO requirements, factual accuracy standards, style guide]
+REFERENCE FILES: [for Stage 3 edit only: .claude/skills/stop-slop/SKILL.md, .claude/skills/stop-slop/references/phrases.md, .claude/skills/stop-slop/references/structures.md]
+SUCCESS CRITERIA:
+- [ ] [checkable item]
+AGENT: [researcher | Content Creator | Technical Writer | Code Reviewer (as editor)]
+SWARM: ring 4 raft pipeline
+DEPENDENCIES: [prior stage task ID — pipeline is sequential]
+OUTPUT FORMAT: unified output schema"
+```
+
+STEP 3 — EXECUTE
+Spawn Task agents in pipeline order (ring topology — each must complete before next starts):
+Stage 1 research: subagent_type "researcher"
+Stage 2 draft: subagent_type "Content Creator"
+Stage 3 edit: subagent_type "Technical Writer"
+Stage 4 format/publish: subagent_type "Content Creator"
+
+Also run /monomind:do --board <board_id> to track execution.
+
+STEP 4 — COLLECT AND RETURN
+Collect the final formatted content. Return to caller:
+
+domain: content
+status: complete | partial | blocked
+artifacts:
+  - path: [path to final content file]
+    type: copy
+decisions:
+  - what: [angle, tone, or structure decisions made]
+    why: [reasoning]
+    confidence: [0.0-1.0]
+    outcome: shipped | pending
+lessons:
+  - what_worked: [what produced the strongest draft]
+  - what_didnt: [what required multiple iterations]
+next_actions:
+  - [e.g. "run mastermind:marketing to distribute the content"]
+  - [e.g. "run mastermind:review for final quality check"]
+board_url: monotask://<project_name>/content
+run_id: <ISO8601-timestamp>`,
+  run_in_background: true
+})
+```
+
+---
+
+## Simple Execution
+
+For simple tasks (single agent, short-form content):
+
+1. Spawn one Task agent with the content 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 article / blog post | researcher → writer → editor | ring 4 raft pipeline |
+| Newsletter | coordinator + writers | ring 4 raft pipeline |
+| Documentation rewrite | Technical Writer + researcher | ring 4 raft pipeline |
+| Social thread | Content Creator | hierarchical 3 raft specialized |
+| Short-form copy | Content Creator | single agent |

package/.claude/skills/mastermind/createorg.md

@@ -0,0 +1,318 @@
+---
+name: mastermind-createorg
+description: Mastermind createorg — design, configure, and persist an autonomous agent organization with named roles, hierarchy, and communication topology. Suggests org structure from a goal description and saves the definition for later use with runorg.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Create Org
+
+This skill is invoked by `mastermind:createorg` or directly via `/mastermind:createorg`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `prompt`: goal and/or role description for this org
+- `org_name`: desired name for the org (slug, e.g. `content-team`); constrained to `[a-z0-9-]`
+- `roles_desc`: optional explicit role list from user (e.g. "boss, content writer, reviewer, marketer, designer, middle manager")
+- `mode`: auto | confirm
+- `session_id`: session ID passed by command wrapper (snake_case input)
+- `caller`: command | master
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command" (i.e. invoked directly, not by the command wrapper), load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+If `caller` is "command", use the `brain_context` already provided.
+
+Run intake from `_intake.md` if `prompt` is vague (stop at Q3, domain is `ops`). Skip intake if `prompt` is a rich prompt per _intake.md criteria.
+
+---
+
+## Step 1 — Resolve Org Name
+
+If `org_name` is not provided, extract the most prominent product/team noun from `prompt`, slugify it (lowercase, spaces → hyphens, strip non-`[a-z0-9-]` chars), and confirm with the user. Fallback: `org-<YYYYMMDD>`.
+
+Reject any `org_name` that does not match `^[a-z0-9][a-z0-9-]{0,63}$`.
+
+---
+
+## Step 2 — Ingest Roles
+
+Parse `roles_desc` (if provided) into a list of role titles. If not provided, derive a set of roles from `prompt` by identifying the human functions needed to achieve the goal.
+
+**Required roles to always include** (if the prompt implies a team):
+- A coordinator/boss role that owns the goal and makes final decisions
+- At least one executor role that does the primary work
+- A reviewer or QA role if quality output is implied
+- A communication layer (middle manager) if team size ≥ 4
+
+**Role → Agent Type mapping table** (use exact `subagent_type` slug for Task tool):
+
+| User role keyword | Agent type slug | Specialty |
+|---|---|---|
+| boss / ceo / director / lead / chief | `coordinator` | Strategic oversight, final decisions |
+| content writer / writer / copywriter | `Content Creator` | Blog posts, copy, articles |
+| content reviewer / editor | `reviewer` | Review quality, accuracy, tone (use `reviewer`, not `Code Reviewer`) |
+| marketer / marketing / growth | `Growth Hacker` | Campaigns, acquisition, channels |
+| designer / ui / ux / visual | `Monodesign` | Visuals, UI, brand |
+| middle manager / manager | `Project Shepherd` | Sprint planning, cross-team coordination |
+| engineer / developer / coder / dev | `coder` | Code implementation |
+| researcher / analyst | `researcher` | Research, data, insights |
+| seo / search | `SEO Specialist` | SEO, search strategy |
+| social media / social | `Social Media Strategist` | Social content and engagement |
+| product / product manager | `Product Manager` | Roadmap, prioritization |
+| qa / tester | `tester` | Quality assurance, testing |
+
+If a role doesn't match any keyword, use `general-purpose` and note it in the org config.
+
+---
+
+## Step 3 — Suggest Communication Topology
+
+Determine topology from team size:
+- 1–3 roles → `mesh` (all communicate directly)
+- 4–6 roles → `star` (boss at center, all report to boss)
+- 7+ roles → `hierarchical` (boss → middle manager(s) → executors)
+
+Build directed communication edges:
+
+**Communication edge types:**
+- `command`: top-down direction of work
+- `report`: bottom-up status / output delivery
+- `feedback`: peer review or critique
+- `handoff`: one role passes output directly to next role in sequence
+
+**Default edges for a 6-role org (boss, content writer, content reviewer, marketer, designer, middle manager):**
+```
+boss → middle_manager (command)
+middle_manager → content_writer (command)
+middle_manager → designer (command)
+middle_manager → marketer (command)
+content_writer → content_reviewer (handoff)
+content_reviewer → middle_manager (report)
+designer → middle_manager (report)
+marketer → middle_manager (report)
+middle_manager → boss (report)
+boss → middle_manager (feedback)
+```
+
+Adjust for the actual roles in this run. Assign `reports_to` on each role using the derived topology.
+
+---
+
+## Step 4 — Build Org Config
+
+Produce an org config object using the resolved topology (not hardcoded to `hierarchical`):
+
+```json
+{
+  "name": "<org_name>",
+  "goal": "<the goal the org exists to achieve>",
+  "created_at": "<ISO8601>",
+  "mode": "daemon",
+  "topology": "<mesh | star | hierarchical — from Step 3>",
+  "roles": [
+    {
+      "id": "<slug>",
+      "title": "<display title>",
+      "agent_type": "<subagent_type slug from mapping table>",
+      "responsibilities": ["<1-3 bullet responsibilities>"],
+      "reports_to": "<role id or null>"
+    }
+  ],
+  "communication": [
+    {
+      "from": "<role_id>",
+      "to": "<role_id>",
+      "type": "command | report | feedback | handoff",
+      "protocol": "direct"
+    }
+  ],
+  "board_id": "<uuid — filled in Step 6 after board creation>",
+  "todo_col_id": "<uuid — filled in Step 6>",
+  "doing_col_id": "<uuid — filled in Step 6>",
+  "done_col_id": "<uuid — filled in Step 6>",
+  "board_space": "<org_name>",
+  "board_name": "org-tasks",
+  "run_config": {
+    "checkpoint_interval_min": 30,
+    "max_concurrent_agents": 6,
+    "memory_namespace": "org:<org_name>"
+  }
+}
+```
+
+---
+
+## Step 5 — Show Plan and Confirm (confirm mode)
+
+Render the org plan in a clear human-readable format:
+
+```
+╔══════════════════════════════════════════════════╗
+║  ORG: <org_name>                                 ║
+║  GOAL: <goal>                                    ║
+╚══════════════════════════════════════════════════╝
+
+ROLES
+─────
+• [boss] CEO / Boss
+    Agent: coordinator
+    Reports to: (none — top of hierarchy)
+    Responsibilities: Strategic oversight, final approval
+
+• [middle_manager] Middle Manager
+    Agent: Project Shepherd
+    Reports to: boss
+    Responsibilities: Sprint planning, cross-team coordination
+
+  ... (all roles)
+
+COMMUNICATION TOPOLOGY
+──────────────────────
+boss → middle_manager  (command)
+middle_manager → content_writer  (command)
+content_writer → content_reviewer  (handoff)
+content_reviewer → middle_manager  (report)
+  ... (all edges)
+
+SETTINGS
+────────
+Topology: <derived>  |  Mode: persistent daemon
+Memory: org:<org_name>  |  Board: <org_name>/org-tasks
+Checkpoint every: 30 min  |  Max agents: 6
+
+Type "go" to save this org, or describe changes.
+```
+
+In **auto** mode, skip the confirmation prompt.
+
+If the user requests changes, apply them and re-render. Repeat until confirmed.
+
+---
+
+## Step 6 — Save Org Config
+
+Set shell variables from the resolved inputs (use the actual `org_name` value from Step 1 and `session_id` input):
+
+```bash
+org_name="<resolved org name from Step 1>"   # e.g. "content-team"
+session_id="<session_id input>"               # passed by command wrapper
+orgJson=".monomind/orgs/${org_name}.json"
+mkdir -p .monomind/orgs
+```
+
+Write the confirmed org config as JSON using `jq` to guarantee valid encoding:
+
+```bash
+# Build the config JSON from the confirmed org plan and write atomically
+# (Claude constructs the full jq expression from the confirmed roles/edges in Step 5)
+jq -n \
+  --arg name "$org_name" \
+  --arg goal "$goal" \
+  --arg topology "$topology" \
+  --argjson roles "$roles_json" \
+  --argjson communication "$communication_json" \
+  '{name:$name,goal:$goal,mode:"daemon",topology:$topology,
+    created_at:(now|todate),roles:$roles,communication:$communication,
+    board_space:$name,board_name:"org-tasks",
+    run_config:{checkpoint_interval_min:30,max_concurrent_agents:6,memory_namespace:("org:"+$name)}}' \
+  > "${orgJson}.tmp" && mv "${orgJson}.tmp" "$orgJson"
+```
+
+Create the monotask space, board, and default columns:
+```bash
+space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$org_name" '$2==n{print $1}' | head -1)
+[ -z "$space_id" ] && space_id=$(monotask space create "$org_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}')
+board_id=$(monotask board create "org-tasks" --json | jq -r '.id')
+[ -z "$board_id" ] && { echo "ERROR: Failed to create monotask board — verify monotask is installed (run: monotask --version)"; exit 1; }
+todo_col_id=$(monotask column create "$board_id" "Todo" --json | jq -r '.id')
+doing_col_id=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
+done_col_id=$(monotask column create "$board_id" "Done" --json | jq -r '.id')
+[ -n "$space_id" ] && monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
+```
+
+Patch the saved org config with the board and column IDs:
+```bash
+tmp="${orgJson}.tmp"
+jq --arg board_id "$board_id" \
+   --arg todo_col_id "$todo_col_id" \
+   --arg doing_col_id "$doing_col_id" \
+   --arg done_col_id "$done_col_id" \
+   '. + {board_id:$board_id,todo_col_id:$todo_col_id,doing_col_id:$doing_col_id,done_col_id:$done_col_id}' \
+   "$orgJson" > "$tmp" && mv "$tmp" "$orgJson"
+```
+
+---
+
+## Step 7 — Emit Dashboard Events
+
+Read values from the saved JSON file and emit two events: `domain:complete` (for the session stream) and `org:create` (so the dashboard Orgs panel registers the new org immediately):
+
+```bash
+orgName=$(jq -r '.name' "$orgJson")
+goal_val=$(jq -r '.goal' "$orgJson")
+rolesCount=$(jq '.roles | length // 0' "$orgJson")
+
+# domain:complete — for session correlation
+curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg orgName "$orgName" \
+    --arg goal "$goal_val" \
+    --argjson rolesCount "$rolesCount" \
+    '{type:"domain:complete",session:$session,domain:"ops",status:"complete",
+      org:$orgName,goal:$goal,roles_count:$rolesCount,ts:(now*1000|floor)}')" || true
+
+# org:create — so handleOrgEvent routes it to the Orgs panel event log
+curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg org "$orgName" \
+    --arg goal "$goal_val" \
+    '{type:"org:create",session:$session,org:$org,goal:$goal,ts:(now*1000|floor)}')" || true
+```
+
+---
+
+## Step 8 — Return Output
+
+```yaml
+domain: ops
+status: complete
+artifacts:
+  - path: .monomind/orgs/<org_name>.json
+    type: config
+decisions:
+  - what: "Org <org_name> created with N roles"
+    why: "Role mapping derived from goal and user description"
+    confidence: 0.85
+    outcome: shipped
+lessons:
+  - what_worked: "Auto-suggested roles matched user intent"
+  - what_didnt: ""
+next_actions:
+  - "Run /mastermind:runorg --org <org_name> to start the organization"
+  - "Edit .monomind/orgs/<org_name>.json to customize roles or communication"
+board_url: "monotask://<org_name>/org-tasks"
+run_id: "<current UTC datetime as ISO8601, e.g. via $(date -u +%Y-%m-%dT%H:%M:%SZ)>"
+```
+
+Print confirmation:
+```
+✓ Org "<org_name>" saved to .monomind/orgs/<org_name>.json
+  → Run: /mastermind:runorg --org <org_name>
+```
+
+---
+
+## Step 9 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.