monomind 1.16.6 → 1.16.7

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

@@ -0,0 +1,170 @@
+---
+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. 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 "development" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create development board"; exit 1; }
+   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: `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(.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 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 /mastermind: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/packages/@monomind/cli/.claude/skills/mastermind/code-quality-reviewer-prompt.md

@@ -0,0 +1,60 @@
+# Code Quality Reviewer Prompt Template
+
+Use this template when dispatching a code quality reviewer subagent from `mastermind:taskdev`.
+
+**Purpose:** Verify implementation is well-built — clean, tested, maintainable.
+
+**Only dispatch AFTER spec compliance review passes (✅).** Never run this first.
+
+```
+Task tool (general-purpose):
+  description: "Code quality review for Task N: [task name]"
+  prompt: |
+    You are reviewing the code quality of a recently implemented task.
+
+    ## Task Summary
+
+    [From implementer's report — what was built]
+
+    ## Diff to Review
+
+    BASE_SHA: [commit before task]
+    HEAD_SHA: [current commit after task]
+
+    Review the changes introduced between these commits.
+
+    ## What to Check
+
+    **Code quality:**
+    - Is the code clean and maintainable?
+    - Are names clear and accurate (match what things do, not how they work)?
+    - Is there duplication that could be DRY'd up?
+    - Are there magic numbers or hardcoded strings that should be constants?
+
+    **File structure:**
+    - Does each file have one clear responsibility with a well-defined interface?
+    - Are units decomposed so they can be understood and tested independently?
+    - Is the implementation following the file structure from the plan?
+    - Did this task create new files that are already large, or significantly grow
+      existing files? (Focus on what this change contributed, not pre-existing sizes.)
+
+    **Tests:**
+    - Do tests actually verify behavior (not just mock behavior)?
+    - Is test coverage adequate for the functionality added?
+    - Are tests readable and well-named?
+
+    **YAGNI / over-engineering:**
+    - Was anything built that wasn't needed?
+    - Is any abstraction premature?
+
+    ## Report Format
+
+    Return:
+    - **Strengths:** What was done well
+    - **Issues (Critical):** Must fix before proceeding
+    - **Issues (Important):** Should fix — notable quality problems
+    - **Issues (Minor):** Nice to have — low priority
+    - **Assessment:** ✅ Approved | ❌ Needs fixes
+
+    If issues are found, the implementer will fix them and you will re-review.
+```

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

@@ -0,0 +1,256 @@
+---
+name: mastermind-companies
+description: Mastermind companies — multi-org management. List all orgs with agent/issue stats, switch the active org, rename an org, delete an org (with confirmation), and view per-org summary. Mirrors Companies.tsx.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Companies
+
+This skill is invoked by `mastermind:companies` or directly via `/mastermind:companies`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `action`: list | select | rename | delete | stats | create
+- `org_name`: org name to target (required for select/rename/delete/stats)
+- `new_name`: new org name (required for rename)
+- `confirm`: yes (required second step for delete)
+- `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 — Locate All Orgs
+
+```bash
+orgsDir=".monomind/orgs"
+[ ! -d "$orgsDir" ] && { echo "No orgs directory found. Run /mastermind:createorg to create your first org."; exit 0; }
+
+# Collect all org names from .json files (not -members, -issues, etc.)
+orgNames=$(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' | xargs -I{} basename {} .json | sort)
+
+# Track active org
+activeFile=".monomind/active-org"
+activeOrg=$([ -f "$activeFile" ] && cat "$activeFile" || echo "")
+```
+
+---
+
+## Step 2 — Execute Action
+
+### list (default)
+
+```bash
+echo "ORGS"
+echo "────────────────────────────────────────────────────────"
+printf "%-22s %-8s %-8s %-8s %s\n" "NAME" "AGENTS" "ISSUES" "MEMBERS" "STATUS"
+echo "────────────────────────────────────────────────────────"
+
+[ -z "$orgNames" ] && { echo "  No orgs found. Create one: /mastermind:createorg"; exit 0; }
+
+echo "$orgNames" | while read -r name; do
+  orgFile="$orgsDir/${name}.json"
+  [ ! -f "$orgFile" ] && continue
+
+  agents=$(jq -r '(.roles // []) | length' "$orgFile" 2>/dev/null || echo 0)
+  issues=$([ -f "$orgsDir/${name}-issues.json" ] && jq '[(.issues // [])[] | select(.status == "open" or .status == "in_progress")] | length' "$orgsDir/${name}-issues.json" 2>/dev/null || echo 0)
+  members=$([ -f "$orgsDir/${name}-members.json" ] && jq '.members | length' "$orgsDir/${name}-members.json" 2>/dev/null || echo 0)
+  status=$([ "$name" = "$activeOrg" ] && echo "● ACTIVE" || echo "")
+
+  printf "%-22s %-8s %-8s %-8s %s\n" "$name" "$agents" "$issues" "$members" "$status"
+done
+
+echo ""
+total=$(echo "$orgNames" | wc -w | tr -d ' ')
+echo "  Total orgs: $total"
+[ -n "$activeOrg" ] && echo "  Active org: $activeOrg"
+echo ""
+echo "  Select:  --action select --org-name <name>"
+echo "  Rename:  --action rename --org-name <name> --new-name <new>"
+echo "  Delete:  --action delete --org-name <name>"
+```
+
+### select
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
+
+orgFile="$orgsDir/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '$org_name' not found."; exit 1; }
+
+echo "$org_name" > "$activeFile"
+echo "Active org set to: $org_name"
+echo "  All mastermind commands will default to this org."
+echo "  To use a different org, pass --org-name explicitly."
+```
+
+### rename
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
+[ -z "$new_name" ] && { echo "ERROR: --new-name required."; exit 1; }
+
+# Validate new name
+echo "$new_name" | grep -qE '^[a-z0-9][a-z0-9_-]*$' || {
+  echo "ERROR: --new-name must be lowercase alphanumeric with hyphens/underscores (e.g. my-org)."
+  exit 1
+}
+
+orgFile="$orgsDir/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '$org_name' not found."; exit 1; }
+
+[ -f "$orgsDir/${new_name}.json" ] && { echo "ERROR: Org '$new_name' already exists."; exit 1; }
+
+# Rename main config file
+mv "$orgFile" "$orgsDir/${new_name}.json"
+
+# Rename all associated files
+for suffix in state members issues goals projects routines approvals adapters plugins environments workspaces worktrees activity threads budgets project-workspaces approval-comments bootstrap secrets; do
+  f="$orgsDir/${org_name}-${suffix}.json"
+  [ -f "$f" ] && mv "$f" "$orgsDir/${new_name}-${suffix}.json"
+  f2="$orgsDir/${org_name}-${suffix}.jsonl"
+  [ -f "$f2" ] && mv "$f2" "$orgsDir/${new_name}-${suffix}.jsonl"
+done
+
+# Update name field inside config
+tmp="$orgsDir/${new_name}.json.tmp"
+jq --arg n "$new_name" '.name = $n' "$orgsDir/${new_name}.json" > "$tmp" && mv "$tmp" "$orgsDir/${new_name}.json"
+
+# Update active org pointer if needed
+[ "$(cat "$activeFile" 2>/dev/null)" = "$org_name" ] && echo "$new_name" > "$activeFile"
+
+echo "Org renamed: $org_name → $new_name"
+```
+
+### delete
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
+
+orgFile="$orgsDir/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '$org_name' not found."; exit 1; }
+
+if [ "${confirm:-}" != "yes" ]; then
+  agentCount=$(jq '(.roles // []) | length' "$orgFile" 2>/dev/null || echo "?")
+  echo "DELETE CONFIRMATION REQUIRED"
+  echo "────────────────────────────────────────────────────────"
+  echo "  Org:    $org_name"
+  echo "  Agents: $agentCount"
+  echo ""
+  echo "  This will permanently delete the org and ALL associated data."
+  echo "  To confirm: --action delete --org-name $org_name --confirm yes"
+  exit 0
+fi
+
+# Delete all org files
+rm -f "$orgsDir/${org_name}.json"
+for suffix in state members issues goals projects routines approvals adapters plugins environments workspaces worktrees activity threads budgets project-workspaces approval-comments bootstrap secrets; do
+  rm -f "$orgsDir/${org_name}-${suffix}.json"
+  rm -f "$orgsDir/${org_name}-${suffix}.jsonl"
+done
+
+# Clear active org if it was this org
+[ "$(cat "$activeFile" 2>/dev/null)" = "$org_name" ] && rm -f "$activeFile"
+
+echo "Org '$org_name' deleted permanently."
+echo "  All associated data removed."
+```
+
+### stats
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
+
+orgFile="$orgsDir/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '$org_name' not found."; exit 1; }
+
+echo "ORG STATS — $org_name"
+echo "────────────────────────────────────────────────────────"
+
+# Agent stats
+agents=$(jq '(.roles // []) | length' "$orgFile")
+gov=$(jq -r '.governance // "(not set)"' "$orgFile")
+echo "  Agents:        $agents"
+echo "  Governance:    $gov"
+
+# Issues
+if [ -f "$orgsDir/${org_name}-issues.json" ]; then
+  total=$(jq '.issues | length' "$orgsDir/${org_name}-issues.json")
+  open=$(jq '[(.issues // [])[] | select(.status == "open" or .status == "in_progress")] | length' "$orgsDir/${org_name}-issues.json")
+  done=$(jq '[(.issues // [])[] | select(.status == "done")] | length' "$orgsDir/${org_name}-issues.json")
+  echo "  Issues:        $total total  ($open open, $done done)"
+fi
+
+# Goals
+[ -f "$orgsDir/${org_name}-goals.json" ] && echo "  Goals:         $(jq '.goals | length' "$orgsDir/${org_name}-goals.json")"
+
+# Projects
+[ -f "$orgsDir/${org_name}-projects.json" ] && echo "  Projects:      $(jq '.projects | length' "$orgsDir/${org_name}-projects.json")"
+
+# Members
+[ -f "$orgsDir/${org_name}-members.json" ] && echo "  Members:       $(jq '.members | length' "$orgsDir/${org_name}-members.json")"
+
+# Routines
+[ -f "$orgsDir/${org_name}-routines.json" ] && echo "  Routines:      $(jq '.routines | length' "$orgsDir/${org_name}-routines.json")"
+
+# Pending approvals
+if [ -f "$orgsDir/${org_name}-approvals.json" ]; then
+  pending=$(jq '[(.approvals // [])[] | select(.status == "pending")] | length' "$orgsDir/${org_name}-approvals.json")
+  echo "  Pending approvals: $pending"
+fi
+```
+
+### create
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
+
+echo "$org_name" | grep -qE '^[a-z0-9][a-z0-9_-]*$' || {
+  echo "ERROR: --org-name must be lowercase alphanumeric with hyphens/underscores."
+  exit 1
+}
+
+orgFile="$orgsDir/${org_name}.json"
+[ -f "$orgFile" ] && { echo "ERROR: Org '$org_name' already exists."; exit 1; }
+
+mkdir -p "$orgsDir"
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+cat > "$orgFile" <<EOF
+{
+  "name": "$org_name",
+  "governance": "auto",
+  "roles": [],
+  "created_at": "$ts"
+}
+EOF
+
+echo "Org '$org_name' created."
+echo "  Add agents: /mastermind:new-agent --org $org_name --title 'My Agent'"
+echo "  Run:        /mastermind:runorg --org $org_name"
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org_name: <org_name>
+active_org: <active_org>
+```
+
+---
+
+## 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/content.md

@@ -0,0 +1,197 @@
+---
+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. 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 "content" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create content board"; exit 1; }
+   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: `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 /mastermind: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 |