If you were dispatched as a subagent to execute a specific task, skip the MASTERMIND PROTOCOL section below and proceed directly to execution. --- ## MASTERMIND PROTOCOL If you think there is even a 1% chance a mastermind skill applies to what you are about to do, you ABSOLUTELY MUST invoke the skill — including before any clarifying questions or other action. IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE. YOU MUST INVOKE IT. This is not negotiable. This is not optional. You cannot rationalize your way out of this. ### Instruction Priority Mastermind skills override default system prompt behavior, but **user instructions always take precedence**: 1. **User's explicit instructions** (CLAUDE.md, GEMINI.md, AGENTS.md, direct requests, `$ARGUMENTS`) — highest priority 2. **Mastermind skills** — override default behavior where they conflict 3. **Default system prompt** — lowest priority If CLAUDE.md, GEMINI.md, or AGENTS.md says "skip review" and the skill says "always review," follow the user's instructions. ### How to Access Mastermind Skills > **Never read skill files manually with file tools.** Always use your platform's skill-loading mechanism so the skill is properly activated with its full harness context. **In Claude Code:** Use the `Skill` tool. When you invoke a skill, its content is loaded and presented to you — follow it directly. **In Copilot CLI:** Use the `skill` tool. Skills are auto-discovered from installed plugins and work the same as Claude Code's `Skill` tool. **In Gemini CLI:** Skills activate via the `activate_skill` tool. Gemini loads skill metadata at session start and activates the full content on demand. **In Codex:** Skills load natively. Follow the instructions presented when a skill activates. **In other environments:** Check your platform's documentation for how skills are loaded. ### Platform Adaptation Mastermind skills speak in actions ("dispatch a subagent", "invoke the skill tool", "create a todo") rather than naming any one runtime's tools. For per-platform tool equivalents and instructions-file conventions, see [claude-code-tools.md](references/claude-code-tools.md), [codex-tools.md](references/codex-tools.md), [copilot-tools.md](references/copilot-tools.md), [gemini-tools.md](references/gemini-tools.md), [pi-tools.md](references/pi-tools.md), and [antigravity-tools.md](references/antigravity-tools.md). Gemini CLI users get the tool mapping loaded automatically via GEMINI.md. ### User Instructions vs. Skill Workflows User instructions say **WHAT** to do, not **HOW** to do it. "Build X" or "Fix Y" is a goal statement — it does not mean skip Brain Load, skip review, or bypass the domain decomposition flow. The skills define the how. Always apply the workflow unless the user explicitly opts out. ### The Rule **Invoke the matching mastermind skill BEFORE any response or action.** Even a 1% chance a skill applies means you must check. If you invoke a skill and it turns out not to fit the situation, you don't need to follow it — but you must check first. ### Command-to-Skill Routing ```dot digraph mastermind_routing { "User command / prompt received" [shape=doublecircle]; "About to EnterPlanMode?" [shape=doublecircle]; "Already ran mastermind:design?" [shape=diamond]; "Invoke mastermind:design first" [shape=box]; "Brain already loaded?" [shape=diamond]; "Load brain (Brain Load Procedure)" [shape=box]; "Might a mastermind skill apply?" [shape=diamond]; "Invoke Skill() tool" [shape=box]; "Announce: Using [skill] for [purpose]" [shape=box]; "Has checklist?" [shape=diamond]; "Execute skill exactly" [shape=box]; "Respond or act (including clarifications)" [shape=doublecircle]; "About to EnterPlanMode?" -> "Already ran mastermind:design?"; "Already ran mastermind:design?" -> "Invoke mastermind:design first" [label="no"]; "Already ran mastermind:design?" -> "Brain already loaded?" [label="yes"]; "Invoke mastermind:design first" -> "Brain already loaded?"; "User command / prompt received" -> "Brain already loaded?"; "Brain already loaded?" -> "Load brain (Brain Load Procedure)" [label="no"]; "Brain already loaded?" -> "Might a mastermind skill apply?" [label="yes"]; "Load brain (Brain Load Procedure)" -> "Might a mastermind skill apply?"; "Might a mastermind skill apply?" -> "Invoke Skill() tool" [label="yes, even 1%"]; "Might a mastermind skill apply?" -> "Respond or act (including clarifications)" [label="definitely not"]; "Invoke Skill() tool" -> "Announce: Using [skill] for [purpose]"; "Announce: Using [skill] for [purpose]" -> "Has checklist?"; "Has checklist?" -> "Create TodoWrite item per checklist step" [label="yes"]; "Has checklist?" -> "Execute skill exactly" [label="no"]; "Create TodoWrite item per checklist step" -> "Execute skill exactly"; } ``` | Situation | Skill to invoke | |---|---| | Debug a bug, test failure, unexpected behavior | `Skill("mastermind-debug")` | | Verify a claim — tests pass, feature works, fix resolved | `Skill("mastermind-verify")` | | Write tests first, enforce Red-Green-Refactor | `Skill("mastermind-tdd")` | | Write a structured implementation plan (no placeholders) | `Skill("mastermind-plan")` | | Execute a written plan step-by-step with stop-on-blocker | `Skill("mastermind-execute")` | | Execute a plan via fresh subagents with 2-stage review | `Skill("mastermind-taskdev")` | | Fix or investigate 2+ independent problems concurrently (different files, subsystems, or bugs) | dispatch parallel subagents in one message — one per independent domain; use `Skill("mastermind-taskdev")` for plan-driven parallel work | | Ingest a prompt/spec/folder and generate agent-optimized tasks | `Skill("mastermind-createtask")` | | Execute tasks from a task file or monotask board (parallel/sequential/minimal modes, review cycles, loop) | `Skill("mastermind-do")` | | Design first — spec, approaches, approval gate before code | `Skill("mastermind-design")` | | Build a feature, fix a bug, implement anything | `Skill("mastermind-build")` | | Code review, content critique, strategy audit | `Skill("mastermind-review")` | | Receive a code review and apply it correctly | `Skill("mastermind-receive-review")` | | System architecture, DDD, technical design | `Skill("mastermind-architect")` | | Market research, competitive analysis, user insights | `Skill("mastermind-research")` | | Ideas, feature generation, opportunity framing | `Skill("mastermind-idea")` | | Research ideas, evaluate with PM lens, decompose into subtasks | `Skill("mastermind-ideate")` | | Analyze a component, research improvements, generate improvement tasks | `Skill("mastermind-improve")` | | Marketing campaign, copy, SEO | `Skill("mastermind-marketing")` | | Sales outreach, proposals, pipeline | `Skill("mastermind-sales")` | | Blog, docs, newsletters, threads | `Skill("mastermind-content")` | | Versioning, changelogs, deployment | `Skill("mastermind-release")` | | Finish a branch — tests, options menu, merge/PR/discard | `Skill("mastermind-finish")` | | Workflow, process, reporting | `Skill("mastermind-ops")` | | Invoicing, forecasting, cost | `Skill("mastermind-finance")` | | Inspect or manage brain memory | `Skill("mastermind-brain")` | | Technical portfolio, project state assessment | `Skill("mastermind-techport")` | | Define/run an agent organization | `Skill("mastermind-createorg")` / `Skill("mastermind-runorg")` | | Review and action pending agent approval requests | `Skill("mastermind-approvev1")` (v1 orgs only — v2 approvals arrive in the dashboard Human Input tab) | | Autonomous build + review until clean | `Skill("mastermind-autodev")` | | Isolate work in a git worktree | `Skill("mastermind-worktree")` | | Write or improve a mastermind skill | `Skill("mastermind-skill-builder")` | ### Skill Execution Order When multiple skills could apply to a **single-skill invocation** (not a full mastermind:master multi-domain run): 1. **Process skills first** — debug (`mastermind:debug`), brainstorming (`mastermind:idea`), architecture (`mastermind:architect`), research (`mastermind:research`) determine HOW to approach the work 2. **Execution skills second** — build, review, release execute the approach "Let's build X" → `mastermind:architect` first if approach is unclear, then `mastermind:build`. "Fix this" → `mastermind:debug` to find root cause first, then `mastermind:build` to fix. "Ship it" → `mastermind:review` to verify clean, then `mastermind:release`. **Multi-domain runs (Steps 4–7 of this command):** Domain manager agents for different domains run concurrently — there is no enforced serial order between `build` and `architect` domain managers when both are active. The order above applies when you (the master) are choosing which single skill to invoke directly. ### Skill Types **Rigid** (tdd, debug, autodev, review with `--tillend`): Follow exactly. Don't adapt away the discipline — it exists to catch the failures that "one quick look" misses. **Flexible** (idea, research, content, architect): Adapt principles to context. Use judgment on scope. The skill itself tells you which it is. ### Anti-Drift Guards These thoughts mean **STOP** — you are rationalizing. Check for a skill first. | Thought | Reality | |---|---| | "This is just a simple question" | Questions are tasks. Check for skills. | | "This is just a simple task" | Simple tasks define the floor. Check for skills. | | "I need more context first" | Skill check comes BEFORE gathering context. | | "Let me explore the codebase first" | Skills tell you HOW to explore. Check first. | | "I can check git/files quickly before invoking a skill" | Files lack conversation context. Brain Load + skill check come first. | | "Let me gather information first, then I'll check" | Skills tell you HOW to gather information. Check first. | | "The brain isn't loaded yet — let me just answer" | Brain Load is the first step. Load it. | | "This doesn't need a formal skill" | If a skill exists for this domain, use it. | | "This doesn't count as a real task" | Action = task. Check for skills. | | "I remember how this works" | Skills evolve. Read current version. Always. | | "I know what that command does" | Knowing the concept ≠ invoking the skill. Invoke it. | | "The skill is overkill for this" | Small tasks become complex. Use it. | | "I'll just do this one thing first" | Check BEFORE doing anything. | | "This feels productive" | Undisciplined action creates drift. Skills prevent this. | | "Auto mode means I should move fast" | Speed without discipline creates drift. Use skills. | | "The user said --auto, so I skip confirmation" | --auto skips user confirmation. It does NOT skip skill invocation. | | "Spawned agents don't need to check skills" | Subagents that have Skill access MUST use it. Only subagents with the `` gate may skip. | | "Agent said success" / "should work now" | Agent reports ≠ evidence. Run `mastermind:verify` independently — fresh and complete. | | "I'll just make a quick change on main" | No changes on main/master without explicit user consent. `mastermind:worktree` first. | | "Should I continue?" (in auto mode) | Never ask. Auto mode means execute continuously until blocked or all tasks complete. | | "TBD / TODO / implement later" (in a plan) | Placeholder = plan failure. Every step needs exact paths, complete code, runnable commands. | | "Code quality review first, then spec" | Wrong order every time. Spec compliance FIRST, code quality SECOND. Never reversed. | | "The subagent can read the plan file itself" | Controller extracts each task into a brief file and hands over that path. Subagents never read whole plan files. | ### Mandatory Patterns These sequences are non-negotiable in all modes: - **Before building**: Load brain → `mastermind:design` (questions → approaches → approved spec) → `mastermind:plan` (complete plan + execution handoff) → then build - **When fixing bugs**: `mastermind:debug` first (root cause) → write failing test via `mastermind:tdd` → fix → `mastermind:verify` - **After building**: `mastermind:review` — at minimum one pass before reporting complete - **Consuming a review**: `mastermind:receive-review` — verify before implementing, clarify unclear items first - **After any run**: Brain Write Procedure — score decisions, append to LanceDB - **Before releasing**: `mastermind:review --tillend --auto` → `mastermind:verify` → `mastermind:finish` - **Isolated work**: `mastermind:worktree` before making changes to avoid contaminating main - **Before claiming complete**: Run `mastermind:verify` — never claim completion based on agent reports, linter passes, or partial checks - **When writing a plan**: Map file structure first → copy spec-wide Global Constraints into the plan header → right-size tasks (smallest unit with its own test cycle) with exact paths, complete code, and Interfaces (Consumes/Produces) blocks — no placeholders → self-review (spec coverage, placeholder scan, type consistency) → offer execution mode choice (subagent-driven vs inline) - **When executing with subagents**: Hand each implementer its task as a brief file (never make them read the plan file) → spec compliance review FIRST → code quality review SECOND → re-review until both ✅ → record each completed task in the durable progress ledger (`.monomind/taskdev/progress.md`) → dispatch final whole-branch reviewer (most capable model, diff handed over as a file) after all tasks complete → then `mastermind:finish` - **When blocked during execution**: Stop immediately — do not guess or force through. Diagnose, provide context, re-dispatch with more capable model, or escalate to user ### Iron Laws These are inviolable regardless of mode, pressure, or context. Violating the letter of any law is violating its spirit — "I ran verify but only checked one file" or "I found the root cause but skipped the failing test" are not exceptions. | Law | Rule | |---|---| | **TDD** | No production code without a failing test first. Entry point: `mastermind:tdd`. | | **Debug** | No fix without root cause investigation first. Entry point: `mastermind:debug`. | | **Verify** | No completion claim without fresh verification evidence. Entry point: `mastermind:verify`. | | **Isolation** | No changes on main/master without explicit user consent. Entry point: `mastermind:worktree`. | | **Plans** | No placeholders: every plan step has exact file paths, complete code, and runnable commands. Entry point: `mastermind:plan`. | ### Platform Note Mastermind is designed for **Claude Code** but runs on any platform that supports the skill-loading mechanism described in "How to Access Mastermind Skills" above. On all platforms: never use file-reading tools to load skills — always use the platform's skill invocation mechanism. Skill content is loaded and injected by the harness when you call the skill tool with `"mastermind:"`. --- **If $ARGUMENTS is empty:** Output the capability menu below and wait. --- **MASTERMIND** — autonomous business execution across specialist domains. Describe your goal. Mastermind identifies the relevant domains, spawns specialist agents in parallel, and synthesizes results. Or invoke a domain directly. --- **Debug & quality** `/mastermind:debug` — systematic root-cause investigation before any fix attempt `/mastermind:verify` — confirm claims with evidence: tests pass, feature works, fix resolved `/mastermind:tdd` — enforce Red-Green-Refactor; no production code before failing test **Plan & execute** `/mastermind:design` — brainstorm, propose approaches, write approved spec before building `/mastermind:plan` — write a complete implementation plan (no placeholders, exact file paths) `/mastermind:execute` — run a written plan step-by-step with stop-on-blocker discipline `/mastermind:taskdev` — execute a plan via fresh subagents with two-stage per-task review `/mastermind:finish` — complete a branch: verify tests → options menu → merge/PR/keep/discard **Build & ship** `/mastermind:build` — code, features, bug fixes, test suites `/mastermind:architect` — system structure, DDD, deduplication, migration (`--scope review|design|deduplicate|migrate|all`) `/mastermind:idea` — products, features, pivots, opportunity framing `/mastermind:content` — blog, threads, documentation, newsletters **Review & improve** `/mastermind:review` — code quality, content critique, strategy audit `/mastermind:receive-review` — consume a code review correctly: verify, clarify, push back with evidence **Understand & decide** `/mastermind:research` — market intelligence, competitors, user insights `/mastermind:brain` — inspect and manage business memory **Go to market & operate** `/mastermind:marketing` — campaigns, copy, SEO, social strategy `/mastermind:sales` — outreach, proposals, pipeline management `/mastermind:release` — versioning, changelogs, deployment `/mastermind:ops` — workflow automation, process reporting `/mastermind:finance` — invoicing, forecasting, cost tracking **Persistent agent orgs** — named teams that coordinate across sessions `/mastermind:createorg` — define an org: roles, hierarchy, goal `/mastermind:runorg` — start a saved org via the Org Runtime v2 daemon (auto-migrates v1 configs); legacy prompt-orchestrated path: `/mastermind:runorgv1` `/mastermind:approvev1` — review and action pending approval requests from running org agents (v1 orgs only — v2 approvals arrive in the dashboard Human Input tab) **Autonomous & advanced** `/mastermind:autodev` — research → build → review loop until clean (`--tillend` supported) `/mastermind:techport` — technical portfolio assessment; port capabilities from other projects `/mastermind:worktree` — isolate work in a git worktree safely `/mastermind:skill-builder` — write or improve a mastermind skill with TDD discipline --- Flags: `--auto` · `--confirm` · `--project ` · `--iterate ` · `--monotask` --- **If $ARGUMENTS is non-empty:** Execute the full flow below. --- ## Execution Flow ### Step 1 — Parse flags Extract from `$ARGUMENTS`: - `--auto` → mode = auto - `--confirm` → mode = confirm - `--project ` → project_name = - `--iterate ` → iterate = N (integer ≥ 1; when flag is absent, no iteration runs) - `--monotask` → use_monotask = true (default: false — domain tracking writes to session files only) - Remaining text = prompt If `--project` was not provided, default `project_name` to the current directory name: ```bash project_name="${project_name:-$(basename "$PWD")}" ``` ### Step 2 — Brain Load Follow the Brain Load Procedure from `mastermind-protocol/SKILL.md`: 1. Call `mcp__monomind__lancedb_hierarchical-recall` namespace `mastermind:principles` (limit 20) 2. For each domain that appears relevant to the prompt, call `mcp__monomind__lancedb_context-synthesize` namespace `mastermind::weekly` 3. Call `mcp__monomind__monograph_query` with 3-5 keywords from the prompt Assemble the BRAIN CONTEXT block from results. ### Step 3 — Intake Invoke the intake logic from `mastermind-intake/SKILL.md`: - Check if prompt is rich (≥20 words + domain signals + goal phrase) - If vague: ask intake questions one at a time (Q1–Q5, stop when enough context) - If user says "decide yourself": make explicit LLM decision, state it, log it with confidence 0.7 - Resolve: mode (auto/confirm), project_name, domains_needed **After intake resolves:** Assign shell variables from the intake outputs (these are LLM-resolved values that must be echoed into the bash environment before the curl block runs): - `resolved_prompt` = the full cleaned prompt string - `mode` = `"auto"` or `"confirm"` Then generate `SESSION_ID` and persist it so iteration cycles can retrieve it across separate Bash calls: ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) # Resolve git-safe monomind data root — shared across worktrees and branch-agnostic. # In a worktree .git is a pointer file; we navigate to the common .git directory. _get_mono_dir() { local w="${1:-$(pwd)}" if [ -d "$w/.git" ]; then echo "$w/.git/monomind"; return; fi if [ -f "$w/.git" ]; then local m; m=$(grep '^gitdir:' "$w/.git" | sed 's/gitdir: *//') [ -z "$m" ] && { echo "$w/.monomind"; return; } [[ "$m" != /* ]] && m="$w/$m" echo "$(dirname "$(dirname "$m")")/monomind"; return fi echo "$w/.monomind" } MONO_DIR=$(_get_mono_dir "$REPO_ROOT") SESSION_ID="mm-$(date -u +%Y%m%dT%H%M%S)" mkdir -p "$MONO_DIR/sessions" # Persist SESSION_ID and project context so Step 12 can restore it in a new shell jq -n --arg sid "$SESSION_ID" --arg proj "$project_name" --arg prompt "$resolved_prompt" \ '{sessionId:$sid,project_name:$proj,prompt:$prompt}' \ > "$MONO_DIR/sessions/current.json.tmp" \ && mv "$MONO_DIR/sessions/current.json.tmp" \ "$MONO_DIR/sessions/current.json" CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") curl -s -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "$(jq -cn --arg sid "$SESSION_ID" --arg prompt "$resolved_prompt" --arg mode "$mode" --arg proj "$REPO_ROOT" \ '{type:"session:start",session:$sid,prompt:$prompt,mode:$mode,project:$proj,ts:(now*1000|floor)}')" || true ``` ### Step 3.5 — Design Gate STOP before Step 4. If `domains_needed` includes `build` (or any code/feature/fix work): 1. Invoke `Skill("mastermind-design")` NOW — pass `resolved_prompt` as the task description 2. Do NOT write any code, do NOT spawn any domain managers, do NOT proceed to Step 4 until the design skill returns with an approved spec 3. When design returns: save the approved spec as `build_spec` in `current.json` 4. Only then continue to Step 4 If `domains_needed` contains ONLY non-build domains (marketing, sales, research, content, ops, finance, idea): skip this gate and go directly to Step 4. Rationale: without a design gate, master spawns agents before the user has confirmed what to build. The design gate replicates the superpowers workflow: questions → approaches → spec approval → plan → execute. ### Step 3.6 — Plan Gate If the Design Gate ran (build work), do NOT skip planning. After `mastermind:design` returns with an approved spec: 1. Invoke `Skill("mastermind-plan")` NOW — pass `build_spec`, the brain context, and mode 2. The plan skill produces `docs/mastermind/plans/YYYY-MM-DD-.md` with the complete header (Goal, Architecture, Tech Stack, Global Constraints), right-sized tasks with Interfaces (Consumes/Produces) blocks, bite-sized TDD steps, and no placeholders — then runs its self-review (spec coverage, placeholder scan, type consistency) 3. The plan skill's Execution Handoff resolves the execution mode. Record it: `build_exec_mode` = `taskdev` (subagent-driven) or `execute` (inline), and save the plan path as `build_plan` in `current.json` 4. Step 5 MUST NOT re-ask the execution-mode question when this gate already resolved `build_exec_mode` 5. Only then continue to Step 4 If `domains_needed` contains ONLY non-build domains: skip this gate (same rule as Step 3.5). Rationale: superpowers' pipeline is brainstorm → spec approval → writing-plans → execution handoff. Without a plan gate, master hands an un-planned spec straight to domain managers and the plan discipline (exact paths, complete code, interface contracts between tasks) is lost. ### Step 4 — Decompose For each domain in `domains_needed`, assess complexity: - **Simple** (skill-only): single task, single agent, < 30 minutes estimated — invoke skill directly - **Complex** (manager agent): multi-step, multi-file, multi-day, or multi-agent — spawn a Task agent Complexity threshold for manager agent: any of these is true: - Requires 3+ files to be created/modified - Requires 2+ specialized agent types - Has external dependencies (APIs, services) - Is estimated to take more than one conversation turn **DOMAIN EXCEPTION — `idea`:** The `idea` domain MUST always be handled by the master invoking `Skill("mastermind-idea")` directly — NEVER by spawning a Task agent. Spawned agents do not have Skill tool access, so delegating `idea` to a Task agent silently degrades to raw analysis with no pipeline execution. After `mastermind:idea` returns, treat its output as the `idea` domain's unified output schema and proceed to the next domain. **Per-domain goal extraction:** For each activated domain, extract a one-sentence goal from the prompt describing what that domain must accomplish. Then **run the following Bash block**, substituting `` with a JSON object mapping each domain name to its one-sentence goal (use the full `resolved_prompt` as the value for any domain where no specific goal is extractable): ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) _get_mono_dir() { local w="${1:-$(pwd)}" if [ -d "$w/.git" ]; then echo "$w/.git/monomind"; return; fi if [ -f "$w/.git" ]; then local m; m=$(grep '^gitdir:' "$w/.git" | sed 's/gitdir: *//') [ -z "$m" ] && { echo "$w/.monomind"; return; } [[ "$m" != /* ]] && m="$w/$m" echo "$(dirname "$(dirname "$m")")/monomind"; return fi echo "$w/.monomind" } MONO_DIR=$(_get_mono_dir "$REPO_ROOT") SESSION_STATE="$MONO_DIR/sessions/current.json" [ -f "$SESSION_STATE" ] || { echo "ERROR: current.json not found"; exit 1; } # LLM: write the extracted goals JSON object to the temp file below. # Use a file (not a shell variable) to avoid quoting issues with apostrophes in goal text. # Example content: {"build":"Ship the auth module","marketing":"Draft launch email series"} # One JSON object, keys = domain names, values = one-sentence goals. SESSION_ID=$(jq -r '.sessionId // empty' "$SESSION_STATE" 2>/dev/null) [ -z "$SESSION_ID" ] && { echo "ERROR: SESSION_ID missing in current.json — run Step 3 first"; exit 1; } GOALS_FILE="$MONO_DIR/sessions/${SESSION_ID}_goals.json" cat > "$GOALS_FILE" << 'GOALS_EOF' GOALS_EOF # Validate it's real JSON before merging jq . "$GOALS_FILE" > /dev/null 2>&1 || { echo "ERROR: domain_goals_json is not valid JSON — check LLM substitution"; exit 1; } jq --slurpfile goals "$GOALS_FILE" '. + {domain_goals:$goals[0]}' \ "$SESSION_STATE" > "$SESSION_STATE.tmp" && mv "$SESSION_STATE.tmp" "$SESSION_STATE" echo "Domain goals written to current.json" ``` ### Step 5 — Plan Output Build a plan summary: ``` MASTERMIND PLAN — ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Prompt: Mode: Domains activated: ✦ build → Development Manager agent → board: /development (will be created in Step 6) ✦ marketing → Marketing Manager agent → board: /marketing (will be created in Step 6) Monotask space: Brain loaded: principles, domain summaries ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ``` If mode = confirm: show plan and wait for user response. Valid responses: - "go" or "proceed" — continue immediately - Any modification (e.g. "add sales domain", "remove marketing") — apply the change, re-show the plan, wait again - "cancel" or "stop" — emit `session:complete` with `status: blocked`, reason "cancelled by user", then STOP If the Step 3.6 Plan Gate already resolved `build_exec_mode`, skip the question below and use that value. Otherwise, after the user says "go" (and `build` is in `domains_needed`), ask once: > "For the build work: **subagents** (recommended — fresh agent per task with 2-stage review, like mastermind:taskdev) or **inline** (direct execution, mastermind:execute)?" - "subagents" → `build_exec_mode = "taskdev"` - "inline" → `build_exec_mode = "execute"` - No answer / skipped → `build_exec_mode = "taskdev"` (default) If mode = auto and Step 3.6 did not set it: `build_exec_mode = "taskdev"` (default). **Persist `build_exec_mode` to `current.json`** (required — Phase C reads it from there): ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) _get_mono_dir() { local w="${1:-$(pwd)}" if [ -d "$w/.git" ]; then echo "$w/.git/monomind"; return; fi if [ -f "$w/.git" ]; then local m; m=$(grep '^gitdir:' "$w/.git" | sed 's/gitdir: *//') [ -z "$m" ] && { echo "$w/.monomind"; return; } [[ "$m" != /* ]] && m="$w/$m" echo "$(dirname "$(dirname "$m")")/monomind"; return fi echo "$w/.monomind" } MONO_DIR=$(_get_mono_dir "$REPO_ROOT") SESSION_STATE="$MONO_DIR/sessions/current.json" # LLM: replace EXEC_MODE_VALUE with the resolved value: taskdev or execute build_exec_mode="EXEC_MODE_VALUE" [ "$build_exec_mode" = "EXEC_MODE_VALUE" ] && build_exec_mode="taskdev" jq --arg m "$build_exec_mode" '. + {build_exec_mode: $m}' \ "$SESSION_STATE" > "$SESSION_STATE.tmp" && mv "$SESSION_STATE.tmp" "$SESSION_STATE" echo "build_exec_mode=$build_exec_mode written to current.json" ``` ### Step 6 — Monotask Setup **Skip this step entirely if `use_monotask` is false** (the default). Domain tracking uses session JSON files only — no boards are created. Set `monotask_available: false` in `current.json` so Step 7 runs without board IDs. If `use_monotask` is true: follow the Monotask Space+Board Setup Procedure from `mastermind-protocol/SKILL.md`. Resolve the space **once**, then create one board per active domain. Use `project_name` as the space name so all boards across repos and domains share the same space. **Board naming convention:** Every board is named `-` (e.g. `factory-idea`, `factory-build`). This canonical name is stable across runs — mastermind finds the existing board instead of creating a new one every time. ```bash # Compatible with macOS bash 3.2 — no associative arrays, uses jq accumulation instead REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) SESSION_STATE="$MONO_DIR/sessions/current.json" # monotask availability guard — all card/board operations below require it if ! command -v monotask >/dev/null 2>&1; then echo "WARN: monotask CLI not found — board and card creation will be skipped." echo "Install via: npm install -g monotask" echo "Domain managers will run without board IDs (text-only output)." # Write marker to current.json so Step 7 Phase C skips Task spawning with empty boards jq '. + {monotask_available: false}' "$SESSION_STATE" > "$SESSION_STATE.tmp" \ && mv "$SESSION_STATE.tmp" "$SESSION_STATE" 2>/dev/null || true exit 0 fi SESSION_ID=$(jq -r '.sessionId // empty' "$SESSION_STATE" 2>/dev/null) [ -z "$SESSION_ID" ] && { echo "ERROR: SESSION_ID missing in current.json — run Step 3 first"; exit 1; } project_name=$(jq -r '.project_name // ""' "$SESSION_STATE") [ -z "$project_name" ] && { echo "ERROR: project_name is empty in current.json — run Step 3 first"; exit 1; } resolved_prompt=$(jq -r '.prompt // ""' "$SESSION_STATE") # LLM: replace DOMAINS_LIST_HERE with space-separated domain names, e.g.: build marketing sales domains_needed="DOMAINS_LIST_HERE" [ "$domains_needed" = "DOMAINS_LIST_HERE" ] && { echo "ERROR: LLM did not substitute DOMAINS_LIST_HERE"; exit 1; } [ -z "$domains_needed" ] && { echo "ERROR: domains_needed is empty — nothing to do"; exit 1; } # Resolve space once — find existing by exact name or create space_id=$(monotask space list 2>/dev/null | awk -F'|' '{gsub(/^ +| +$/,"",$1);gsub(/^ +| +$/,"",$2);if($2==n)print $1}' n="$project_name" | head -1) [ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>/dev/null | 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; } echo "Space: $space_id ($project_name)" # jq accumulation state (replaces bash 4.3+ associative arrays) state_patch='{}' for domain in $domains_needed; do canonical="${project_name}-${domain}" # Find existing board by canonical name — reuse across runs # board list format is "uuid: name" (colon-space separator, NOT pipe) board_id=$(monotask board list 2>/dev/null | awk -F': ' '{gsub(/^ +| +$/,"",$1);gsub(/^ +| +$/,"",$2);if($2==n)print $1}' n="$canonical" | head -1) # Domain-specific column schema: # idea → New | Evaluated | Elaborated | Tasked | Iced | Rejected (intake = "New") # all others → Todo | In Progress | Human in Loop | Review | Done | Cancelled (intake = "Todo") if [ "$domain" = "idea" ]; then intake_col_name="New" else intake_col_name="Todo" fi if [ -n "$board_id" ]; then echo "Reusing board: $board_id ($canonical)" cols_json=$(monotask column list "$board_id" --json 2>/dev/null || echo '[]') todo_col=$(echo "$cols_json" | jq -r --arg n "$intake_col_name" '[.[] | select(.title==$n)] | .[0].id // empty') doing_col=$(echo "$cols_json" | jq -r '[.[] | select(.title=="In Progress" or .title=="Doing")] | .[0].id // empty') done_col=$(echo "$cols_json" | jq -r '[.[] | select(.title=="Done")] | .[0].id // empty') else echo "Creating board: $canonical" board_id=$(monotask board create --space "$space_id" "$canonical" --json 2>/dev/null | jq -r '.id // empty') [ -z "$board_id" ] && echo "[mastermind] monotask board unavailable — board tracking skipped." monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true if [ "$domain" = "idea" ]; then todo_col=$(monotask column create "$board_id" "New" --json | jq -r '.id // empty') doing_col=$(monotask column create "$board_id" "Evaluated" --json | jq -r '.id // empty') monotask column create "$board_id" "Elaborated" --json >/dev/null monotask column create "$board_id" "Tasked" --json >/dev/null monotask column create "$board_id" "Iced" --json >/dev/null done_col=$(monotask column create "$board_id" "Rejected" --json | jq -r '.id // empty') else todo_col=$(monotask column create "$board_id" "Todo" --json | jq -r '.id // empty') doing_col=$(monotask column create "$board_id" "In Progress" --json | jq -r '.id // empty') monotask column create "$board_id" "Human in Loop" --json >/dev/null monotask column create "$board_id" "Review" --json >/dev/null done_col=$(monotask column create "$board_id" "Done" --json | jq -r '.id // empty') monotask column create "$board_id" "Cancelled" --json >/dev/null fi [ -z "$todo_col" ] && { echo "ERROR: Failed to create intake column for $domain"; exit 1; } fi domain_goal=$(jq -r --arg d "$domain" '.domain_goals[$d] // empty' "$SESSION_STATE") [ -z "$domain_goal" ] && domain_goal="$resolved_prompt" state_patch=$(echo "$state_patch" | jq \ --arg d "$domain" --arg b "$board_id" \ --arg t "$todo_col" --arg g "$doing_col" --arg e "$done_col" \ --arg goal "$domain_goal" \ '.board_ids[$d]=$b | .todo_cols[$d]=$t | .doing_cols[$d]=$g | .done_cols[$d]=$e | .domain_goals[$d]=$goal') echo "DOMAIN=$domain BOARD=$board_id TODO=$todo_col DOING=$doing_col DONE=$done_col" done # Persist to current.json — one atomic merge jq --arg domains "$domains_needed" \ --argjson patch "$state_patch" \ '. + $patch + {domains_needed:($domains | split(" ") | map(select(length>0)))}' \ "$SESSION_STATE" > "$SESSION_STATE.tmp" && mv "$SESSION_STATE.tmp" "$SESSION_STATE" echo "Session state saved to current.json" ``` ### Step 7 — Spawn Domain Managers **BEFORE THIS STEP:** If `idea` is in `domains_needed`, invoke `Skill("mastermind-idea")` directly now (master context has Skill tool access). Pass the resolved prompt, project path, and mode. The idea skill's Step 7 writes its output to `$MONO_DIR/sessions//idea.json` automatically — do not write it again. Mark the `idea` domain as handled. Do NOT include `idea` in the Task spawning below. **IDEA PIPELINE REQUIREMENT:** `mastermind:idea` runs a multi-step pipeline (Steps 3–6 inside idea.md). You MUST follow all of those steps — do NOT shortcut to manually creating cards. The full pipeline is: - Step 3: Board setup — find-or-create `-idea` board (master's Step 6 already created it with correct columns: New → Evaluated → Elaborated → Tasked → Iced → Rejected). Load column IDs from existing board. - Step 4: Spawn Idea Manager agent (coordinator) with specialist sub-agents per angle — generates ideas as cards in the `New` column. - Step 5: Spawn PM agent for validation — moves each card to `Evaluated`, `Iced`, or `Rejected`, sets impact/effort. - Step 6a: Elaboration agents enrich each `Evaluated` card and move it to `Elaborated`. - Step 6b: User gate (skip in auto mode). - Step 6c: Task decomposition — creates subtask cards on `-tasks-dev` and `-tasks-ops` boards, linked as subtasks of their parent idea card. Moves parent idea cards to `Tasked`. Skipping any of these steps produces an incomplete pipeline run — card content is generated but no evaluation, elaboration, or task breakdown occurs. **Before spawning**, select the best domain manager agent type from the registry for each active domain. Do not hardcode `coordinator` — pick the agent whose expertise best fits the domain goal. **BASH TOOL REQUIREMENT:** Domain managers must run `monotask` CLI commands. Only use subagent_types that include Bash in their tool list. If the registry returns an agent without Bash (e.g. `Product Manager`, `Backend Architect`), override it with `general-purpose` (which has all tools). Agents without Bash cannot create cards, emit curl events, or write session files — they will silently produce degraded output. **Phase A — Registry selection** (run as one Bash call; must complete before Phase C): ```bash # Compatible with macOS bash 3.2 — uses jq accumulation instead of declare -A REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) REGISTRY="$REPO_ROOT/.monomind/registry.json" # Reload state from current.json — this is a new shell; no inherited variables SESSION_STATE="$MONO_DIR/sessions/current.json" [ -f "$SESSION_STATE" ] || { echo "ERROR: current.json not found — run from Step 3"; exit 1; } # If Step 6 skipped due to missing monotask, board_ids are empty — skip Task agent spawning if [ "$(jq -r '.monotask_available // true' "$SESSION_STATE")" = "false" ]; then echo "INFO: monotask_available=false — domain managers will be spawned in text-only mode (no board IDs)" echo " Install monotask (npm install -g monotask) and re-run to enable board tracking." fi domains_needed=$(jq -r '.domains_needed[]? // empty' "$SESSION_STATE" | grep -v '^idea$' | tr '\n' ' ') [ -z "$domains_needed" ] && { echo "INFO: no non-idea domains to spawn as Task agents"; } # idea-only runs are valid # Returns: best agent name from registry for the given domain+goal pick_domain_manager() { local domain="$1" local goal="$2" local kw cats result kw=$(echo "$goal" | tr '[:upper:]' '[:lower:]' | grep -oE '[a-z]{5,}' | sort -u | tr '\n' ' ') case "$domain" in build) cats="engineering development architecture" ;; marketing) cats="marketing paid-media strategy" ;; sales) cats="sales strategy" ;; research) cats="academic specialized strategy" ;; content) cats="marketing specialized" ;; ops) cats="project-management strategy support" ;; release) cats="devops github engineering" ;; review) cats="engineering testing analysis" ;; finance) cats="strategy specialized" ;; architect) cats="architecture engineering" ;; idea) cats="product strategy marketing" ;; *) cats="core strategy" ;; esac result=$(jq -r \ --arg cats "$cats" \ --arg kw "$kw" \ '[ .agents[] | select(.deprecated != true) | select(.category as $c | ($cats | split(" ") | any(. == $c))) | {name: .name, score: ( (.name | ascii_downcase) as $n | # Score on ANY keyword match, not just the first (if ($kw | length) > 0 then ([$kw | split(" ")[] | select(length > 0) | if ($n | contains(.)) then 1 else 0 end] | add // 0) else 0 end) + (if $n | test("manager|director|coordinator") then 1 else 0 end) )} ] | sort_by(-.score) | .[0].name // empty' \ "$REGISTRY" 2>/dev/null) if [ -z "$result" ]; then echo "WARN: registry lookup failed for domain=$domain, using coordinator fallback" >&2 echo "coordinator" else echo "$result" fi } # jq accumulation (replaces bash 4.3+ declare -A — compatible with macOS bash 3.2) domain_managers_json='{}' for domain in $domains_needed; do goal=$(jq -r --arg d "$domain" '.domain_goals[$d] // empty' "$SESSION_STATE") [ -z "$goal" ] && goal=$(jq -r '.prompt // ""' "$SESSION_STATE") manager=$(pick_domain_manager "$domain" "$goal") domain_managers_json=$(echo "$domain_managers_json" | jq --arg d "$domain" --arg m "$manager" '. + {($d): $m}') echo "Domain manager for $domain: $manager" done # Persist domain_managers so Phase C can reload them without stdout parsing [ -z "$domain_managers_json" ] && domain_managers_json="{}" jq --argjson mgrs "$domain_managers_json" '. + {domain_managers:$mgrs}' \ "$SESSION_STATE" > "$SESSION_STATE.tmp" && mv "$SESSION_STATE.tmp" "$SESSION_STATE" # Emit board/column lookup for LLM use in Phase C Task construction: echo "--- Phase C board/col IDs (loaded from current.json) ---" for domain in $domains_needed; do board=$(jq -r --arg d "$domain" '.board_ids[$d] // ""' "$SESSION_STATE") todo=$(jq -r --arg d "$domain" '.todo_cols[$d] // ""' "$SESSION_STATE") doing=$(jq -r --arg d "$domain" '.doing_cols[$d] // ""' "$SESSION_STATE") done_c=$(jq -r --arg d "$domain" '.done_cols[$d] // ""' "$SESSION_STATE") mgr=$(jq -r --arg d "$domain" '.domain_managers[$d] // "coordinator"' "$SESSION_STATE") echo "DOMAIN=$domain MANAGER=$mgr BOARD=$board TODO=$todo DOING=$doing DONE=$done_c" done ``` **Phase B — Dashboard dispatch** + **Phase C — Task spawning** (run in one message — B is a Bash call, C is the Task tool calls; they are independent of each other): Phase B: ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) SESSION_STATE="$MONO_DIR/sessions/current.json" SESSION_ID=$(jq -r '.sessionId // empty' "$SESSION_STATE" 2>/dev/null) [ -z "$SESSION_ID" ] && { echo "ERROR: SESSION_ID not found in current.json"; exit 1; } CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242") # Filter idea — it was already handled by Skill tool before Phase A, not dispatched as a Task agent domains_needed=$(jq -r '.domains_needed[]? // empty' "$SESSION_STATE" | grep -v '^idea$' | tr '\n' ' ') for domain in $domains_needed; do goal=$(jq -r --arg d "$domain" '.domain_goals[$d] // empty' "$SESSION_STATE") [ -z "$goal" ] && goal=$(jq -r '.prompt // ""' "$SESSION_STATE") curl -s -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \ -H "Content-Type: application/json" \ -d "$(jq -cn --arg sid "$SESSION_ID" --arg d "$domain" --arg cmd "$goal" \ '{type:"domain:dispatch",session:$sid,domain:$d,cmd:$cmd,ts:(now*1000|floor)}')" || true done ``` Spawn ALL domain manager agents in ONE message using the Task tool (parallel execution). **Before constructing the Task calls:** load board/column UUIDs and domain manager names from `current.json` — that is the authoritative source. The Phase A echo lines are a human-readable diagnostic only; do not parse them as the primary data source. ```bash REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) SESSION_STATE="$MONO_DIR/sessions/current.json" SESSION_ID=$(jq -r '.sessionId // empty' "$SESSION_STATE" 2>/dev/null) [ -z "$SESSION_ID" ] && { echo "ERROR: SESSION_ID missing"; exit 1; } # Emit one line per domain for LLM to read before constructing Task calls for domain in $(jq -r '.domains_needed[]? // empty' "$SESSION_STATE" | grep -v '^idea$'); do board_id=$(jq -r --arg d "$domain" '.board_ids[$d] // ""' "$SESSION_STATE") if [ -z "$board_id" ]; then echo "WARN: DOMAIN=$domain has no board_id — Step 6 may not have run or monotask is missing. Task agent will run without board tracking." fi exec_mode="" [ "$domain" = "build" ] && exec_mode=$(jq -r '.build_exec_mode // "taskdev"' "$SESSION_STATE") echo "DOMAIN=$domain \ MANAGER=$(jq -r --arg d "$domain" '.domain_managers[$d] // "coordinator"' "$SESSION_STATE") \ BOARD=$board_id \ TODO=$(jq -r --arg d "$domain" '.todo_cols[$d] // ""' "$SESSION_STATE") \ DOING=$(jq -r --arg d "$domain" '.doing_cols[$d] // ""' "$SESSION_STATE") \ DONE=$(jq -r --arg d "$domain" '.done_cols[$d] // ""' "$SESSION_STATE") \ EXEC_MODE=$exec_mode \ GOAL=$(jq -r --arg d "$domain" '.domain_goals[$d] // .prompt' "$SESSION_STATE" | tr -d '\n')" done ``` Use each `MANAGER` value as `subagent_type`, `BOARD`/`TODO`/`DOING`/`DONE` as board and column IDs. Do NOT use placeholder strings. Each Task call must include a complete briefing following the Monotask Task Briefing Standard from `mastermind-protocol/SKILL.md`. Include: - The full BRAIN CONTEXT block - The board ID (from `current.json` above) - The specific goal for this domain - The project name and run context - Instruction to create monotask cards directly using `monotask card create $BOARD_ID $COL_TODO_ID "