monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/.claude/skills/mastermind-release/SKILL.md

@@ -1,168 +0,0 @@
----
-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 mastermind-protocol/SKILL.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 mastermind-protocol/SKILL.md Brain Load Procedure (namespace: `release`)
-2. Run intake from mastermind-intake/SKILL.md if prompt is vague
-3. Follow mastermind-protocol/SKILL.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 "release" --json | jq -r '.id // empty')
-   [ -z "$board_id" ] && { echo "ERROR: Failed to create release 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 mastermind-protocol/SKILL.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(.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 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 /mastermind: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/packages/@monomind/cli/.claude/skills/mastermind-repeat/SKILL.md

@@ -1,171 +0,0 @@
----
-name: mastermind-repeat
-description: REPEAT POSTAMBLE — executes inter-session repeat/tillend loop continuation after any mastermind or monomind command completes. Calls ScheduleWakeup when work remains.
-type: protocol-skill
----
-
-# REPEAT POSTAMBLE
-
-<EXTREMELY-IMPORTANT>
-## MANDATORY EXECUTION — READ THIS FIRST
-
-This postamble is **not optional**. You MUST execute every step below. You MUST call ScheduleWakeup unless a legitimate stop condition is met (stop file, empty round confirmed by git, or count reached).
-
-**Anti-rationalization rules:**
-- "I think the work is done" is NOT a reason to stop. Only the checks below decide.
-- "The skill already handled everything" is NOT a reason to skip this postamble.
-- "There's nothing more to do" is NOT your decision — the tillend check decides.
-- For `--repeat N`: you MUST run all N iterations. The count is non-negotiable. You cannot stop at run 3 of 5 because you think 3 was enough.
-- For `--tillend`: you MUST continue until git AND your assessment BOTH confirm an empty round. Your feeling that "it's probably clean" is not evidence.
-
-If you are about to end your response without calling ScheduleWakeup and you have not hit a legitimate stop condition, **YOU ARE MAKING AN ERROR. Go back and call ScheduleWakeup.**
-</EXTREMELY-IMPORTANT>
-
-**If neither `tillend_mode = true` nor `repeat_count ≥ 2` was active in this invocation, stop immediately — this skill is a no-op.**
-
-Otherwise execute all steps below before ending the response.
-
----
-
-## Step 1 — Stop check
-
-```bash
-[ -f ".monomind/loops/${LOOP_ID}.stop" ] && echo "STOP_REQUESTED"
-```
-
-If the stop file exists:
-- Output: `[repeat] Stop requested. Halting after run <current_rep>.`
-- Run: `rm -f ".monomind/loops/${LOOP_ID}.json" ".monomind/loops/${LOOP_ID}.stop"`
-- **END** (do not continue to Step 2).
-
----
-
-## Step 2 — Tillend termination check (tillend mode only — skip for fixed-count)
-
-**`LOOP_ASYNC_PENDING` escape hatch:** If the calling skill set `LOOP_ASYNC_PENDING=true` before invoking this postamble (because it spawned background agents whose results have not yet arrived), skip the empty-round check and go directly to Step 4 to schedule the next run. Output: `[tillend] Async work in flight — deferring empty-round check to run <next_rep>.`
-
-**Step 2a — Machine verification (REQUIRED before any self-assessment):**
-
-Run this command to get an objective signal of whether files changed during this run:
-
-```bash
-GIT_CHANGES=$(git diff --stat HEAD 2>/dev/null; git diff --cached --stat 2>/dev/null; git status --porcelain 2>/dev/null | grep -v '^\?\?' | head -20)
-echo "GIT_CHANGES_DURING_RUN: ${GIT_CHANGES:-NONE}"
-```
-
-If `GIT_CHANGES` is non-empty, files were modified — `TILLEND_EMPTY=false` regardless of your self-assessment. Skip to "Otherwise" below.
-
-**Step 2b — Self-assessment (only if git shows no changes):**
-
-Only if `GIT_CHANGES` was empty, evaluate whether this run produced findings (issues identified, problems flagged) or actions (tasks created, content written, configs changed — anything not captured by git diff).
-
-Set `TILLEND_EMPTY=true` **only if git shows no changes AND your self-assessment confirms zero findings and zero actions**.
-
-**Important**: If this round found things AND fixed them, `TILLEND_EMPTY=false` — the loop must continue to verify the fixes didn't introduce new issues.
-
-**If `TILLEND_EMPTY=true`:**
-- Output:
-  ```
-  [tillend] Empty round — nothing found, nothing changed in run <current_rep>.
-  /<command> tillend loop complete (ran <current_rep> run(s)).
-  ```
-- Emit dashboard event (non-fatal if control server is not running):
-  ```bash
-  REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-  curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "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 "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"mode\":\"tillend\",\"ranReps\":<current_rep>,\"reason\":\"empty-round\",\"project\":\"${REPO_ROOT}\",\"ts\":$(date +%s)000}" || true
-  ```
-- Run: `rm -f ".monomind/loops/${LOOP_ID}.json"`
-- **END**.
-
-**If `current_rep >= tillend_maxruns` (safety cap reached):**
-- Output:
-  ```
-  [tillend] Safety cap reached (<tillend_maxruns> runs). Stopping loop.
-  If work is still incomplete, re-run: /<command> --tillend --maxruns <N> <prompt>
-  ```
-- Run: `rm -f ".monomind/loops/${LOOP_ID}.json"`
-- **END**.
-
-**Otherwise (`TILLEND_EMPTY=false`, cap not reached):**
-- Output: `[tillend] Run <current_rep> produced findings or actions. Scheduling run <next_rep>...`
-- Continue to Step 4.
-
----
-
-## Step 3 — Fixed-count completion check (fixed-count mode only — skip for tillend)
-
-If `current_rep >= repeat_count`:
-- Output: `[repeat] All <repeat_count> runs of /<command> complete.`
-- Emit dashboard event:
-  ```bash
-  REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-  curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "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 "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"ranReps\":<repeat_count>,\"project\":\"${REPO_ROOT}\",\"ts\":$(date +%s)000}" || true
-  ```
-- Run: `rm -f ".monomind/loops/${LOOP_ID}.json"`
-- **END**.
-
----
-
-## Step 4 — Schedule next run (REQUIRED tool call — cannot be skipped)
-
-Compute `next_rep = current_rep + 1`.
-
-Update state file:
-```bash
-NOW_MS=$(python3 -c 'import time;print(int(time.time()*1000))' 2>/dev/null || echo "$(date +%s)000")
-NEXT_AT=$(( NOW_MS + <wait_seconds> * 1000 ))
-INTERVAL_MIN=$(( (<wait_seconds> + 30) / 60 ))
-LOOP_TYPE=$( [ "<tillend_mode>" = "true" ] && echo "tillend" || echo "repeat" )
-MAX_REPS=$( [ "<tillend_mode>" = "true" ] && echo "<tillend_maxruns>" || echo "<repeat_count>" )
-PROMPT_JSON=$(jq '.prompt' ".monomind/loops/${LOOP_ID}.json" 2>/dev/null \
-  || python3 -c "import json; print(json.dumps(json.load(open('.monomind/loops/${LOOP_ID}.json'))['prompt']))" 2>/dev/null \
-  || echo '"<prompt>"')
-STARTED_AT=$(jq '.startedAt' ".monomind/loops/${LOOP_ID}.json" 2>/dev/null || echo "${NOW_MS}")
-cat > ".monomind/loops/${LOOP_ID}.json" << EOF
-{
-  "id": "${LOOP_ID}",
-  "sessionId": "${LOOP_ID}",
-  "type": "${LOOP_TYPE}",
-  "command": "/<command>",
-  "prompt": ${PROMPT_JSON},
-  "maxReps": ${MAX_REPS},
-  "interval": ${INTERVAL_MIN},
-  "wait": <wait_seconds>,
-  "currentRep": <next_rep>,
-  "startedAt": ${STARTED_AT},
-  "lastRunAt": ${NOW_MS},
-  "nextRunAt": ${NEXT_AT},
-  "status": "running",
-  "source": "mastermind-repeat/SKILL.md"
-}
-EOF
-```
-
-Emit `loop:tick`:
-```bash
-REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "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 "{\"type\":\"loop:tick\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"completedRep\":<current_rep>,\"nextRep\":<next_rep>,\"nextAt\":${NEXT_AT},\"project\":\"${REPO_ROOT}\",\"ts\":$(date +%s)000}" || true
-```
-
-**Call `ScheduleWakeup` now** — this is a mandatory tool call:
-
-- **Tillend mode**:
-  - `delaySeconds`: `<wait_seconds>`
-  - `prompt`: `/<command> --tillend --maxruns <tillend_maxruns> --wait <wait_seconds> --rep <next_rep> --loop ${LOOP_ID} <original_prompt_text>`
-  - `reason`: `"tillend run <next_rep> of /<command> (cap: <tillend_maxruns>)"`
-  - Output before calling: `[tillend] Work remains. Next run in <wait_seconds>s (run <next_rep>, cap: <tillend_maxruns>)...`
-
-- **Fixed-count mode**:
-  - `delaySeconds`: `<wait_seconds>`
-  - `prompt`: `/<command> --repeat <repeat_count> --wait <wait_seconds> --rep <next_rep> --loop ${LOOP_ID} <original_prompt_text>`
-  - `reason`: `"repeat run <next_rep>/<repeat_count> of /<command>"`
-  - Output before calling: `[repeat] Next run in <wait_seconds>s (run <next_rep>/<repeat_count>)...`

package/packages/@monomind/cli/.claude/skills/mastermind-research/SKILL.md

@@ -1,168 +0,0 @@
----
-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 mastermind-protocol/SKILL.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 mastermind-protocol/SKILL.md Brain Load Procedure (namespace: `research`)
-2. Run intake from mastermind-intake/SKILL.md if prompt is vague
-3. Follow mastermind-protocol/SKILL.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 "research" --json | jq -r '.id // empty')
-   [ -z "$board_id" ] && { echo "ERROR: Failed to create research 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 mastermind-protocol/SKILL.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(.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 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 /mastermind: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 |