@monoes/monomindcli 1.10.57 → 1.11.0

package/.claude/commands/monomind/idea.md

@@ -1,273 +0,0 @@
----
-name: monomind:idea
-description: "Monomind — Research ideas from a prompt, evaluate them, and decompose into subtasks on monotask boards"
----
-
-**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:** `/monomind:idea <prompt>`
->
-> Example: `/monomind:idea add real-time collaboration to the editor`
->
-> This command researches ideas from your prompt, evaluates them with a product manager lens, elaborates promising ones, and decomposes them into actionable subtasks on monotask boards.
-
-Do NOT proceed further if no arguments were provided.
-
----
-
-## Step 0: Check monotask CLI
-
-Run:
-```bash
-command -v monotask
-```
-
-If `monotask` is NOT found, attempt to install:
-```bash
-command -v cargo && cargo install monotask
-```
-
-If `cargo` is also missing, output this and STOP:
-> monotask requires Rust. Install Rust first:
-> ```bash
-> curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-> source "$HOME/.cargo/env"
-> cargo install monotask
-> ```
-
-Verify monotask is now available before continuing.
-
----
-
-## 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 Monotask Space and Idea Board
-
-### Space
-- Run `monotask space list` and check if a space named `$REPO_NAME` already exists.
-- If not, create it: `monotask space create "$REPO_NAME"`.
-- Store the `SPACE_ID`.
-
-### Idea Board
-- First check memory: `npx monomind@latest memory search "monomind-idea board_id"`. If a board ID is returned, use it as `BOARD_ID` and skip the board search below.
-- Otherwise, list boards in the space via `monotask space boards list $SPACE_ID` (one board ID per line). For each ID, check `monotask column list <BOARD_ID> --json` — if the result contains a column named `New`, treat it as the `monomind-idea` board candidate and use its ID as `BOARD_ID`.
-- If the `monomind-idea` board does not exist:
-  1. Create it: `monotask board create "monomind-idea" --json` -- store the returned `BOARD_ID`.
-  2. Add it to the space: `monotask space boards add $SPACE_ID $BOARD_ID`.
-  3. Persist the ID: `npx monomind@latest memory store --key "monomind-idea board_id" --value "$BOARD_ID" --namespace monomind`.
-  3. Create these columns in order:
-     - `New`
-     - `Evaluated`
-     - `Elaborated`
-     - `Tasked`
-     - `Iced`
-     - `Rejected`
-- Store all column IDs mapped by name (e.g., `COL_NEW`, `COL_EVALUATED`, `COL_ELABORATED`, `COL_TASKED`, `COL_ICED`, `COL_REJECTED`).
-
----
-
-## 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. For each unique idea, create a card in the `New` column:
-   ```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 monotask board:
-
-- **evaluated**: Move card to `Evaluated`. Set impact and effort. Add comment with the value statement.
-  ```bash
-  monotask card move $BOARD_ID $CARD_ID $COL_EVALUATED --json
-  monotask card set-impact $BOARD_ID $CARD_ID <0-10>
-  monotask card set-effort $BOARD_ID $CARD_ID <0-10>
-  monotask card comment add $BOARD_ID $CARD_ID "Value: <value statement>"
-  ```
-- **iced**: Move card to `Iced`. Set impact and effort estimates. Add comment with the blocking question.
-  ```bash
-  monotask card move $BOARD_ID $CARD_ID $COL_ICED --json
-  monotask card set-impact $BOARD_ID $CARD_ID <0-10>
-  monotask card set-effort $BOARD_ID $CARD_ID <0-10>
-  monotask card comment add $BOARD_ID $CARD_ID "Blocked: <question>"
-  ```
-- **rejected**: Move card to `Rejected`. Add comment with the reason.
-  ```bash
-  monotask card move $BOARD_ID $CARD_ID $COL_REJECTED --json
-  monotask card comment add $BOARD_ID $CARD_ID "Rejected: <reason>"
-  ```
-
-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`:**
-- Move each directly from `Evaluated` to `Elaborated`:
-  ```bash
-  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 potential technical pitfalls.
-2. Add findings as comments on the card:
-   ```bash
-   monotask card comment add $BOARD_ID $CARD_ID "Edge cases: <findings>"
-   monotask card comment add $BOARD_ID $CARD_ID "Technical notes: <notes>"
-   ```
-3. If no blocking issues found, move to `Elaborated`:
-   ```bash
-   monotask card move $BOARD_ID $CARD_ID $COL_ELABORATED --json
-   ```
-4. If a blocking issue IS found, move to `Iced` with a comment explaining the issue:
-   ```bash
-   monotask card move $BOARD_ID $CARD_ID $COL_ICED --json
-   monotask card comment add $BOARD_ID $CARD_ID "Blocked during elaboration: <issue>"
-   ```
-
-Also move any `skipElaboration: true` ideas directly to `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 `/monomind: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 `/monomind: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.
-
-### Create Cards on Monotask
-
-Follow the same card creation process as `/monomind:createtask` Steps 6–7, with these values:
-- `SOURCE_TAG` = `"monomind:idea"`
-- `SOURCE_SUMMARY` = first 100 chars of `$ARGUMENTS`
-
-After all cards are created for each idea, annotate its idea card and move it to `Tasked`:
-```bash
-monotask card comment add $BOARD_ID $IDEA_CARD_ID "Subtasks created:\n- <title> (agent: <type>, effort: <N>/10)\n..."
-monotask card move $BOARD_ID $IDEA_CARD_ID $COL_TASKED --json
-```
-
-Then follow `/monomind:createtask` Steps 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
-- Monotask space: `$REPO_NAME` (ID: `$SPACE_ID`)
-- Idea board: `monomind-idea` (ID: `$BOARD_ID`)
-- Task board: `monomind-task` (ID: `$TASK_BOARD_ID`)
-
----
-
-## Step 8: Offer to Execute Tasks
-
-If there are tasks in Todo, offer:
-
-```
-Skill("monomind:do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
-```
-
-To repeat this command on a schedule, wrap it with `/monomind: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/monomind/improve.md

@@ -1,352 +0,0 @@
----
-name: monomind:improve
-description: "Monomind — Deeply analyze a project component, research improvements online, and create improvement tasks on monotask boards"
----
-
-**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:** `/monomind:improve <component or concept>`
->
-> Examples:
-> - `/monomind:improve the authentication flow`
-> - `/monomind:improve error handling across the codebase`
-> - `/monomind:improve CLI startup performance`
-> - `/monomind:improve the MCP server architecture`
->
-> This command deeply analyzes the target component inside your project, researches improvement directions online, evaluates them, and decomposes the best ones into professional tasks on monotask boards. All cards are tagged `monomind-improve`.
-
-Do NOT proceed further if no arguments were provided.
-
----
-
-## Step 0: Check monotask CLI
-
-Run:
-```bash
-command -v monotask
-```
-
-If `monotask` is NOT found, attempt to install:
-```bash
-command -v cargo && cargo install monotask
-```
-
-If `cargo` is also missing, output this and STOP:
-> monotask requires Rust. Install Rust first:
-> ```bash
-> curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-> source "$HOME/.cargo/env"
-> cargo install monotask
-> ```
-
-Verify monotask is now available before continuing.
-
----
-
-## 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 `/monomind:improve` from `/monomind:idea`. 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 Monotask Space and Improve Board
-
-### Space
-- Run `monotask space list` and check if a space named `$REPO_NAME` already exists.
-- If not, create it: `monotask space create "$REPO_NAME"`.
-- Store the `SPACE_ID`.
-
-### Improve Board
-- First check memory: `npx monomind@latest memory search "monomind-improve board_id"`. If a board ID is returned, use it as `BOARD_ID` and skip the search below.
-- Otherwise, list boards in the space via `monotask space boards list $SPACE_ID` (one board ID per line) and check each via `monotask column list <ID> --json` for a `Discovered` column — if found, that is the `monomind-improve` board.
-- If the `monomind-improve` board does not exist:
-  1. Create it: `monotask board create "monomind-improve" --json` — store the returned `BOARD_ID`.
-  2. Add it to the space: `monotask space boards add $SPACE_ID $BOARD_ID`.
-  3. Persist the ID: `npx monomind@latest memory store --key "monomind-improve board_id" --value "$BOARD_ID" --namespace monomind`.
-  3. Create these columns in order:
-     - `Discovered`
-     - `Evaluated`
-     - `Approved`
-     - `Tasked`
-     - `Deferred`
-     - `Rejected`
-- Store all column IDs mapped by name.
-
----
-
-## 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
-
-For each idea, create a card in the `Discovered` column:
-```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 ideas 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 the monotask board:
-
-- **approved**: Move to `Evaluated`. Set impact and effort. Add value statement.
-  ```bash
-  monotask card move $BOARD_ID $CARD_ID $COL_EVALUATED --json
-  monotask card set-impact $BOARD_ID $CARD_ID <0-10>
-  monotask card set-effort $BOARD_ID $CARD_ID <0-10>
-  monotask card comment add $BOARD_ID $CARD_ID "Value: <value statement>"
-  ```
-- **deferred**: Move to `Deferred`. Set impact and effort. Add reason.
-  ```bash
-  monotask card move $BOARD_ID $CARD_ID $COL_DEFERRED --json
-  monotask card set-impact $BOARD_ID $CARD_ID <0-10>
-  monotask card set-effort $BOARD_ID $CARD_ID <0-10>
-  monotask card comment add $BOARD_ID $CARD_ID "Deferred: <reason>"
-  ```
-- **rejected**: Move to `Rejected`. Add reason.
-  ```bash
-  monotask card move $BOARD_ID $CARD_ID $COL_REJECTED --json
-  monotask card comment add $BOARD_ID $CARD_ID "Rejected: <reason>"
-  ```
-
-If ALL ideas 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 ideas have `skipElaboration: true`:**
-- Move each directly from `Evaluated` to `Approved`:
-  ```bash
-  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 idea needing elaboration:
-1. Add findings as comments:
-   ```bash
-   monotask card comment add $BOARD_ID $CARD_ID "Implementation path: <files and functions to change>"
-   monotask card comment add $BOARD_ID $CARD_ID "Risks: <breaking changes, migration needs>"
-   monotask card comment add $BOARD_ID $CARD_ID "Research: <patterns and references found>"
-   ```
-2. If no blocking issues, move to `Approved`:
-   ```bash
-   monotask card move $BOARD_ID $CARD_ID $COL_APPROVED --json
-   ```
-3. If a blocking issue IS found, move to `Deferred`:
-   ```bash
-   monotask card move $BOARD_ID $CARD_ID $COL_DEFERRED --json
-   monotask card comment add $BOARD_ID $CARD_ID "Blocked: <issue>"
-   ```
-
-Also move any `skipElaboration: true` ideas directly to `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 `/monomind: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 `/monomind: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.
-
-### Create Cards on Monotask
-
-Follow the same card creation process as `/monomind:createtask` Steps 6–7, with these values:
-- `SOURCE_TAG` = `"monomind:improve"`
-- `SOURCE_SUMMARY` = first 100 chars of `$ARGUMENTS`
-
-After all cards are created for each improvement, annotate its improvement card and move it to `Tasked`:
-```bash
-monotask card comment add $BOARD_ID $IMPROVE_CARD_ID "Subtasks created:\n- <title> (agent: <type>, effort: <N>/10)\n..."
-monotask card move $BOARD_ID $IMPROVE_CARD_ID $COL_TASKED --json
-```
-
-Then follow `/monomind:createtask` Steps 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 board references:
-- Monotask space: `$REPO_NAME` (ID: `$SPACE_ID`)
-- Improve board: `monomind-improve` (ID: `$BOARD_ID`)
-- Task board: `monomind-task` (ID: `$TASK_BOARD_ID`)
-
----
-
-## Step 9: Offer to Execute Tasks
-
-If there are tasks in Todo, offer:
-
-```
-Skill("monomind:do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
-```
-
-To repeat this command on a schedule, wrap it with `/monomind: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/monomind/loops.md

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