monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/skills/mastermind/_agent-select.md

@@ -0,0 +1,132 @@
+---
+name: mastermind-agent-select
+description: Shared utility — registry-aware agent selection for mastermind domain skills. Reads .monomind/registry.json and returns ranked agent slugs/names for a given task, prompt, and category filter. Include this logic wherever a domain skill needs to pick the best agent(s) instead of hardcoding types.
+type: helper
+---
+
+# Agent Selection from Registry
+
+Use this pattern whenever a mastermind skill needs to select specialist agents. The registry lives at `.monomind/registry.json` and contains all 257+ available agent types with their category labels.
+
+---
+
+## Standard Selection Block
+
+```bash
+# AGENT SELECTION — pick best agents for the current task
+# Set these before the block:
+#   REGISTRY=".monomind/registry.json"
+#   PROMPT="<the user's prompt or idea description>"
+#   CATEGORIES="marketing strategy product"   # space-separated; adjust per domain
+#   TOP_N=6                                   # how many agents to return
+
+REGISTRY="${REGISTRY:-.monomind/registry.json}"
+
+# 1. Extract candidates from the registry filtered by category
+candidates=$(jq -r \
+  --arg cats "$CATEGORIES" \
+  '[ (.agents // [])[]
+     | select(.deprecated != true)
+     | select(
+         .category as $c |
+         ($cats | split(" ") | any(. == $c))
+       )
+     | {name: .name, slug: .slug, category: .category}
+   ] | unique_by(.slug) | .[]' \
+  "$REGISTRY")
+
+# 2. Score each candidate by keyword overlap with the prompt
+# Extract keywords from prompt (words ≥5 chars, lowercase)
+keywords=$(echo "$PROMPT" | tr '[:upper:]' '[:lower:]' | grep -oE '[a-z]{5,}' | sort -u | tr '\n' ' ')
+
+selected_agents=$(echo "$candidates" | jq -Rs \
+  --arg kw "$keywords" \
+  --argjson n "$TOP_N" \
+  '
+  [ split("\n")[] | select(length > 0) | fromjson ] |
+  map(
+    . as $agent |
+    ($kw | split(" ")) as $keywords |
+    ($agent.name | ascii_downcase) as $name |
+    ($agent.category | ascii_downcase) as $cat |
+    {
+      agent: $agent,
+      score: ([$keywords[] | if (($name | contains(.)) or ($cat | contains(.))) then 1 else 0 end] | add // 0)
+    }
+  ) |
+  sort_by(-.score) |
+  .[0:$n] |
+  map(.agent)
+  ')
+
+echo "$selected_agents"
+```
+
+The output is a JSON array of `{name, slug, category}` objects. Use `.name` as the `subagent_type` in Task calls, `.slug` for display.
+
+---
+
+## Category Map — which categories to filter per domain
+
+| Domain / purpose | Categories to include |
+|---|---|
+| **Idea — user/market angles** | `marketing strategy product academic` |
+| **Idea — technical angles** | `engineering development architecture` |
+| **Idea — ops/business angles** | `sales strategy product project-management` |
+| **Build** | `engineering development architecture devops testing` |
+| **Marketing** | `marketing paid-media strategy` |
+| **Sales** | `sales strategy product` |
+| **Research** | `academic specialized strategy` |
+| **Content** | `marketing specialized` |
+| **Ops** | `project-management strategy support` |
+| **Release** | `devops github engineering` |
+| **Review** | `engineering testing analysis` |
+| **Finance** | `strategy specialized` |
+
+---
+
+## Quick Pattern: pick ONE best agent for a specific task
+
+```bash
+# Pick the single best agent for a task description
+TASK_DESC="<one-line description of what this agent must do>"
+CATS="engineering development"
+
+best_agent=$(jq -r \
+  --arg cats "$CATS" \
+  --arg task "$(echo "$TASK_DESC" | tr '[:upper:]' '[:lower:]')" \
+  '[ (.agents // [])[]
+     | select(.deprecated != true)
+     | select(.category as $c | ($cats | split(" ") | any(. == $c)))
+     | {name: .name, slug: .slug,
+        score: (.name | ascii_downcase | if contains($task) then 2 else 0 end)}
+   ]
+   | sort_by(-.score)
+   | .[0].name // "coder"' \
+  "$REGISTRY")
+```
+
+---
+
+## Fallback
+
+If the registry is missing or empty, fall back to these safe defaults per domain:
+
+| Domain | Fallback agents |
+|---|---|
+| idea specialists | `researcher`, `Trend Researcher`, `Growth Hacker` |
+| dev decomp | `Software Architect` |
+| ops decomp | `Product Manager` |
+| build | `coder`, `tester`, `reviewer` |
+| marketing | `Content Creator`, `SEO Specialist` |
+| sales | `Outbound Strategist`, `Deal Strategist` |
+
+---
+
+## Usage in a domain skill
+
+1. Set `REGISTRY`, `PROMPT`, `CATEGORIES`, `TOP_N`
+2. Run the Standard Selection Block
+3. Parse `selected_agents` JSON array
+4. Spawn Task agents using `.name` as `subagent_type`, one per entry
+5. If `selected_agents` is empty or registry missing: use the fallback list above

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

@@ -0,0 +1,83 @@
+---
+name: mastermind-delegation
+description: Agent Delegation Capability — injected into every spawned agent prompt so subagents can further delegate specialized work. Never invoked directly; referenced by _protocol.md and domain skills.
+type: shared
+---
+
+# Agent Delegation Capability
+
+This file defines the **AGENT DELEGATION CAPABILITY** block that MUST be included verbatim in every `Task` / `Agent` spawn within mastermind and monomind commands.
+
+Including it in every agent prompt makes delegation **recursive**: an agent can spawn sub-agents, which can spawn their own sub-agents, each with full access to the same capability.
+
+---
+
+## How to use this file
+
+When writing a Task/Agent `description` or `prompt`, paste the section below verbatim after `BRAIN CONTEXT:`. Do not paraphrase — paste it as-is so sub-agents receive the full capability statement.
+
+---
+
+## AGENT DELEGATION CAPABILITY [paste this block into every agent prompt]
+
+```
+== AGENT DELEGATION CAPABILITY ==
+You have full access to the Agent tool (Claude Code: Task tool) to spawn
+sub-agents for any specialized subtask. This capability is recursive —
+sub-agents you spawn also receive it.
+
+Available agent categories (use the exact slug or name):
+
+  CORE      coder · reviewer · tester · planner · researcher
+  BACKEND   backend-dev · Backend Architect · DB Optimizer · API Tester
+  FRONTEND  Frontend Developer · mobile-dev · Mobile App Builder
+  ARCH      Software Architect · system-architect
+  SECURITY  Security Engineer · security-architect
+  AI/ML     AI Engineer · ml-developer · Data Engineer
+  DEVOPS    DevOps Automator · SRE · cicd-engineer
+  DOCS      Technical Writer · api-docs
+  PRODUCT   Product Manager · Launch Strategist · CRO Specialist
+  MARKETING Content Creator · SEO Specialist · Growth Hacker · Email Marketing
+  SOCIAL    TikTok · LinkedIn · Twitter · Instagram Strategist
+  SALES     Deal Strategist · Sales Coach · Outbound Strategist
+  BUSINESS  Finance Tracker · Legal Compliance Checker · Analytics Reporter
+  DESIGN    Monodesign (UI/UX · brand · CSS · animation · design systems)
+
+WHEN to delegate:
+- A subtask needs deeper expertise than your primary role
+- Work can be done faster in parallel by concurrent specialists
+- A subtask is outside your domain but blocks your progress
+
+HOW to delegate:
+  Agent({
+    subagent_type: "agent-slug",
+    description: "Short task label",
+    prompt: `Full self-contained briefing — treat every sub-agent as cold-start.
+             Include: context, scope, success criteria, and this AGENT DELEGATION
+             CAPABILITY block so they can further delegate if needed.`,
+    run_in_background: true   // use for parallel work
+  })
+
+RULES:
+- Always pass enough context for the sub-agent to work independently
+- Collect and synthesize sub-agent results before writing your final output
+- Report what you delegated and what each sub-agent returned
+- If a sub-agent is blocked, handle it rather than silently failing
+=================================
+```
+
+---
+
+## Placement in agent prompts
+
+```
+BRAIN CONTEXT:
+[...]
+=====================
+
+== AGENT DELEGATION CAPABILITY ==
+[full block above]
+=================================
+
+YOUR GOAL: [task description]
+```

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

@@ -0,0 +1,83 @@
+---
+name: mastermind-intake
+description: Shared intake protocol for mastermind — rich-prompt detection, comprehensive intake questions asked one at a time, and LLM-decide logic. Never invoked directly; called by master and standalone domain commands.
+type: shared
+---
+
+# Mastermind Intake Protocol
+
+This file is referenced by `master.md` and domain commands. Never invoke directly.
+
+---
+
+## Rich Prompt Detection
+
+Count the words in `$ARGUMENTS` and scan for domain signals.
+
+**Rich prompt** (skip all intake questions → proceed to execution):
+- Word count ≥ 20 AND
+- Contains at least one domain signal (build, ship, feature, bug, fix, campaign, marketing, SEO, content, review, audit, research, launch, release, sales, outreach, ops, finance, report) AND
+- Contains a goal or outcome phrase (e.g. "so that", "by end of", "targeting", "for our", "to improve")
+
+**Vague prompt** (run intake): anything that doesn't meet rich-prompt criteria.
+
+Even with a rich prompt, if `--confirm` flag is present: skip to execution but show the plan before spawning agents and wait for "go".
+
+---
+
+## Intake Questions
+
+Ask ONE question at a time. Wait for the answer before asking the next. Stop asking as soon as you have enough to proceed.
+
+**Q1 — Goal:**
+> "What outcome defines success for this run? Be as specific as you can — what will be done or produced when we're finished?"
+
+**Q2 — Scope:**
+> "Which business domains should this touch? Options: build, idea, marketing, review, research, content, release, sales, ops, finance — or should I decide based on the goal?"
+
+**Q3 — Constraints:**
+> "Any constraints I should know about? Examples: don't touch production, stay within this codebase, only content work this week, timeline by end of sprint."
+
+**Q4 — Mode:**
+> "Should I execute automatically once I have a plan, or show you the plan first and wait for your approval before spawning agents?"
+
+**Q5 — Project:**
+> "Which project is this for? I'll create or find a monotask space with that name. (Or I can infer it from context.)"
+
+Skip Q4 if `--auto` or `--confirm` flag was provided. Skip Q5 if `--project <name>` flag was provided.
+
+---
+
+## LLM-Decide Rule
+
+If the user responds with any of: "decide yourself", "you decide", "your call", "whatever you think", "up to you" — to any intake question:
+
+1. Make an explicit decision. State it clearly:
+   > "I'm choosing [X] because [one-sentence reason]."
+2. Log this as a decision in the run's output schema with `confidence: 0.7` and `outcome: pending`.
+3. Continue immediately. Do NOT ask a follow-up on the same question.
+
+---
+
+## Mode Resolution
+
+After intake (or skip), resolve the execution mode:
+
+| Flag / Answer | Mode |
+|---|---|
+| `--auto` flag | auto — spawn immediately after planning |
+| `--confirm` flag | confirm — show plan, wait for "go" |
+| Q4 answer: "auto" or "yes go ahead" | auto |
+| Q4 answer: "show me first" or "confirm" | confirm |
+| No flag, vague prompt | confirm (default for vague) |
+| No flag, rich prompt | auto (default for rich) |
+
+---
+
+## Project Name Resolution
+
+Priority order:
+1. `--project <name>` flag — use exactly as provided
+2. Q5 answer — use as provided
+3. Infer from prompt: extract the most prominent product/project noun
+4. Fallback: use today's date as `session-YYYY-MM-DD`