@monoes/monomindcli 1.7.0 → 1.9.0

package/.claude/skills/mastermind/references/persuasion-psychology.md

@@ -0,0 +1,158 @@
+# Persuasion Psychology Reference
+
+Mental models, cognitive biases, and behavioral frameworks for marketing. Apply these when writing copy, designing campaigns, structuring pricing, or briefing agents on how to frame their output.
+
+---
+
+## Quick Reference: Challenge → Models
+
+| Challenge | Apply These |
+|---|---|
+| Low conversions | Hick's Law, Activation Energy, BJ Fogg, friction reduction |
+| Price objections | Anchoring, Framing, Mental Accounting, Loss Aversion |
+| Building trust | Authority, Social Proof, Reciprocity, Mere Exposure |
+| Creating urgency | Scarcity, Loss Aversion, Zeigarnik Effect |
+| Retention/churn | Endowment Effect, Switching Costs, Status-Quo Bias |
+| Growth stalling | Theory of Constraints, Pareto, Feedback Loops |
+| Decision paralysis | Paradox of Choice, Default Effect, Decoy Effect |
+| Onboarding | Goal-Gradient, IKEA Effect, Commitment & Consistency |
+| Cold outreach | Reciprocity, Authority, Liking/Similarity, Mere Exposure |
+
+---
+
+## Cognitive Biases
+
+### Anchoring Effect
+The first number seen heavily influences subsequent judgments. Show the higher price first (enterprise tier, competitor price, original price) to anchor expectations before revealing your price.
+
+### Loss Aversion
+Losses feel roughly twice as painful as equivalent gains. Frame in terms of what they'll lose by not acting. "Don't miss out" outperforms "You could gain." "Stop losing $X/week" beats "Save $X/week."
+
+### Social Proof / Bandwagon Effect
+People follow what others are doing. Popularity signals quality and safety. Show customer counts, testimonials with photos, company logos, review scores, and "trending" indicators near CTAs.
+
+### Scarcity / Urgency
+Limited availability increases perceived value. Limited-time offers, low-stock warnings, and exclusive access create urgency. Only use when genuine — fake scarcity destroys trust permanently.
+
+### Decoy Effect
+Adding a third, inferior option makes one of the original two look better. A pricing tier that's clearly worse value makes your preferred tier look like the obvious choice.
+
+### Framing Effect
+Same facts, different frames. "90% success rate" vs. "10% failure rate" are identical but feel different. Frame positively. "Keep your savings" beats "Avoid losing money."
+
+### Default Effect
+People accept pre-selected options. Defaults are powerful. Pre-select the plan you want customers to choose. The recommended tier should be visually pre-selected.
+
+### Paradox of Choice
+Too many options overwhelm and paralyze. Fewer choices often lead to more decisions. Three pricing tiers beat seven. One clear CTA beats three. Recommend a single "best for most" option.
+
+### Goal-Gradient Effect
+People accelerate effort as they approach a goal. Show progress bars, completion percentages, and "almost there" messaging to drive completion in onboarding and signup flows.
+
+### Endowment Effect
+People value things more once they own them. Free trials, samples, and freemium models let customers "own" the product before committing, making them reluctant to give it up.
+
+### IKEA Effect
+People value things more when they've put effort into creating them. Let customers customize, configure, or build something during onboarding. Their investment increases perceived value.
+
+### Zero-Price Effect
+"Free" is psychologically different from low-priced. The jump from $1 to $0 is disproportionately powerful. Free tiers, free shipping, and free trials have outsized appeal.
+
+### Status-Quo Bias
+People prefer the current state. Change feels risky. Reduce friction to switch: "Import your data in one click." Make the transition feel safe and easy, not effortful.
+
+### Zeigarnik Effect
+Unfinished tasks occupy the mind. Open loops create tension. "You're 80% done" creates pull to finish. Abandoned carts, incomplete profiles, and progress indicators leverage this.
+
+### Mere Exposure Effect
+Familiarity breeds liking. Consistent brand presence builds preference over time. Repetition across channels creates comfort and trust — even without explicit recall.
+
+### Confirmation Bias
+People seek information confirming existing beliefs. Understand what your audience already believes and align messaging accordingly. Fighting beliefs head-on rarely works.
+
+### Hyperbolic Discounting / Present Bias
+People strongly prefer immediate rewards. Emphasize immediate benefits ("Start saving time today") over future ones ("You'll see ROI in 6 months").
+
+---
+
+## Persuasion Principles
+
+### Reciprocity
+People feel obligated to return favors. Give first: free content, free tools, generous free tiers create reciprocal obligation. Give value before asking for anything.
+
+### Commitment & Consistency
+Once people commit, they want to stay consistent. Get small commitments first (email signup, free trial). People who've taken one step are more likely to take the next.
+
+### Authority Bias
+People defer to experts. Feature expert endorsements, certifications, "as seen in" logos, and thought leadership content. Credentials reduce perceived risk.
+
+### Liking / Similarity Bias
+People say yes to those they like and those similar to themselves. "Built by marketers for marketers" signals similarity. Use relatable spokespeople and shared-values positioning.
+
+### Scarcity (see Cognitive Biases above)
+
+### Unity Principle
+Shared identity drives influence. Position your brand as part of the customer's tribe. Use insider language and shared values.
+
+---
+
+## Pricing Psychology
+
+### Charm Pricing / Left-Digit Effect
+Prices ending in 9 seem significantly lower than the next round number. $99 feels much cheaper than $100. Use for value-focused products.
+
+### Rounded-Price (Fluency) Effect
+Round numbers feel premium. $100 signals quality; $99 signals value. Use round prices for premium products, charm prices for value products.
+
+### Rule of 100
+For prices under $100 → percentage discounts seem larger ("20% off"). For prices over $100 → absolute discounts seem larger ("$50 off").
+
+### Mental Accounting
+Same price framed differently changes perception. "$1/day" feels cheaper than "$30/month." "Less than your morning coffee" reframes the expense.
+
+---
+
+## Behavioral Models
+
+### BJ Fogg Behavior Model
+Behavior = Motivation × Ability × Prompt. All three must be present for action. High motivation but hard to do = won't happen. Easy to do but no prompt = won't happen. Design for all three in every CTA.
+
+### EAST Framework
+Make desired behaviors: **Easy** (reduce friction), **Attractive** (appealing visually and verbally), **Social** (show others doing it), **Timely** (ask at the right moment in the journey).
+
+### Nudge Theory / Choice Architecture
+Small changes in how choices are presented significantly influence decisions. Default selections, strategic ordering, and friction reduction guide behavior without restricting choice.
+
+### Activation Energy
+The initial energy required to start. High activation energy prevents action even if the overall task is easy. Pre-fill forms, offer templates, show quick wins. Make the first step trivially easy.
+
+### Feedback Loops
+Output becomes input. Build virtuous cycles: more users → more content → better SEO → more users. Identify and strengthen positive feedback loops in your marketing system.
+
+### Flywheel Effect
+Sustained effort creates self-sustaining momentum. Content → traffic → leads → customers → case studies → more content. Each element powers the next.
+
+### Theory of Constraints
+Every system has one bottleneck. Fix the constraint before optimizing elsewhere. If funnel converts well but traffic is low, more CRO won't help. Fix the bottleneck first.
+
+---
+
+## Mental Models for Strategy
+
+### Jobs to Be Done
+People don't buy products — they hire them to get a job done. A drill buyer wants a hole. Frame around the job (outcome), not the tool (feature).
+
+### First Principles
+Break problems down to basic truths. Ask "why" repeatedly to find root causes. Don't assume you need content marketing because competitors do — ask what problem it solves.
+
+### Inversion
+Ask "What would guarantee failure?" then systematically prevent those things. List everything that would make your campaign fail before building it.
+
+### Pareto Principle (80/20)
+80% of results come from 20% of efforts. Find the 20% of channels, customers, or content driving 80% of results. Cut or reduce the rest.
+
+### Second-Order Thinking
+Consider effects of effects. A flash sale boosts revenue (first order) but trains customers to wait for discounts (second order). Think two moves ahead.
+
+### Barbell Strategy
+Put 80% of budget into proven channels, 20% into experimental bets. Avoid moderate-risk, moderate-reward middle ground.

package/.claude/skills/mastermind/release.md

@@ -0,0 +1,156 @@
+---
+name: mastermind-release
+description: Mastermind release domain — versioning, changelog, deployment coordination. Spawns a Release Manager who coordinates testing and devops agents for a safe, traceable release pipeline.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Release Domain
+
+This skill is invoked by `mastermind:master` or directly via `/mastermind:release`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via _protocol.md brain load)
+- `prompt`: the release goal (version target, scope, environment)
+- `project_name`: monotask space name
+- `board_id`: monotask board ID (set by master, or created standalone)
+- `mode`: auto | confirm
+
+---
+
+## Complexity Assessment
+
+Assess the prompt to determine execution mode:
+
+**Simple (direct execution):** Single-step release action:
+- "Bump the version to 1.2.3 in package.json"
+- "Generate a changelog for this git range"
+→ Use a single release-manager or coder agent. Skip manager delegation.
+
+**Complex (spawn Release Manager agent):** Any of these:
+- Full end-to-end release (version + changelog + tests + deploy)
+- Multi-environment deployment (staging → production)
+- Release requiring review gates or rollback plan
+- Coordinated release across multiple packages
+→ Spawn Release 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: `release`)
+2. Run intake from _intake.md if prompt is vague
+3. Create or find monotask space `<project_name>`, create board `release`
+4. Proceed with complexity assessment below
+5. At end: follow _protocol.md Brain Write Procedure (namespace: `release`)
+
+---
+
+## Complex Execution — Release Manager Agent
+
+Spawn a Release Manager agent via Task tool:
+
+```javascript
+Task({
+  subagent_type: "coordinator",
+  description: `You are the Release Manager for project <project_name>.
+
+CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:release
+
+BRAIN CONTEXT:
+<brain_context>
+
+YOUR BOARD: <board_id>
+YOUR GOAL: <prompt>
+
+STEP 1 — PLAN
+Decompose the release into ordered stages. Identify for each stage:
+- Pre-release: version bump, changelog, final tests
+- Release: build, package, deploy to target environment
+- Post-release: smoke tests, monitoring check, announcement prep
+- Rollback plan: what triggers a rollback and how to execute it
+
+STEP 2 — CREATE TASKS
+For each release 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(.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 release stage goal, ≤80 chars>" --json)
+CARD_ID=$(echo "$result" | jq -r '.id // empty')
+monotask card set-description "$BOARD_ID" "$CARD_ID" "[specific release stage goal]"
+monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Release Manager
+BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
+SCOPE: [packages, environments, services in scope]
+CONSTRAINTS: [breaking change rules, downtime windows, rollback triggers, compliance gates]
+SUCCESS CRITERIA:
+- [ ] [checkable item — e.g. \"all tests green before deploy\"]
+AGENT: [release-manager | tester | DevOps Automator | cicd-engineer]
+SWARM: hierarchical 5 raft
+DEPENDENCIES: [prior stage task ID — release pipeline is sequential]
+OUTPUT FORMAT: unified output schema"
+```
+
+STEP 3 — EXECUTE
+Spawn Task agents in release order (hierarchical raft — coordinator maintains authoritative release state):
+- Pre-release prep: subagent_type "release-manager"
+- Testing gate: subagent_type "tester"
+- Infrastructure and deploy: subagent_type "DevOps Automator"
+- CI/CD pipeline: subagent_type "cicd-engineer"
+
+Also run /monomind:do --board <board_id> to track execution.
+
+STEP 4 — COLLECT AND RETURN
+Collect all stage outcomes. Return to caller:
+
+domain: release
+status: complete | partial | blocked
+artifacts:
+  - path: [changelog file, release notes, deployment manifest]
+    type: config
+decisions:
+  - what: [version strategy, deploy window, rollback threshold]
+    why: [reasoning]
+    confidence: [0.0-1.0]
+    outcome: shipped | pending | reverted
+lessons:
+  - what_worked: [what made the release smooth]
+  - what_didnt: [what caused delays or required rollback]
+next_actions:
+  - [e.g. "run mastermind:ops to monitor post-release metrics"]
+  - [e.g. "run mastermind:review on the next release candidate"]
+board_url: monotask://<project_name>/release
+run_id: <ISO8601-timestamp>`,
+  run_in_background: true
+})
+```
+
+---
+
+## Simple Execution
+
+For simple tasks (single agent, single step):
+
+1. Spawn one Task agent with the release action as a self-contained briefing
+2. Collect output
+3. Return unified output schema with `status: complete`
+
+---
+
+## Domain Swarm Defaults
+
+| Task Type | Agent | Swarm |
+|---|---|---|
+| Full end-to-end release | coordinator + tester + devops | hierarchical 5 raft specialized |
+| Multi-package release | coordinator + release-manager | hierarchical 5 raft specialized |
+| Deploy only | DevOps Automator | hierarchical 3 raft specialized |
+| Test gate | tester | star 4 raft parallel |
+| Changelog / version bump | release-manager | single agent |

package/.claude/skills/mastermind/research.md

@@ -0,0 +1,156 @@
+---
+name: mastermind-research
+description: Mastermind research domain — market research, competitor analysis, user research, trend scanning. Spawns a Research Manager coordinating a mesh of researcher agents for comprehensive intelligence gathering.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Research Domain
+
+This skill is invoked by `mastermind:master` or directly via `/mastermind:research`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via _protocol.md brain load)
+- `prompt`: the research question or intelligence goal
+- `project_name`: monotask space name
+- `board_id`: monotask board ID (set by master, or created standalone)
+- `mode`: auto | confirm
+
+---
+
+## Complexity Assessment
+
+Assess the prompt to determine execution mode:
+
+**Simple (direct execution):** Single-answer lookup or quick scan:
+- "What is the pricing model for Competitor X?"
+- "Find the current market size for SaaS tools in HR"
+→ Use a single researcher agent. Skip manager delegation.
+
+**Complex (spawn Research Manager agent):** Any of these:
+- Full competitive landscape analysis
+- Market sizing with multiple data sources
+- User research synthesis across multiple interviews or signals
+- Trend analysis requiring cross-domain intelligence
+→ Spawn Research 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: `research`)
+2. Run intake from _intake.md if prompt is vague
+3. Create or find monotask space `<project_name>`, create board `research`
+4. Proceed with complexity assessment below
+5. At end: follow _protocol.md Brain Write Procedure (namespace: `research`)
+
+---
+
+## Complex Execution — Research Manager Agent
+
+Spawn a Research Manager agent via Task tool:
+
+```javascript
+Task({
+  subagent_type: "researcher",
+  description: `You are the Research Manager for project <project_name>.
+
+CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:research
+
+BRAIN CONTEXT:
+<brain_context>
+
+YOUR BOARD: <board_id>
+YOUR GOAL: <prompt>
+
+STEP 1 — PLAN
+Decompose the research goal into parallel intelligence streams. For each stream, identify:
+- What specific question it answers
+- Which data sources to tap (web, docs, user signals, code, analytics)
+- Which specialist is best suited
+- How outputs from different streams combine into a final answer
+
+STEP 2 — CREATE TASKS
+For each research stream, 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 research question, ≤80 chars>" --json)
+CARD_ID=$(echo "$result" | jq -r '.id // empty')
+monotask card set-description "$BOARD_ID" "$CARD_ID" "[specific research question this stream answers]"
+monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Research Manager
+BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
+SCOPE: [sources to consult, search queries to run, depth of analysis]
+CONSTRAINTS: [recency requirements, geographic scope, data reliability thresholds]
+SUCCESS CRITERIA:
+- [ ] [checkable item — e.g. \"top 5 competitors identified with pricing\"]
+AGENT: [researcher | Trend Researcher | UX Researcher | Analytics Reporter]
+SWARM: mesh 4 gossip
+DEPENDENCIES: [task IDs or \"none\"]
+OUTPUT FORMAT: unified output schema"
+```
+
+STEP 3 — EXECUTE
+Spawn one Task agent per research stream (mesh topology — findings cross-pollinate):
+- Web and market research: subagent_type "researcher"
+- Trend and signal analysis: subagent_type "Trend Researcher"
+- User behavior and UX signals: subagent_type "UX Researcher"
+- Data and metrics analysis: subagent_type "Analytics Reporter"
+
+Also run /monomind:do --board <board_id> to track execution.
+
+STEP 4 — COLLECT AND RETURN
+Synthesize all research streams into an intelligence report. Return to caller:
+
+domain: research
+status: complete | partial | blocked
+artifacts:
+  - path: [research report if written to disk]
+    type: report
+decisions:
+  - what: [key findings and recommended actions]
+    why: [evidence from research]
+    confidence: [0.0-1.0]
+    outcome: pending
+lessons:
+  - what_worked: [which sources or methods yielded best signal]
+  - what_didnt: [gaps or low-quality sources]
+next_actions:
+  - [e.g. "run mastermind:idea to act on market insights"]
+  - [e.g. "run mastermind:marketing with validated positioning"]
+board_url: monotask://<project_name>/research
+run_id: <ISO8601-timestamp>`,
+  run_in_background: true
+})
+```
+
+---
+
+## Simple Execution
+
+For simple tasks (single researcher, single question):
+
+1. Spawn one Task agent with the research question as a self-contained briefing
+2. Collect output
+3. Return unified output schema with `status: complete`
+
+---
+
+## Domain Swarm Defaults
+
+| Task Type | Agent | Swarm |
+|---|---|---|
+| Full competitive analysis | researcher + trend + UX | mesh 4 gossip balanced |
+| Market sizing | researcher | hierarchical 3 raft specialized |
+| Trend scan | Trend Researcher | single agent |
+| User research synthesis | UX Researcher | hierarchical 3 raft specialized |
+| Quick factual lookup | researcher | single agent |

package/.claude/skills/mastermind/review.md

@@ -0,0 +1,157 @@
+---
+name: mastermind-review
+description: Mastermind review domain — code review, content review, strategy review, security audit. Spawns a Review Manager coordinating a mesh of specialist reviewers for multi-angle assessment.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Review Domain
+
+This skill is invoked by `mastermind:master` or directly via `/mastermind:review`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via _protocol.md brain load)
+- `prompt`: what to review and what to assess
+- `project_name`: monotask space name
+- `board_id`: monotask board ID (set by master, or created standalone)
+- `mode`: auto | confirm
+
+---
+
+## Complexity Assessment
+
+Assess the prompt to determine execution mode:
+
+**Simple (direct execution):** Single file or single artifact:
+- "Review this function for bugs"
+- "Check this paragraph for clarity"
+→ Use a single Code Reviewer or content reviewer agent. Skip manager delegation.
+
+**Complex (spawn Review Manager agent):** Any of these:
+- Full codebase or module audit
+- Security review across multiple surfaces
+- Strategy or content review requiring multiple expert perspectives
+- Combined code + architecture + security pass
+→ Spawn Review 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: `review`)
+2. Run intake from _intake.md if prompt is vague
+3. Create or find monotask space `<project_name>`, create board `review`
+4. Proceed with complexity assessment below
+5. At end: follow _protocol.md Brain Write Procedure (namespace: `review`)
+
+---
+
+## Complex Execution — Review Manager Agent
+
+Spawn a Review Manager agent via Task tool:
+
+```javascript
+Task({
+  subagent_type: "reviewer",
+  description: `You are the Review Manager for project <project_name>.
+
+CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:review
+
+BRAIN CONTEXT:
+<brain_context>
+
+YOUR BOARD: <board_id>
+YOUR GOAL: <prompt>
+
+STEP 1 — PLAN
+Decompose the review scope into distinct assessment angles. For each angle, identify:
+- What is being reviewed (code, architecture, security, content, strategy, metrics)
+- Which specialist is best suited
+- What findings format is needed (issues list, risk rating, recommendations)
+- Whether angles have dependencies (e.g. architecture review before security)
+
+STEP 2 — CREATE TASKS
+For each review angle, 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 review scope, ≤80 chars>" --json)
+CARD_ID=$(echo "$result" | jq -r '.id // empty')
+monotask card set-description "$BOARD_ID" "$CARD_ID" "[specific review scope and assessment criteria]"
+monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Review Manager
+BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
+SCOPE: [exact files, URLs, documents, or system surfaces in scope]
+CONSTRAINTS: [known acceptable risks, existing decisions not to revisit, standards to apply]
+SUCCESS CRITERIA:
+- [ ] [checkable item — e.g. \"all critical issues documented\"]
+AGENT: [Code Reviewer | Security Engineer | analyst | Accessibility Auditor | UX Researcher]
+SWARM: mesh 4 gossip
+DEPENDENCIES: [task IDs or \"none\"]
+OUTPUT FORMAT: unified output schema"
+```
+
+STEP 3 — EXECUTE
+Spawn one Task agent per review angle (mesh topology — reviewers share findings):
+- Code quality: subagent_type "Code Reviewer"
+- Security: subagent_type "Security Engineer"
+- Architecture: subagent_type "Software Architect"
+- Analytics/metrics: subagent_type "Analytics Reporter"
+- Accessibility: subagent_type "Accessibility Auditor"
+
+Also run /monomind:do --board <board_id> to track execution.
+
+STEP 4 — COLLECT AND RETURN
+Synthesize all review findings. Return to caller:
+
+domain: review
+status: complete | partial | blocked
+artifacts:
+  - path: [review report if written to disk]
+    type: report
+decisions:
+  - what: [critical findings and recommended actions]
+    why: [evidence from review]
+    confidence: [0.0-1.0]
+    outcome: pending
+lessons:
+  - what_worked: [which review angles surfaced the most value]
+  - what_didnt: [gaps in review coverage]
+next_actions:
+  - [e.g. "run mastermind:build to fix critical issues found"]
+  - [e.g. "run mastermind:release after fixes are confirmed"]
+board_url: monotask://<project_name>/review
+run_id: <ISO8601-timestamp>`,
+  run_in_background: true
+})
+```
+
+---
+
+## Simple Execution
+
+For simple tasks (single reviewer, single artifact):
+
+1. Spawn one Task agent with the review 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 multi-angle review | reviewer + specialists | mesh 4 gossip balanced |
+| Security audit | Security Engineer + Code Reviewer | hive-mind hierarchical-mesh byzantine 6 |
+| Code review only | Code Reviewer | hierarchical 3 raft specialized |
+| Strategy review | analyst + researcher | mesh 3 gossip balanced |
+| Content review | Code Reviewer (content) | single agent |