monomind 1.10.47 → 1.10.55

package/.claude/commands/mastermind/ideate.md

@@ -0,0 +1,261 @@
+---
+name: mastermind:ideate
+description: "Mastermind — Research ideas from a prompt, evaluate them with a PM lens, elaborate, and decompose into subtasks saved to docs/ideas/ (default) or monotask boards (--monotask flag)"
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-arguments check below.
+
+If `$ARGUMENTS` is empty, output this and STOP:
+
+> **Usage:** `/mastermind:ideate <prompt>`
+>
+> Example: `/mastermind:ideate add real-time collaboration to the editor`
+>
+> By default, ideas are saved to `docs/ideas/YYYY-MM-DD-<slug>.md`. Add `--monotask` to write to a monotask board instead.
+
+Do NOT proceed further if no arguments were provided.
+
+**Extract `--monotask` flag:** If present, set `USE_MONOTASK=true` and remove from `$ARGUMENTS`. Default: `USE_MONOTASK=false`.
+
+---
+
+## Step 0: Check monotask CLI *(skip unless `--monotask` was passed)*
+
+**Only run this step if `USE_MONOTASK=true`.**
+
+```bash
+command -v monotask || (command -v cargo && cargo install monotask)
+```
+If neither exists, tell user to install Rust + monotask and STOP.
+
+---
+
+## Step 1: Gather Project Context
+
+Collect ALL of the following in parallel (skip any that error):
+
+1. **Repo name**: Run `git remote get-url origin`, extract the last path segment, strip `.git`. Fallback: `basename` of the current working directory. Store as `REPO_NAME`.
+
+2. **README**: Read `README.md` (first 200 lines). Skip if missing.
+
+3. **Package manifest**: Read whichever exists first: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`. Extract name, description, and keywords/tags.
+
+4. **Knowledge graph**: Call `mcp__monomind__monograph_suggest` with the user's prompt (`$ARGUMENTS`). Skip if it errors or returns empty.
+
+5. **Memory search**: Call `mcp__monomind__memory_search` with the user's prompt (`$ARGUMENTS`). Use the top 5 results.
+
+Bundle all gathered information into a single `PROJECT_CONTEXT` string for downstream agents.
+
+---
+
+## Step 2: Setup Storage
+
+**File mode (default):**
+```bash
+DATE=$(date +%Y-%m-%d)
+SLUG=$(echo "$ARGUMENTS" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g; s/-\+/-/g; s/^-//; s/-$//' | cut -c1-40)
+IDEA_FILE="docs/ideas/${DATE}-${SLUG}.md"
+mkdir -p docs/ideas
+```
+Write the file header using the Write tool:
+```markdown
+---
+source: mastermind:ideate
+repo: <REPO_NAME>
+created: <DATE>
+prompt: <first 100 chars of $ARGUMENTS>
+---
+
+# Ideas: <$ARGUMENTS>
+
+```
+Store `IDEA_FILE`.
+
+---
+
+**Monotask mode:**
+- Find or create space `$REPO_NAME` → store `SPACE_ID`
+- Find or create `monomind-idea` board with columns: `New`, `Evaluated`, `Elaborated`, `Tasked`, `Iced`, `Rejected` → store `BOARD_ID` and all column IDs
+
+---
+
+## Step 3: Research Swarm -- Generate Ideas
+
+Spawn 3-5 `researcher` agents in parallel using the Agent tool (mesh topology). Each agent receives:
+
+- The user's prompt: `$ARGUMENTS`
+- The `PROJECT_CONTEXT` string from Step 1
+
+Each agent should generate ideas as a JSON array. There is no hard cap — generate as many or as few as the topic warrants. Ideas should span **two categories**:
+
+1. **Feature/capability ideas** — what to build, what problem it solves, why it matters.
+2. **Technical stack & baseline decisions** — foundational choices that must be made before implementation (e.g., "Use PostgreSQL vs SQLite for persistence", "Adopt event-driven architecture vs request-response", "Choose WebSocket vs SSE for real-time updates", "Define the API versioning strategy"). These are the "how" decisions that shape everything downstream.
+
+```json
+[
+  {
+    "title": "Short idea title",
+    "description": "2-3 sentence description of the idea, what it solves, and why it matters.",
+    "category": "feature | technical-baseline"
+  }
+]
+```
+
+After all agents complete:
+1. Merge all idea arrays.
+2. Deduplicate by title similarity (fuzzy match — drop ideas whose titles are >80% similar to an already-kept idea).
+3. Persist each unique idea:
+
+**File mode:** Append to `IDEA_FILE` using the idea section format from `_taskfile.md`:
+```markdown
+### <Idea Title>
+> status: new
+> category: <feature|technical-baseline>
+
+<description>
+
+---
+```
+
+**Monotask mode:**
+```bash
+monotask card create $BOARD_ID $COL_NEW "<title>" --json
+monotask card comment add $BOARD_ID $CARD_ID "<description>"
+monotask card label add $BOARD_ID $CARD_ID "monomind-idea"
+monotask card label add $BOARD_ID $CARD_ID "<category>"
+```
+
+If zero ideas were generated after deduplication, report "No ideas generated by the research swarm." and STOP.
+
+---
+
+## Step 4: Evaluator -- Assess Each Idea
+
+Spawn a single `Product Manager` agent via the Agent tool. Provide it with:
+- All ideas (titles + descriptions)
+- The `PROJECT_CONTEXT`
+- The user's original prompt: `$ARGUMENTS`
+
+For EACH idea, the agent must return one of three verdicts, along with an **impact** score (0-10) and an **effort** score (0-10):
+
+| Verdict | Action |
+|---------|--------|
+| **evaluated** | Idea is worth pursuing. Include a `skipElaboration` boolean: `true` if the idea is straightforward and needs no further research, `false` if edge cases should be explored. Include a 1-2 sentence value statement. Include `impact` (0-10, how much value it adds) and `effort` (0-10, how much work it requires). |
+| **iced** | Idea might have potential but needs a question answered first. Include the blocking question. Include `impact` and `effort` estimates. |
+| **rejected** | Idea is out of scope, infeasible, or low value. Include a 1-sentence reason. |
+
+For each verdict, update the storage:
+
+**File mode:** Use the Edit tool on `IDEA_FILE` to update the `> status:` line for the idea, then add the relevant fields. For `evaluated`: change to `> status: evaluated`, add `> impact: N`, `> effort: N`, `> skip_elaboration: true|false`, append `**Value:** <value statement>`. For `iced`: change to `> status: iced`, append `**Blocked by:** <question>`. For `rejected`: change to `> status: rejected`, append `**Rejected reason:** <reason>`.
+
+**Monotask mode:**
+- *evaluated:* `monotask card move $BOARD_ID $CARD_ID $COL_EVALUATED --json` + set impact/effort + add value comment
+- *iced:* `monotask card move $BOARD_ID $CARD_ID $COL_ICED --json` + set impact/effort + add blocking question comment
+- *rejected:* `monotask card move $BOARD_ID $CARD_ID $COL_REJECTED --json` + add reason comment
+
+If ALL ideas were iced or rejected, output a summary table of verdicts and STOP.
+
+---
+
+## Step 5: Elaborator -- Add Edge Cases (conditional)
+
+Check if ANY evaluated ideas have `skipElaboration: false`.
+
+**If ALL evaluated ideas have `skipElaboration: true`:**
+- *File mode:* Change each idea's `> status: evaluated` → `> status: elaborated` in `IDEA_FILE`
+- *Monotask mode:* `monotask card move $BOARD_ID $CARD_ID $COL_ELABORATED --json`
+- Skip spawning the elaborator agent entirely.
+
+**Otherwise**, spawn two agents in parallel via the Agent tool:
+
+1. A `feature-dev:code-explorer` agent — deep-dives into the existing codebase to trace execution paths, map dependencies, and surface internal constraints relevant to each idea.
+2. A `researcher` agent (with WebSearch capability) — searches the internet for prior art, external edge cases, and potential technical pitfalls.
+
+Provide both agents with:
+- All evaluated ideas that have `skipElaboration: false`
+- The `PROJECT_CONTEXT`
+
+After both agents complete, merge their findings per idea. For each idea needing elaboration:
+1. Research edge cases, prior art, codebase constraints, and technical pitfalls.
+2. Persist findings:
+   - *File mode:* Edit `IDEA_FILE` — append `**Edge cases:** <findings>` and `**Technical notes:** <notes>` under the idea section. If no blocking issues: change `> status: evaluated` → `> status: elaborated`. If blocking issue found: change to `> status: iced` and append `**Blocked by:** <issue>`.
+   - *Monotask mode:* `monotask card comment add` for findings. Move to `Elaborated` or `Iced` accordingly.
+
+Also mark `skipElaboration: true` ideas as `elaborated`.
+
+---
+
+## Step 6: Task Decomposer — Break Ideas into Subtasks
+
+### Generate the TASKS Array
+
+Spawn a single `Software Architect` agent via the Agent tool. Provide it with:
+- All ideas in the `Elaborated` column (titles, descriptions, and all comments)
+- The `PROJECT_CONTEXT`
+- **The Task Grouping Rules and Card Format from `/mastermind:createtask` Step 5** — include them verbatim in the agent prompt so it produces correctly structured tasks
+
+The agent MUST produce a `TASKS` array following the `/mastermind:createtask` task card format (Step 5). Each task must comply with all 7 grouping rules. For each elaborated idea, decompose into 2-6 subtasks.
+
+**If the architect has doubts** about decomposing an idea (unclear scope, missing info), they should:
+- Add a comment with the question
+- Move the idea to `Iced` instead of `Tasked`
+
+Store the result as `TASKS` array.
+
+### Persist Task Decomposition
+
+**File mode:** Follow `/mastermind:createtask` Steps 6–7 (file mode) to write a new task file. Use:
+- `SOURCE_TAG` = `"mastermind:ideate"`
+- `SOURCE_SUMMARY` = first 100 chars of `$ARGUMENTS`
+
+After writing the task file, update `IDEA_FILE`:
+- For each parent idea: change `> status: elaborated` → `> status: tasked`, append `**Subtasks file:** <TASK_FILE> (N tasks created)`
+
+**Monotask mode:** Follow `/mastermind:createtask` Steps 6–7 (monotask mode) with:
+- `SOURCE_TAG` = `"mastermind:ideate"`
+- After cards created: `monotask card comment add $BOARD_ID $IDEA_CARD_ID "Subtasks created:\n- <title>..."` and `monotask card move $BOARD_ID $IDEA_CARD_ID $COL_TASKED --json`
+
+Then follow `/mastermind:createtask` Step 8 (Final Dependency Review) and report results.
+
+---
+
+## Step 7: Final Summary
+
+Output a summary table:
+
+```
+| # | Idea                        | Category           | Status   | Subtasks | Total Effort | Agents |
+|---|-----------------------------|--------------------|----- ----|----------|--------------|--------|
+| 1 | <title>                     | feature            | Tasked   | 4        | 18/40        | coder, backend-dev, tester |
+| 2 | <title>                     | technical-baseline | Iced     | --       | --           | --     |
+| 3 | <title>                     | feature            | Rejected | --       | --           | --     |
+```
+
+Then output:
+- Total ideas generated: N
+- Ideas tasked: N (with M total subtasks)
+- Total effort points: X
+- Ideas iced: N
+- Ideas rejected: N
+- *File mode:* Idea file: `<IDEA_FILE>` | Task file: `<TASK_FILE>`
+- *Monotask mode:* Space: `$REPO_NAME` | Idea board: `monomind-idea` | Task board: `monomind-task`
+
+---
+
+## Step 8: Offer to Execute Tasks
+
+If there are todo tasks:
+
+*File mode:*
+```
+Skill("mastermind:do", "--file <TASK_FILE> --mode <parallel|minimal|sequential>")
+```
+
+*Monotask mode:*
+```
+Skill("mastermind:do", "--monotask --space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
+```
+
+To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/improve.md

@@ -0,0 +1,345 @@
+---
+name: mastermind:improve
+description: "Mastermind — Deeply analyze a component, research improvements online, and create improvement tasks saved to docs/improvements/ (default) or monotask boards (--monotask flag)"
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-arguments check below.
+
+If `$ARGUMENTS` is empty, output this and STOP:
+
+> **Usage:** `/mastermind:improve <component or concept>`
+>
+> Examples:
+> - `/mastermind:improve the authentication flow`
+> - `/mastermind:improve error handling across the codebase`
+> - `/mastermind:improve CLI startup performance`
+> - `/mastermind:improve the MCP server architecture`
+>
+> By default, analysis is saved to `docs/improvements/YYYY-MM-DD-<slug>.md`. Add `--monotask` to write to a monotask board instead.
+
+Do NOT proceed further if no arguments were provided.
+
+**Extract `--monotask` flag:** If present, set `USE_MONOTASK=true` and remove from `$ARGUMENTS`. Default: `USE_MONOTASK=false`.
+
+---
+
+## Step 0: Check monotask CLI *(skip unless `--monotask` was passed)*
+
+**Only run this step if `USE_MONOTASK=true`.**
+
+```bash
+command -v monotask || (command -v cargo && cargo install monotask)
+```
+If neither exists, tell user to install Rust + monotask and STOP.
+
+---
+
+## Step 1: Gather Project Context
+
+Collect ALL of the following in parallel (skip any that error):
+
+1. **Repo name**: Run `git remote get-url origin`, extract the last path segment, strip `.git`. Fallback: `basename` of the current working directory. Store as `REPO_NAME`.
+
+2. **README**: Read `README.md` (first 200 lines). Skip if missing.
+
+3. **Package manifest**: Read whichever exists first: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`. Extract name, description, and keywords/tags.
+
+4. **Knowledge graph**: Call `mcp__monomind__monograph_suggest` with the user's prompt (`$ARGUMENTS`). Skip if it errors or returns empty.
+
+5. **Memory search**: Call `mcp__monomind__memory_search` with the user's prompt (`$ARGUMENTS`). Use the top 5 results.
+
+Bundle all gathered information into a single `PROJECT_CONTEXT` string for downstream agents.
+
+**DELEGATION RULE:** Every agent spawned in this command MUST include the `== AGENT DELEGATION CAPABILITY ==` block (from `mastermind/_delegation.md`) in its prompt, immediately before `YOUR GOAL:`. This lets each agent spawn its own sub-agents when needed — delegation is recursive.
+
+---
+
+## Step 2: Deep Component Analysis
+
+This is what differentiates `/mastermind:improve` from `/mastermind:ideate`. Before generating improvement ideas, we must deeply understand the current state of the target component.
+
+Spawn 2 agents in parallel via the Agent tool:
+
+### Agent 1: `feature-dev:code-explorer`
+
+Provide it with `$ARGUMENTS` and `PROJECT_CONTEXT`. It must:
+
+1. **Trace the component** — find all files, functions, classes, and modules related to the target. Use `mcp__monomind__monograph_query` for each key term found.
+2. **Map dependencies** — what does the component depend on? What depends on it? Use `mcp__monomind__monograph_shortest_path` for key relationships.
+3. **Identify pain points** — look for:
+   - Code smells (large files, deep nesting, god objects, duplicated logic)
+   - Missing tests or low coverage areas
+   - Performance bottlenecks (synchronous I/O, N+1 patterns, unnecessary allocations)
+   - Security gaps (unvalidated inputs, missing auth checks, exposed secrets)
+   - API inconsistencies (naming, error shapes, response formats)
+   - Outdated patterns (callbacks vs async/await, old library versions)
+   - Missing error handling or silent failures
+4. **Measure complexity** — count files, lines, dependencies, and circular references.
+
+Return a structured analysis:
+```json
+{
+  "component": "name",
+  "files": ["list of files touched"],
+  "total_lines": N,
+  "dependency_count": N,
+  "pain_points": [
+    { "type": "code-smell|perf|security|api|testing|pattern", "description": "...", "file": "path", "severity": "critical|high|medium|low" }
+  ],
+  "strengths": ["things that are already well done"],
+  "architecture_notes": "how it fits into the larger system"
+}
+```
+
+### Agent 2: `researcher` (with WebSearch)
+
+Provide it with `$ARGUMENTS` and `PROJECT_CONTEXT`. It must:
+
+1. **Search for best practices** related to the component's domain (e.g., "authentication best practices 2025", "CLI performance optimization techniques").
+2. **Find competitor/prior art** — how do similar tools/libraries solve this?
+3. **Search for common improvements** — what do blog posts, conference talks, and docs recommend?
+4. **Identify emerging patterns** — new libraries, frameworks, or techniques relevant to this area.
+
+Return structured research:
+```json
+{
+  "best_practices": [
+    { "title": "...", "description": "...", "source": "url or reference" }
+  ],
+  "prior_art": [
+    { "project": "name", "approach": "how they solve it", "takeaway": "what we can learn" }
+  ],
+  "emerging_patterns": [
+    { "pattern": "name", "description": "...", "relevance": "why it matters for us" }
+  ]
+}
+```
+
+After both agents complete, merge their outputs into `COMPONENT_ANALYSIS`.
+
+---
+
+## Step 3: Setup Storage
+
+**File mode (default):**
+```bash
+DATE=$(date +%Y-%m-%d)
+SLUG=$(echo "$ARGUMENTS" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g; s/-\+/-/g; s/^-//; s/-$//' | cut -c1-40)
+IMPROVE_FILE="docs/improvements/${DATE}-${SLUG}.md"
+mkdir -p docs/improvements
+```
+Write the file header using the Write tool:
+```markdown
+---
+source: mastermind:improve
+repo: <REPO_NAME>
+created: <DATE>
+component: <$ARGUMENTS>
+---
+
+# Improvements: <$ARGUMENTS>
+
+```
+Store `IMPROVE_FILE`.
+
+---
+
+**Monotask mode:**
+- Find or create space `$REPO_NAME` → store `SPACE_ID`
+- Find or create `monomind-improve` board with columns: `Discovered`, `Evaluated`, `Approved`, `Tasked`, `Deferred`, `Rejected` → store `BOARD_ID` and all column IDs
+
+---
+
+## Step 4: Generate Improvement Ideas
+
+Spawn a single `Software Architect` agent via the Agent tool. Provide it with:
+- The user's prompt: `$ARGUMENTS`
+- The full `COMPONENT_ANALYSIS` from Step 2
+- The `PROJECT_CONTEXT` from Step 1
+
+The agent must synthesize the code analysis and online research into concrete improvement ideas. For each idea, produce:
+
+```json
+{
+  "title": "Short, action-oriented title",
+  "description": "2-3 sentences: what the improvement is, what problem it solves, and the expected benefit.",
+  "category": "performance | security | reliability | maintainability | dx | testing | architecture",
+  "evidence": "What from the analysis or research supports this (pain point ref, best practice ref, or prior art ref)",
+  "estimated_impact": "Concrete expected outcome (e.g., '50% faster CLI startup', 'eliminate 3 code smells', 'cover 5 untested edge cases')"
+}
+```
+
+**Idea generation rules:**
+- Ideas must be grounded in the analysis — no generic "add more tests" without pointing to specific gaps
+- Each idea must reference either a pain point from the code analysis or a best practice from the research
+- Prefer high-impact, low-effort ideas first
+- Include at least one idea from each applicable category (perf, security, testing, etc.)
+- No duplicates — each idea must address a distinct improvement
+
+Persist each improvement:
+
+**File mode:** Append to `IMPROVE_FILE` using the improvement section format from `_taskfile.md`:
+```markdown
+### <Improvement Title>
+> status: discovered
+> category: <category>
+
+<description>
+
+**Evidence:** <evidence>
+**Estimated impact:** <estimated_impact>
+
+---
+```
+
+**Monotask mode:**
+```bash
+monotask card create $BOARD_ID $COL_DISCOVERED "<title>" --json
+monotask card comment add $BOARD_ID $CARD_ID "<description>"
+monotask card comment add $BOARD_ID $CARD_ID "Category: <category>\nEvidence: <evidence>\nExpected impact: <estimated_impact>"
+monotask card label add $BOARD_ID $CARD_ID "monomind-improve"
+```
+
+If zero improvements were generated, report "No improvement opportunities found for this component." and STOP.
+
+---
+
+## Step 5: Evaluate and Prioritize
+
+Spawn a single `Product Manager` agent via the Agent tool. Provide it with:
+- All improvement ideas (titles, descriptions, and all comments)
+- The `COMPONENT_ANALYSIS`
+- The `PROJECT_CONTEXT`
+
+For EACH idea, the agent must return one of three verdicts, along with **impact** (0-10) and **effort** (0-10) scores:
+
+| Verdict | Criteria |
+|---------|----------|
+| **approved** | High value, feasible, aligns with project direction. Include a `skipElaboration` boolean: `true` if straightforward, `false` if needs deeper investigation. |
+| **deferred** | Good idea but wrong timing, blocked by something, or needs more research. Include the reason. |
+| **rejected** | Low value, too risky, or out of scope. Include a 1-sentence reason. |
+
+For each verdict, update storage:
+
+**File mode:** Edit `IMPROVE_FILE` — update the `> status:` line and append relevant fields:
+- *approved:* `> status: evaluated`, add `> impact: N`, `> effort: N`, `> skip_elaboration: true|false`, append `**Value:** <value statement>`
+- *deferred:* `> status: deferred`, add impact/effort, append `**Deferred reason:** <reason>`
+- *rejected:* `> status: rejected`, append `**Rejected reason:** <reason>`
+
+**Monotask mode:**
+- *approved:* move to Evaluated + set impact/effort + add value comment
+- *deferred:* move to Deferred + set impact/effort + add reason comment
+- *rejected:* move to Rejected + add reason comment
+
+If ALL improvements were deferred or rejected, output a summary table and STOP.
+
+---
+
+## Step 6: Elaborate Approved Improvements
+
+Check if ANY approved ideas have `skipElaboration: false`.
+
+**If ALL approved improvements have `skipElaboration: true`:**
+- *File mode:* Change each improvement's `> status: evaluated` → `> status: approved` in `IMPROVE_FILE`
+- *Monotask mode:* `monotask card move $BOARD_ID $CARD_ID $COL_APPROVED --json`
+- Skip spawning agents.
+
+**Otherwise**, spawn two agents in parallel via the Agent tool:
+
+1. A `feature-dev:code-explorer` agent — traces implementation paths, identifies exactly which files/functions need to change, surfaces hidden constraints and breaking changes.
+2. A `researcher` agent (with WebSearch) — searches for implementation patterns, migration guides, and gotchas specific to each improvement.
+
+After both complete, for each improvement needing elaboration:
+1. Persist findings:
+   - *File mode:* Edit `IMPROVE_FILE` — append `**Implementation path:** <files>`, `**Risks:** <breaking changes>`, `**Research:** <patterns>` under the improvement section. If no blocking issues: change `> status: evaluated` → `> status: approved`. If blocking issue: change to `> status: deferred`, append `**Deferred reason:** <issue>`.
+   - *Monotask mode:* Add three comments for implementation path, risks, research. Move to `Approved` or `Deferred` accordingly.
+
+Also mark `skipElaboration: true` improvements as `approved`.
+
+---
+
+## Step 7: Task Decomposer — Break Improvements into Subtasks
+
+### Generate the TASKS Array
+
+Spawn a single `Software Architect` agent via the Agent tool. Provide it with:
+- All ideas in the `Approved` column (titles, descriptions, and all comments including implementation paths and research)
+- The `COMPONENT_ANALYSIS` from Step 2
+- The `PROJECT_CONTEXT`
+- **The Task Grouping Rules and Card Format from `/mastermind:createtask` Step 5** — include them verbatim in the agent prompt so it produces correctly structured tasks
+
+The agent MUST produce a `TASKS` array following the `/mastermind:createtask` task card format (Step 5). Each task must comply with all 7 grouping rules. For each approved improvement, decompose into 2-6 subtasks.
+
+**If the architect has doubts** about decomposing an improvement (unclear scope, missing info):
+- Add a comment with the question
+- Move the improvement to `Deferred` instead of `Tasked`
+
+Store the result as `TASKS` array.
+
+### Persist Task Decomposition
+
+**File mode:** Follow `/mastermind:createtask` Steps 6–7 (file mode) to write a new task file. Use:
+- `SOURCE_TAG` = `"mastermind:improve"`
+- `SOURCE_SUMMARY` = first 100 chars of `$ARGUMENTS`
+
+After writing the task file, update `IMPROVE_FILE`:
+- For each parent improvement: change `> status: approved` → `> status: tasked`, append `**Subtasks file:** <TASK_FILE> (N tasks created)`
+
+**Monotask mode:** Follow `/mastermind:createtask` Steps 6–7 (monotask mode) with:
+- `SOURCE_TAG` = `"mastermind:improve"`
+- After cards created: annotate parent card and move it to `Tasked`
+
+Then follow `/mastermind:createtask` Step 8 (Final Dependency Review) and report results.
+
+---
+
+## Step 8: Final Summary
+
+Output a component health report:
+
+```
+## Improvement Analysis: <component>
+
+### Component Health
+- Files analyzed: N
+- Pain points found: N (X critical, Y high, Z medium)
+- Strengths identified: N
+
+### Improvement Pipeline
+| # | Improvement                 | Category       | Status   | Impact | Effort | Subtasks |
+|---|-----------------------------|----------------|----------|--------|--------|----------|
+| 1 | <title>                     | performance    | Tasked   | 8      | 4      | 3        |
+| 2 | <title>                     | security       | Deferred | 7      | 8      | --       |
+| 3 | <title>                     | testing        | Rejected | --     | --     | --       |
+
+### Summary
+- Improvements discovered: N
+- Improvements tasked: N (with M total subtasks)
+- Total effort points: X
+- Improvements deferred: N
+- Improvements rejected: N
+```
+
+Output file/board references:
+- *File mode:* Improvement file: `<IMPROVE_FILE>` | Task file: `<TASK_FILE>`
+- *Monotask mode:* Space: `$REPO_NAME` | Improve board: `monomind-improve` | Task board: `monomind-task`
+
+---
+
+## Step 9: Offer to Execute Tasks
+
+If there are todo tasks:
+
+*File mode:*
+```
+Skill("mastermind:do", "--file <TASK_FILE> --mode <parallel|minimal|sequential>")
+```
+
+*Monotask mode:*
+```
+Skill("mastermind:do", "--monotask --space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
+```
+
+To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/loops.md

@@ -0,0 +1,7 @@
+---
+description: List active loops — command, type, run count, HIL status
+---
+
+```bash
+node "$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs" loops-status
+```