monomind 1.16.6 → 1.16.8

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

@@ -0,0 +1,392 @@
+---
+name: mastermind-liveness
+description: Mastermind liveness — enforce the non-terminal issue liveness contract for agent-owned work. Checks if every in_progress/blocked/in_review issue has a valid action path (active run, queued wake, explicit blocker, or recovery action). Can checkout an issue to an agent run, release checkout, trigger wakeup decisions, and file explicit recovery actions for stalled issues. Based on Paperclip's execution-semantics.md liveness contract.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Liveness
+
+This skill is invoked by `mastermind:liveness` or directly via `/mastermind:liveness`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to check (required)
+- `action`: check | checkout | release | wakeup | recover
+- `issue_id`: specific issue to operate on (required for checkout/release/wakeup/recover)
+- `agent_id`: agent claiming checkout (required for checkout)
+- `run_id`: execution run ID (required for checkout)
+- `reason`: recovery reason (required for recover)
+- `caller`: command | master
+
+---
+
+## Liveness Contract
+
+An issue is **healthy** when the product can answer "what moves this forward next?" without requiring a human to reconstruct intent.
+
+An issue is **stalled** when it is non-terminal but has no:
+- active run linked to the issue
+- queued wake or continuation deliverable to the responsible agent
+- explicit execution-policy participant
+- pending interaction waiting on a specific responder
+- one-shot monitor (`nextCheckAt`) that will wake the assignee
+- human owner (`assigneeUserId`)
+- first-class blocker chain whose leaf issues are themselves healthy
+- open explicit recovery action naming owner + next action
+
+**Valid non-terminal statuses for agent-owned work:** `todo`, `in_progress`, `blocked`, `in_review`
+
+**Status → execution expectation:**
+- `todo`: actionable but not yet claimed — may still need wake path to assignee
+- `in_progress`: must have agent assignee + active execution backing (strict)
+- `blocked`: must have named external dependency (blockedByIssueIds) or explicit human decision needed
+- `in_review`: review participant must be named; next move belongs to reviewer
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — Load Org and Issues
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
+
+issuesFile=".monomind/orgs/${org_name}-issues.json"
+stateFile=".monomind/orgs/${org_name}-state.json"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### check (default)
+
+Audit every non-terminal agent-owned issue for liveness. Flag stalled issues.
+
+```bash
+echo "LIVENESS CHECK — ${org_name}"
+echo "════════════════════════════════════════════════════════"
+
+python3 - "$issuesFile" "$stateFile" <<'PYEOF'
+import json, sys, os
+from datetime import datetime, timedelta
+
+issues_path = sys.argv[1]
+state_path  = sys.argv[2]
+
+# Load issues
+if not os.path.exists(issues_path):
+    print("  No issues file found. Org has no tracked issues.")
+    sys.exit(0)
+
+data   = json.load(open(issues_path))
+issues = data.get("issues", [])
+
+# Load active agent run IDs from state
+active_runs = set()
+if os.path.exists(state_path):
+    try:
+        state = json.load(open(state_path))
+        for role in state.get("roles", []):
+            if role.get("currentRunId"): active_runs.add(role["currentRunId"])
+    except: pass
+
+non_terminal_statuses = {"todo","in_progress","blocked","in_review"}
+terminal_statuses     = {"done","cancelled"}
+
+healthy, stalled, warnings = [], [], []
+now = datetime.utcnow()
+
+for iss in issues:
+    status = iss.get("status","")
+    if status in terminal_statuses or status not in non_terminal_statuses:
+        continue
+
+    aId = iss.get("assigneeAgentId") or iss.get("assigneeId")
+    uId = iss.get("assigneeUserId")
+    iid = iss.get("id","?")
+    title = iss.get("title","?")[:50]
+
+    # User-owned: skip strict execution checks
+    if uId and not aId:
+        healthy.append((iid, title, status, "user-owned"))
+        continue
+
+    # Evaluate liveness
+    paths = []
+
+    run_id = iss.get("executionRunId") or iss.get("checkoutRunId")
+    if run_id and run_id in active_runs:
+        paths.append("active-run")
+
+    blockers = iss.get("blockedByIssueIds") or []
+    if status == "blocked" and blockers:
+        unresolved = [b for b in blockers if b not in
+                      {i["id"] for i in issues if i.get("status") in terminal_statuses}]
+        if unresolved:
+            paths.append(f"blocked-by:{','.join(unresolved[:2])}")
+        else:
+            # All blockers resolved — should transition
+            warnings.append((iid, title, status, "all blockers resolved but issue still blocked"))
+
+    if iss.get("executionPolicy", {}).get("monitor", {}).get("nextCheckAt"):
+        paths.append("monitor")
+
+    if iss.get("recoveryActions") and any(
+        r.get("status") not in ("resolved","cancelled")
+        for r in iss.get("recoveryActions",[])
+    ):
+        paths.append("recovery-action")
+
+    if iss.get("currentParticipant"):
+        paths.append("participant")
+
+    # Stale heartbeat check (in_progress with no run and no recent update)
+    if status == "in_progress" and aId and not paths:
+        updated = iss.get("updatedAt","")
+        if updated:
+            try:
+                age = now - datetime.fromisoformat(updated[:19])
+                if age > timedelta(hours=2):
+                    stalled.append((iid, title, status, f"in_progress {int(age.total_seconds()//3600)}h with no active path"))
+                    continue
+            except: pass
+        stalled.append((iid, title, status, "in_progress with no active execution path"))
+        continue
+
+    if not paths and status == "todo" and aId:
+        warnings.append((iid, title, status, "todo assigned to agent — may need wakeup"))
+    elif paths:
+        healthy.append((iid, title, status, " + ".join(paths)))
+    else:
+        healthy.append((iid, title, status, "no agent assignee"))
+
+print(f"  ✓ Healthy: {len(healthy)}")
+if healthy:
+    for iid, t, s, p in healthy[:5]:
+        print(f"    {iid}: [{s}] {t} — {p}")
+    if len(healthy) > 5: print(f"    … {len(healthy)-5} more")
+
+print()
+if stalled:
+    print(f"  ✗ STALLED: {len(stalled)}")
+    for iid, t, s, p in stalled:
+        print(f"    {iid}: [{s}] {t}")
+        print(f"      → {p}")
+    print()
+    print("  Fix: /mastermind:liveness --org <org> --action recover --issue-id <id> --reason 'execution path lost'")
+else:
+    print("  ✓ No stalled issues.")
+
+if warnings:
+    print()
+    print(f"  ⚠ Warnings: {len(warnings)}")
+    for iid, t, s, p in warnings:
+        print(f"    {iid}: [{s}] {t} — {p}")
+PYEOF
+```
+
+### checkout
+
+Claim an issue for execution by an agent run. Sets `checkoutRunId` and `executionRunId`.
+
+```bash
+[ -z "$issue_id" ] && { echo "ERROR: --issue-id required."; exit 1; }
+[ -z "$agent_id" ] && { echo "ERROR: --agent-id required."; exit 1; }
+[ -z "$run_id"   ] && { echo "ERROR: --run-id required."; exit 1; }
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+python3 - "$issuesFile" "$issue_id" "$agent_id" "$run_id" "$ts" <<'PYEOF'
+import json, sys
+
+path, iid, agentId, runId, ts = sys.argv[1:]
+data = json.load(open(path))
+issues = data.get("issues", [])
+
+found = False
+for iss in issues:
+    if iss.get("id") == iid:
+        existing = iss.get("checkoutRunId")
+        if existing and existing != runId:
+            print(f"  CONFLICT: Issue already checked out by run {existing}")
+            print(f"  Release first: /mastermind:liveness --org <org> --action release --issue-id {iid}")
+            sys.exit(1)
+        iss["checkoutRunId"]  = runId
+        iss["executionRunId"] = runId
+        iss["assigneeId"]     = agentId
+        iss["assigneeAgentId"]= agentId
+        iss["status"]         = "in_progress"
+        iss["checkedOutAt"]   = ts
+        iss["updatedAt"]      = ts
+        found = True
+        print(f"  CHECKOUT: Issue {iid} → agent {agentId}, run {runId}")
+        print(f"  Status set to: in_progress")
+        break
+
+if not found:
+    print(f"  ERROR: Issue '{iid}' not found.")
+    sys.exit(1)
+
+data["issues"] = issues
+with open(path, "w") as f:
+    json.dump(data, f, indent=2)
+PYEOF
+```
+
+### release
+
+Release the checkout lock on an issue.
+
+```bash
+[ -z "$issue_id" ] && { echo "ERROR: --issue-id required."; exit 1; }
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+python3 - "$issuesFile" "$issue_id" "$ts" "${run_id:-}" <<'PYEOF'
+import json, sys, os
+
+path, iid, ts, run_id = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
+data = json.load(open(path))
+issues = data.get("issues", [])
+
+for iss in issues:
+    if iss.get("id") == iid:
+        current = iss.get("checkoutRunId","")
+        if run_id and current != run_id:
+            print(f"  WARNING: Releasing run {run_id} but issue has run {current}. Proceeding.")
+        iss.pop("checkoutRunId", None)
+        iss.pop("executionRunId", None)
+        iss.pop("checkedOutAt", None)
+        iss["updatedAt"] = ts
+        print(f"  RELEASED: Checkout cleared for issue {iid}")
+        print(f"  Status remains: {iss.get('status','?')} — update separately if needed.")
+        data["issues"] = issues
+        with open(path, "w") as f:
+            json.dump(data, f, indent=2)
+        sys.exit(0)
+
+print(f"  ERROR: Issue '{iid}' not found.")
+sys.exit(1)
+PYEOF
+```
+
+### wakeup
+
+Decide whether the assignee of a `todo` or `blocked` issue should be woken.
+
+```bash
+[ -z "$issue_id" ] && { echo "ERROR: --issue-id required."; exit 1; }
+
+python3 - "$issuesFile" "$stateFile" "$issue_id" "${agent_id:-}" <<'PYEOF'
+import json, sys, os
+
+issues_path, state_path, iid, actor_agent_id = sys.argv[1:]
+
+data = json.load(open(issues_path))
+iss = next((i for i in data.get("issues",[]) if i.get("id") == iid), None)
+if not iss:
+    print(f"  ERROR: Issue '{iid}' not found.")
+    sys.exit(1)
+
+checkout_agent = iss.get("assigneeAgentId") or iss.get("assigneeId","")
+checkout_run   = iss.get("checkoutRunId","")
+
+# Port of Paperclip's shouldWakeAssigneeOnCheckout logic
+actor_is_agent     = bool(actor_agent_id)
+actor_differs      = actor_agent_id != checkout_agent
+checkout_has_no_run= not checkout_run
+
+should_wake = (
+    not actor_is_agent          # non-agent actor (board/human) → always wake
+    or actor_differs            # different agent claiming → wake original
+    or checkout_has_no_run      # no active run → wake to get work started
+)
+
+print(f"  Issue:   {iid} — {iss.get('title','?')[:60]}")
+print(f"  Status:  {iss.get('status','?')}")
+print(f"  Assignee:{checkout_agent or '(none)'}")
+print(f"  Run:     {checkout_run or '(none)'}")
+print(f"  Actor:   {actor_agent_id or '(board)'}")
+print()
+if should_wake:
+    print("  WAKE: YES — assignee should be notified to pick up this issue.")
+    print("  Reasons:")
+    if not actor_is_agent:           print("    · Non-agent actor (board/human)")
+    if actor_is_agent and actor_differs: print(f"    · Actor ({actor_agent_id}) != assignee ({checkout_agent})")
+    if checkout_has_no_run:          print("    · No active execution run")
+else:
+    print("  WAKE: NO — assignee already has an active run for this issue.")
+PYEOF
+```
+
+### recover
+
+File an explicit recovery action on a stalled issue with a named owner and next step.
+
+```bash
+[ -z "$issue_id" ] && { echo "ERROR: --issue-id required."; exit 1; }
+[ -z "$reason"   ] && { echo "ERROR: --reason required."; exit 1; }
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+recoveryId="recovery-$(python3 -c 'import time; print(int(time.time()*1000))')"
+
+python3 - "$issuesFile" "$issue_id" "$recoveryId" "${agent_id:-operator}" "$reason" "$ts" <<'PYEOF'
+import json, sys
+
+path, iid, rid, owner, cause, ts = sys.argv[1:]
+data = json.load(open(path))
+issues = data.get("issues", [])
+
+for iss in issues:
+    if iss.get("id") == iid:
+        recovery = {
+            "id": rid,
+            "kind": "restore-liveness",
+            "owner": owner,
+            "cause": cause,
+            "createdAt": ts,
+            "status": "open",
+            "nextAction": f"Investigate why issue '{iid}' has no active execution path and restore it.",
+        }
+        iss.setdefault("recoveryActions", []).append(recovery)
+        iss["status"] = "blocked"
+        iss["updatedAt"] = ts
+        data["issues"] = issues
+        with open(path, "w") as f:
+            json.dump(data, f, indent=2)
+        print(f"  RECOVERY ACTION FILED: {rid}")
+        print(f"  Issue {iid} → status: blocked (pending recovery)")
+        print(f"  Owner: {owner}")
+        print(f"  Cause: {cause}")
+        print(f"  Resolve with: /mastermind:liveness --org <org> --action checkout --issue-id {iid} --agent-id <id> --run-id <id>")
+        sys.exit(0)
+
+print(f"  ERROR: Issue '{iid}' not found.")
+sys.exit(1)
+PYEOF
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org_name: <org_name>
+issue_id: <issue_id or all>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

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

@@ -0,0 +1,228 @@
+---
+name: mastermind-marketing
+description: Mastermind marketing domain — campaigns, copy, SEO, social media strategy. Spawns a Marketing Manager who coordinates content, SEO, social, and analytics agents in parallel.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Marketing Domain
+
+This skill is invoked by `mastermind:master` or directly via `/mastermind:marketing`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via _protocol.md brain load)
+- `prompt`: the marketing goal for this run
+- `project_name`: monotask space name
+- `board_id`: monotask board ID (set by master, or created standalone)
+- `mode`: auto | confirm
+
+---
+
+## Reference Library
+
+Before building any task briefing, identify which reference files apply and include their paths in the agent's instructions with a directive to Read them before starting work.
+
+| Reference | When to include |
+|---|---|
+| `references/persuasion-psychology.md` | **Always** — all marketing tasks |
+| `references/copywriting-frameworks.md` | Copy tasks: landing pages, headlines, CTAs, hero sections, any page copy; email copy: subject lines, cold outreach, nurture sequences |
+| `.claude/skills/stop-slop/SKILL.md` | **All copy review** — run before delivering any written asset |
+| `.claude/skills/stop-slop/references/phrases.md` | Full copy edit pass — check for banned phrases |
+| `.claude/skills/stop-slop/references/structures.md` | Full copy edit pass — check structural patterns |
+
+In each agent task briefing, add:
+```
+REFERENCE FILES: Read these before starting:
+- .claude/skills/mastermind/references/persuasion-psychology.md
+[For copy tasks (landing pages, CTAs, email copy, headlines, subject lines), also read:]
+- .claude/skills/mastermind/references/copywriting-frameworks.md
+[For all copy review/edit passes, also read:]
+- .claude/skills/stop-slop/SKILL.md
+- .claude/skills/stop-slop/references/phrases.md
+- .claude/skills/stop-slop/references/structures.md
+```
+
+---
+
+## Specialist Agent Routing
+
+Use these agents instead of generic types when the task is domain-specific:
+
+| Task | Agent slug | When to use |
+|---|---|---|
+| Email sequences, drip campaigns, cold outreach | `email-specialist` | Any multi-email flow or cold email |
+| Page CRO, signup flow, form, popup optimization | `cro-specialist` | Conversion analysis or optimization |
+| Pricing decisions, tier design, pricing pages | `pricing-strategist` | Any pricing or packaging task |
+| Product launch, feature announcement, GTM | `launch-strategist` | Any launch or release |
+| Competitor pages, content strategy, topic planning | `competitive-content` | Competitive content or editorial planning |
+| General copy and content | `content-creator` | Multi-platform content, brand storytelling |
+| SEO audits, keyword strategy | `seo-specialist` | Technical SEO, organic search |
+| Social media | `social-media-strategist` | Social content and calendars |
+| Paid ads | `ad-creative-strategist` | Ad copy and paid creative |
+
+For tasks outside these domains (referral programs, schema markup, analytics tracking), name the appropriate specialist agent in the briefing and let it handle depth.
+
+---
+
+## Complexity Assessment
+
+Assess the prompt to determine execution mode:
+
+**Simple (direct execution):** Single asset, single agent:
+- "Write one tweet announcing the new API release"
+- "Draft a subject line for the newsletter"
+→ Use a single Content Creator agent. Skip manager delegation.
+
+**Complex (spawn Marketing Manager agent):** Any of these:
+- Full campaign across multiple channels
+- SEO audit or keyword strategy
+- Social media calendar or multi-post series
+- Launch strategy requiring copy + analytics + distribution
+→ Spawn Marketing 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: `marketing`)
+2. Run intake from _intake.md if prompt is vague
+3. Follow _protocol.md Monotask Space+Board Setup Procedure:
+   ```bash
+   project_name="${project_name:-$(basename "$PWD")}"
+   space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$project_name" '$2==n{print $1}' | head -1)
+   [ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+   [ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$project_name'"; exit 1; }
+   board_id=$(monotask board create "marketing" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create marketing board"; exit 1; }
+   monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
+   todo_col=$(monotask column create "$board_id" "Todo"  --json | jq -r '.id')
+   doing_col=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
+   done_col=$(monotask column create "$board_id" "Done"  --json | jq -r '.id')
+   ```
+4. Proceed with complexity assessment below
+5. At end: follow _protocol.md Brain Write Procedure (namespace: `marketing`)
+
+---
+
+## Complex Execution — Marketing Manager Agent
+
+Spawn a Marketing Manager agent via Task tool:
+
+```javascript
+Task({
+  subagent_type: "coordinator",
+  description: `You are the Marketing Manager for project <project_name>.
+
+CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:marketing
+
+BRAIN CONTEXT:
+<brain_context>
+
+YOUR BOARD: <board_id>
+YOUR GOAL: <prompt>
+
+STEP 1 — PLAN
+Decompose the marketing goal into parallel workstreams. For each workstream, identify:
+- Which channel or medium it targets (social, SEO, email, paid, content)
+- Which specialist to assign
+- What deliverables are needed (copy, strategy doc, keyword list, calendar)
+- Dependencies between workstreams
+
+STEP 2 — CREATE TASKS
+For each workstream, 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 workstream goal, ≤80 chars>" --json)
+CARD_ID=$(echo "$result" | jq -r '.id // empty')
+monotask card set-description "$BOARD_ID" "$CARD_ID" "[specific marketing workstream goal]"
+monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Marketing Manager
+BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
+SCOPE: [channel, audience, tone, brand constraints]
+CONSTRAINTS: [brand voice, legal/compliance, budget limits, existing assets]
+REFERENCE FILES: [for copy/content workstreams: .claude/skills/mastermind/references/persuasion-psychology.md; for copy tasks also: .claude/skills/mastermind/references/copywriting-frameworks.md; for copy review/edit: .claude/skills/stop-slop/SKILL.md, .claude/skills/stop-slop/references/phrases.md, .claude/skills/stop-slop/references/structures.md]
+SUCCESS CRITERIA:
+- [ ] [checkable item]
+AGENT: [Content Creator | Email Marketing Specialist | CRO Specialist | Pricing Strategist | Launch Strategist | Competitive Content Strategist | SEO Specialist | Social Media Strategist | Analytics Reporter | Ad Creative Strategist]
+SWARM: star 5 parallel
+DEPENDENCIES: [task IDs or \"none\"]
+OUTPUT FORMAT: unified output schema"
+```
+
+STEP 3 — EXECUTE
+Spawn one Task agent per workstream (all in parallel — star topology, hub aggregates):
+- Copy and content: subagent_type "Content Creator"
+- SEO: subagent_type "SEO Specialist"
+- Social media: subagent_type "Social Media Strategist"
+- Analytics and measurement: subagent_type "Analytics Reporter"
+- Ad creative: subagent_type "Ad Creative Strategist"
+- Email sequences / drip campaigns: subagent_type "Email Marketing Specialist" (slug: email-specialist)
+- Page / flow CRO: subagent_type "CRO Specialist" (slug: cro-specialist)
+- Pricing strategy / packaging: subagent_type "Pricing Strategist" (slug: pricing-strategist)
+- Product launch / GTM: subagent_type "Launch Strategist" (slug: launch-strategist)
+- Competitive content / comparison pages: subagent_type "Competitive Content Strategist" (slug: competitive-content)
+
+Also run /mastermind:do --board <board_id> to track execution.
+
+STEP 4 — COLLECT AND RETURN
+Collect all agent outputs. Return to caller:
+
+domain: marketing
+status: complete | partial | blocked
+artifacts:
+  - path: [each asset created — copy doc, keyword list, social calendar]
+    type: copy
+decisions:
+  - what: [channel prioritization or messaging decisions]
+    why: [reasoning]
+    confidence: [0.0-1.0]
+    outcome: pending | shipped
+lessons:
+  - what_worked: [which channels or approaches were strongest]
+  - what_didnt: [what needed more brand context or iteration]
+next_actions:
+  - [e.g. "run mastermind:content to produce the blog series"]
+  - [e.g. "run mastermind:review on the campaign copy"]
+board_url: monotask://<project_name>/marketing
+run_id: <ISO8601-timestamp>`,
+  run_in_background: true
+})
+```
+
+---
+
+## Simple Execution
+
+For simple tasks (single agent, single asset):
+
+1. Spawn one Task agent with the marketing 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 campaign | coordinator + channel specialists | star 5 parallel |
+| SEO strategy | SEO Specialist | hierarchical 3 raft specialized |
+| Social calendar | Social Media Strategist | hierarchical 3 raft specialized |
+| Copy production | Content Creator | single agent or hierarchical 3 |
+| Email sequence | Email Marketing Specialist | single agent |
+| Cold outreach | Email Marketing Specialist | single agent |
+| Page / flow CRO | CRO Specialist | single agent |
+| Pricing design | Pricing Strategist | single agent |
+| Product launch | Launch Strategist + Content Creator | hierarchical 3 |
+| Competitive content | Competitive Content Strategist | single agent |
+| Analytics review | Analytics Reporter | single agent |