@monoes/monomindcli 1.6.8 → 1.7.0

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

@@ -87,10 +87,18 @@ Spawn 3-5 `researcher` agents in parallel using the Agent tool (mesh topology).
 - 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:
+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." }
+  {
+    "title": "Short idea title",
+    "description": "2-3 sentence description of the idea, what it solves, and why it matters.",
+    "category": "feature | technical-baseline"
+  }
 ]
 ```
 
@@ -101,6 +109,8 @@ After all agents complete:
    ```bash
    monotask card create $BOARD_ID $COL_NEW "<title>" --json
    monotask card comment add $BOARD_ID $CARD_ID "<description>"
+   monotask card tag add $BOARD_ID $CARD_ID "monomind-idea"
+   monotask card tag add $BOARD_ID $CARD_ID "<category>"
    ```
 
 If zero ideas were generated after deduplication, report "No ideas generated by the research swarm." and STOP.
@@ -189,112 +199,44 @@ Also move any `skipElaboration: true` ideas directly to `Elaborated`.
 
 ---
 
-## Step 6: Task Decomposer -- Break Ideas into Subtasks
-
-### Task Board Setup
-- Check if a `monomind-task` board exists in the space (same lookup method as Step 2).
-- If not, create it with these columns:
-  - `Backlog`
-  - `Todo`
-  - `In Progress`
-  - `Review`
-  - `Human in Loop`
-  - `Done`
-- Store column IDs (especially `COL_BACKLOG`).
+## Step 6: Task Decomposer — Break Ideas into Subtasks
 
-### Decomposition into Professional Task Cards
+### 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-task-engine` skill (Sections 1 & 2)** — include them verbatim in the agent prompt so it produces correctly structured tasks
 
-For each elaborated idea, the agent must:
-
-1. **Analyze and decompose** into 2-6 subtasks. Each subtask must be a professional task card following this structure:
-
-```json
-{
-  "title": "Action-oriented title (verb + noun + context)",
-  "description": "## What\nExact deliverable (new file, modified function, endpoint, etc.).\n\n## Why\nBusiness or technical motivation — what breaks without this?\n\n## Where\nFile paths, module boundaries, related components.\n\n## Patterns\nExisting conventions to follow (naming, error handling, test style).",
-  "definition_of_done": [
-    "Specific, binary, verifiable condition (include HTTP codes, error shapes, edge cases)",
-    "Quantified thresholds where applicable (rate limits, timeouts, sizes)"
-  ],
-  "testing_criteria": {
-    "unit_tests": ["function(input) → expected outcome"],
-    "integration_tests": ["endpoint + method → status + response shape"],
-    "edge_cases": ["boundary condition → expected behavior"]
-  },
-  "checklist": [
-    "Write failing test for [specific behavior]",
-    "Implement [function/class] in [file path]",
-    "Run tests — verify green",
-    "Commit: '[type]: [description]'"
-  ],
-  "agent_type": "best-fit agent from 230+ roster (e.g., backend-dev, Frontend Developer, Security Engineer)",
-  "priority": "critical | high | medium | low",
-  "effort": "1-10 (1=trivial, 10=full day)",
-  "dependencies": ["titles of prerequisite tasks, or empty"]
-}
-```
-
-**Task generation rules:**
-- Tasks MUST be ordered so dependencies come first
-- Each task: 5-30 minutes for a single agent
-- Split anything larger
-- Every task starts with writing a test (TDD)
-- DOD items must be binary (pass/fail, not "looks good")
-- Testing criteria must name specific functions, endpoints, inputs
-
-2. **Create each subtask** as a card in `Backlog` (has deps) or `Todo` (no deps):
-   ```bash
-   monotask card create $TASK_BOARD_ID $COLUMN_ID "<title>" --json
-   ```
-
-3. **Set description** with full context block:
-   ```bash
-   monotask card set-description $TASK_BOARD_ID $CARD_ID "<description with What/Why/Where/Patterns>"
-   ```
-
-4. **Add DOD comment**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "## Definition of Done\n- [ ] <condition 1>\n- [ ] <condition 2>\n..."
-   ```
-
-5. **Add testing criteria comment**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "## Testing Criteria\n\n### Unit Tests\n- <test 1>\n\n### Integration Tests\n- <test 1>\n\n### Edge Cases\n- <case 1>"
-   ```
+The agent MUST produce a `TASKS` array following the `monomind-task-engine` card format (Section 2). Each task must comply with all 7 grouping rules (Section 1). For each elaborated idea, decompose into 2-6 subtasks.
 
-6. **Add agent assignment + metadata**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "Assigned agent: <agent_type>\nPriority: <priority>\nEffort: <effort>/10\nDependencies: <dep titles or none>"
-   ```
+**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`
 
-7. **Set priority**: `monotask card set-priority $TASK_BOARD_ID $CARD_ID <1-4>`
+Store the result as `TASKS` array.
 
-8. **Create checklist** (TDD implementation steps):
-   ```bash
-   monotask checklist add $TASK_BOARD_ID $CARD_ID "Implementation Steps" --json
-   ```
-   Then for each step:
-   ```bash
-   monotask checklist item-add $TASK_BOARD_ID $CARD_ID $CHECKLIST_ID "<step>"
-   ```
+### Invoke the Unified Task Engine
 
-9. **Comment on original idea card** listing all subtask titles with their assigned agents:
-   ```bash
-   monotask card comment add $BOARD_ID $IDEA_CARD_ID "Subtasks created:\n- <title> (agent: <type>, effort: <N>/10)\n- <title> (agent: <type>, effort: <N>/10)\n..."
-   ```
+Invoke the `monomind-task-engine` skill (Sections 3-7) with these parameters:
 
-10. **Move the idea card** to `Tasked`:
-    ```bash
-    monotask card move $BOARD_ID $IDEA_CARD_ID $COL_TASKED --json
-    ```
+| Parameter | Value |
+|-----------|-------|
+| `TASKS` | The array from the architect agent |
+| `TASK_BOARD_ID` | From Step 2 (or let the engine set up the board) |
+| `REPO_NAME` | From Step 1 |
+| `SOURCE_TAG` | `"monomind-idea"` |
+| `SOURCE_SUMMARY` | First 100 chars of `$ARGUMENTS` |
+| `PARENT_CARD_ID` | Each `IDEA_CARD_ID` in the Elaborated column |
+| `PARENT_BOARD_ID` | `$BOARD_ID` (the monomind-idea board) |
+| `PARENT_DONE_COLUMN` | `$COL_TASKED` |
 
-**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`
+The engine will:
+1. Create all cards on the monotask board (Section 4)
+2. Store execution strategy in session memory (Section 5)
+3. Run the **Final Dependency & Critical Path Review** (Section 6) — a fresh Code Reviewer agent validates prerequisites, context groups, critical path, parallel safety, and agent assignments
+4. Fix any blocker issues automatically, present warnings to user
+5. Present execution offer with mode recommendation (Section 7)
 
 ---
 
@@ -303,11 +245,11 @@ For each elaborated idea, the agent must:
 Output a summary table:
 
 ```
-| # | Idea                        | Status   | Subtasks | Total Effort | Agents |
-|---|-----------------------------|----------|----------|--------------|--------|
-| 1 | <title>                     | Tasked   | 4        | 18/40        | coder, backend-dev, tester |
-| 2 | <title>                     | Iced     | --       | --           | --     |
-| 3 | <title>                     | Rejected | --       | --           | --     |
+| # | 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:
@@ -324,15 +266,10 @@ Then output:
 
 ## Step 8: Offer to Execute Tasks
 
-If there are any tasked ideas (subtasks in Backlog), ask the user:
+The `monomind-task-engine` (Section 7) already presents the execution offer after the final review passes. If the user picks a mode there, it invokes `monomind-do` automatically.
 
-> **M subtasks are ready in the backlog.** Want me to start executing them now?
->
-> Say **yes** to launch `/monomind:do` — it will pick up tasks one by one, execute them with the assigned agent, review for bugs, and loop every 2 minutes until the queue is empty.
+If the engine's execution offer was skipped or the user deferred, and there are tasks in Todo, offer:
 
-If the user says yes (or any affirmative), invoke the Skill tool with:
 ```
-Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID")
+Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
 ```
-
-This passes the exact space and board IDs so `monomind:do` skips discovery and starts executing immediately.

package/.claude/commands/monomind-improve.md

@@ -0,0 +1,352 @@
+---
+name: monomind-improve
+description: "Monomind — Deeply analyze a project component, research improvements online, and create improvement tasks on monotask boards"
+---
+
+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__graphify_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: 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__graphify_query` for each key term found.
+2. **Map dependencies** — what does the component depend on? What depends on it? Use `mcp__monomind__graphify_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
+- List boards via `monotask board list --json`. For each board ID, run `monotask column list <BOARD_ID> --json` to find one whose title is `monomind-improve`. (There is no "board view" command -- column list reveals the board structure.)
+- 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. 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 tag 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-task-engine` skill (Sections 1 & 2)** — include them verbatim in the agent prompt so it produces correctly structured tasks
+
+The agent MUST produce a `TASKS` array following the `monomind-task-engine` card format (Section 2). Each task must comply with all 7 grouping rules (Section 1). 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.
+
+### Invoke the Unified Task Engine
+
+Invoke the `monomind-task-engine` skill (Sections 3-7) with these parameters:
+
+| Parameter | Value |
+|-----------|-------|
+| `TASKS` | The array from the architect agent |
+| `TASK_BOARD_ID` | From Step 3 (or let the engine set up the board) |
+| `REPO_NAME` | From Step 1 |
+| `SOURCE_TAG` | `"monomind-improve"` |
+| `SOURCE_SUMMARY` | First 100 chars of `$ARGUMENTS` |
+| `PARENT_CARD_ID` | Each `IMPROVE_CARD_ID` in the Approved column |
+| `PARENT_BOARD_ID` | `$BOARD_ID` (the monomind-improve board) |
+| `PARENT_DONE_COLUMN` | `$COL_TASKED` |
+
+The engine will:
+1. Create all cards on the monotask board (Section 4)
+2. Store execution strategy in session memory (Section 5)
+3. Run the **Final Dependency & Critical Path Review** (Section 6) — a fresh Code Reviewer agent validates prerequisites, context groups, critical path, parallel safety, and agent assignments
+4. Fix any blocker issues automatically, present warnings to user
+5. Present execution offer with mode recommendation (Section 7)
+
+---
+
+## 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
+
+The `monomind-task-engine` (Section 7) already presents the execution offer after the final review passes. If the user picks a mode there, it invokes `monomind-do` automatically.
+
+If the engine's execution offer was skipped or the user deferred, and there are tasks in Todo, offer:
+
+```
+Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
+```