monomind 1.6.7 → 1.6.9

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.
@@ -202,28 +212,97 @@ Also move any `skipElaboration: true` ideas directly to `Elaborated`.
   - `Done`
 - Store column IDs (especially `COL_BACKLOG`).
 
-### Decomposition
+### Decomposition into Professional Task Cards
+
 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`
 
 For each elaborated idea, the agent must:
-1. Break it into 2-6 actionable subtasks. Each subtask should have a clear title, a 1-2 sentence description of what to implement, and the recommended **agent type** to assign for implementation (e.g., `backend-dev`, `Frontend Developer`, `coder`, `Security Engineer`). Pick the agent type from the available agents list that best matches the subtask's domain.
-2. Create each subtask as a card in the `Backlog` column of the `monomind-task` board, including the agent type:
+
+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 $COL_BACKLOG "<subtask title>" --json
-   monotask card comment add $TASK_BOARD_ID $SUBTASK_CARD_ID "<subtask description>"
-   monotask card comment add $TASK_BOARD_ID $SUBTASK_CARD_ID "Assigned agent: <agent type>"
+   monotask card create $TASK_BOARD_ID $COLUMN_ID "<title>" --json
+   monotask card tag add $TASK_BOARD_ID $CARD_ID "monomind-idea"
    ```
-3. Comment on the original idea card listing all subtask titles with their assigned agents:
+
+3. **Set description** with full context block:
    ```bash
-   monotask card comment add $BOARD_ID $IDEA_CARD_ID "Subtasks created: <title> (agent: <type>), <title> (agent: <type>), ..."
+   monotask card set-description $TASK_BOARD_ID $CARD_ID "<description with What/Why/Where/Patterns>"
    ```
-4. Move the idea card to `Tasked`:
+
+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 move $BOARD_ID $IDEA_CARD_ID $COL_TASKED --json
+   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>"
    ```
 
+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>"
+   ```
+
+7. **Set priority**: `monotask card set-priority $TASK_BOARD_ID $CARD_ID <1-4>`
+
+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>"
+   ```
+
+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..."
+   ```
+
+10. **Move the idea card** to `Tasked`:
+    ```bash
+    monotask card move $BOARD_ID $IDEA_CARD_ID $COL_TASKED --json
+    ```
+
 **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`
@@ -235,16 +314,17 @@ For each elaborated idea, the agent must:
 Output a summary table:
 
 ```
-| # | Idea                        | Status   | Subtasks |
-|---|-----------------------------|----------|----------|
-| 1 | <title>                     | Tasked   | 4        |
-| 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:
 - Total ideas generated: N
-- Ideas tasked: N (with M total subtasks in Backlog)
+- Ideas tasked: N (with M total subtasks)
+- Total effort points: X
 - Ideas iced: N
 - Ideas rejected: N
 - Monotask space: `$REPO_NAME` (ID: `$SPACE_ID`)

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

@@ -0,0 +1,424 @@
+---
+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
+
+### Task Board Setup
+- Check if a `monomind-task` board exists in the space (same lookup method as Step 3).
+- If not, create it with these columns:
+  - `Backlog`
+  - `Todo`
+  - `In Progress`
+  - `Review`
+  - `Human in Loop`
+  - `Done`
+- Store column IDs.
+
+### Decomposition into Professional Task Cards
+
+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`
+
+For each approved improvement, the agent must:
+
+1. **Analyze and decompose** into 2-6 subtasks. Each subtask must be a professional task card:
+
+```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",
+  "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
+   monotask card tag add $TASK_BOARD_ID $CARD_ID "monomind-improve"
+   ```
+
+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>"
+   ```
+
+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>\nSource: monomind-improve"
+   ```
+
+7. **Set priority**: `monotask card set-priority $TASK_BOARD_ID $CARD_ID <1-4>`
+
+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>"
+   ```
+
+9. **Comment on original improvement card** listing all subtask titles:
+   ```bash
+   monotask card comment add $BOARD_ID $IMPROVE_CARD_ID "Subtasks created:\n- <title> (agent: <type>, effort: <N>/10)\n- <title> (agent: <type>, effort: <N>/10)\n..."
+   ```
+
+10. **Move the improvement card** to `Tasked`:
+    ```bash
+    monotask card move $BOARD_ID $IMPROVE_CARD_ID $COL_TASKED --json
+    ```
+
+**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`
+
+---
+
+## 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 any tasked improvements (subtasks in Backlog/Todo), ask the user:
+
+> **M subtasks are ready.** 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 until the queue is empty.
+
+If the user says yes, invoke:
+```
+Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID")
+```

package/.claude/skills/monomind-createtask/SKILL.md

@@ -0,0 +1,269 @@
+---
+name: monomind-createtask
+description: Ingest a prompt, file, or folder — deeply analyze it, generate a professional implementation plan, and create self-contained task cards on monotask with DOD, testing criteria, and checklists
+version: 1.0.0
+triggers:
+  - /monomind:createtask
+  - create tasks from spec
+  - decompose into tasks
+  - turn this into tasks
+  - break this down into tasks
+  - create implementation tasks
+---
+
+# /monomind:createtask — Spec-to-Tasks Pipeline
+
+Transforms a prompt, file, or folder into professional, self-contained task cards on a monotask board. Each card carries enough context that a coder agent with zero prior knowledge can execute it.
+
+## Task Card Quality Standard
+
+Every task card produced by this skill MUST meet this bar — no exceptions:
+
+### 1. Self-Contained Context
+The card description alone must answer: What am I building? Why? Where does it fit? What patterns exist?
+
+Include:
+- **What**: Exact deliverable (new file, modified function, new endpoint, etc.)
+- **Why**: Business or technical motivation — what breaks without this?
+- **Where**: File paths, module boundaries, related components
+- **Patterns**: Existing conventions to follow (naming, error handling, test style)
+- **Data shapes**: Relevant types, interfaces, API contracts, DB schemas
+
+### 2. Definition of Done (DOD)
+Concrete, binary conditions — not vague "it works" statements.
+
+Bad DOD:
+- "Authentication works"
+- "Tests pass"
+- "Error handling is complete"
+
+Good DOD:
+- "POST /auth/login returns 200 with JWT when credentials valid, 401 when invalid, 429 after 5 failed attempts within 15 minutes"
+- "Unit tests cover: valid login, invalid password, expired account, rate limit hit, missing fields — all green"
+- "Invalid email format returns 422 with `{ error: 'INVALID_EMAIL', field: 'email' }` shape"
+
+Rules:
+- Every DOD item must be verifiable by running code or reading output
+- Include specific HTTP codes, error shapes, edge cases
+- Quantify where possible (rate limits, timeouts, thresholds)
+
+### 3. Testing Criteria
+Explicit test cases — not "write tests."
+
+Each task must specify:
+- **Unit tests**: What functions, what inputs, what assertions
+- **Integration tests**: What endpoints, what sequences, what state transitions
+- **Edge cases**: What breaks, what's empty, what's too large, what's concurrent
+
+Format:
+```
+## Testing Criteria
+
+### Unit Tests
+- `createUser({valid})` → returns user with generated ID and hashed password
+- `createUser({duplicate_email})` → throws ConflictError with code DUPLICATE_EMAIL
+- `createUser({missing_name})` → throws ValidationError listing missing fields
+
+### Integration Tests
+- POST /users with valid body → 201, response matches UserSchema
+- POST /users with duplicate email → 409, idempotent (no side effects)
+- GET /users/:id after create → returns same user
+
+### Edge Cases
+- Empty string fields → validation rejects before DB call
+- 10,000 char name → truncated or rejected at boundary
+- Concurrent duplicate creates → exactly one succeeds
+```
+
+### 4. Implementation Checklist
+Ordered steps that a coder follows mechanically. Each step is one action (5 minutes max).
+
+Rules:
+- Start with the test (TDD: red → green → refactor)
+- Include the exact file to create or modify
+- Include the function signature or interface shape
+- End with "run tests, verify green, commit"
+
+### 5. Dependencies and Ordering
+- Explicit: "Blocked by: [Card Title]" or "No dependencies"
+- Tasks ordered so foundations come first
+- Parallel-safe tasks identified
+
+---
+
+## Pipeline Steps
+
+### Step 0: Verify monotask CLI
+```bash
+command -v monotask || (command -v cargo && cargo install monotask)
+```
+If neither exists, tell user to install Rust + monotask and STOP.
+
+### Step 1: Classify and Ingest Input
+
+Parse `$ARGUMENTS`:
+- `test -f` → file: read with Read tool
+- `test -d` → folder: `find` up to 30 files, read each, concatenate with `--- FILE: <path> ---` separators
+- Otherwise → prompt: store text directly
+
+### Step 2: Enrich with Project Context
+
+Run ALL in parallel (skip errors):
+1. `mcp__monomind__graphify_suggest` with first 200 chars of input
+2. `mcp__monomind__graphify_query` for module/component names found in input (up to 5)
+3. `mcp__monomind__memory_search` with input summary
+4. Read `README.md` (first 200 lines)
+5. Read first found: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`
+6. Repo name from `git remote get-url origin` (strip path, strip `.git`)
+
+Bundle everything into `FULL_CONTEXT`.
+
+### Step 3: Setup Monotask Space and Board
+
+**Space**: Find or create space named `$REPO_NAME`.
+
+**Board**: Find `monomind-task` board (identify by checking columns for `Todo`). If missing, create with columns:
+- `Backlog` → `Todo` → `In Progress` → `Review` → `Human in Loop` → `Done`
+
+### Step 4: Deep Analysis
+
+Spawn a `Software Architect` agent. Provide `FULL_CONTEXT` + `$ARGUMENTS`.
+
+Required output:
+```json
+{
+  "summary": "2-3 sentence overview",
+  "goals": ["high-level goals"],
+  "components": [
+    {
+      "name": "component name",
+      "description": "what it does",
+      "dependencies": ["other components"],
+      "files_likely_affected": ["paths from graphify or educated guesses"]
+    }
+  ],
+  "technical_constraints": ["stack requirements, limitations"],
+  "acceptance_criteria": ["testable conditions for when the whole thing is done"],
+  "risks": ["pitfalls, ambiguities, unknowns"]
+}
+```
+
+### Step 5: Generate Professional Tasks
+
+Spawn a `planner` agent. Provide analysis + `FULL_CONTEXT`.
+
+For each task, produce:
+
+```json
+{
+  "title": "Action-oriented title (verb + noun + context)",
+  "description": "## What\nExact deliverable.\n\n## Why\nMotivation.\n\n## Where\nFile paths, module boundaries.\n\n## Patterns\nExisting conventions to follow.",
+  "definition_of_done": [
+    "Specific, binary, verifiable condition 1",
+    "Specific, binary, verifiable condition 2"
+  ],
+  "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": "coder | backend-dev | Frontend Developer | Security Engineer | etc.",
+  "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)
+- Agent type chosen from the 230+ available roster based on domain fit
+- DOD items must be binary (pass/fail, not "looks good")
+- Testing criteria must name specific functions, endpoints, inputs
+
+### Step 6: Create Cards on Monotask
+
+For each task, in dependency order:
+
+1. **Create card** in `Todo` (no deps) or `Backlog` (has deps):
+   ```bash
+   monotask card create $BOARD_ID $COLUMN_ID "<title>" --json
+   ```
+
+2. **Set description** with full context block:
+   ```bash
+   monotask card set-description $BOARD_ID $CARD_ID "<description>"
+   ```
+
+3. **Add DOD comment**:
+   ```bash
+   monotask card comment add $BOARD_ID $CARD_ID "## Definition of Done\n- [ ] <condition 1>\n- [ ] <condition 2>\n..."
+   ```
+
+4. **Add testing criteria comment**:
+   ```bash
+   monotask card comment add $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>"
+   ```
+
+5. **Add agent assignment**:
+   ```bash
+   monotask card comment add $BOARD_ID $CARD_ID "Assigned agent: <agent_type>"
+   ```
+
+6. **Add dependencies** (if any):
+   ```bash
+   monotask card comment add $BOARD_ID $CARD_ID "Dependencies: <task title 1>, <task title 2>"
+   ```
+
+7. **Set priority**: `monotask card set-priority $BOARD_ID $CARD_ID <1-4>`
+
+8. **Create checklist**:
+   ```bash
+   monotask checklist add $BOARD_ID $CARD_ID "Implementation Steps" --json
+   ```
+   Then for each step:
+   ```bash
+   monotask checklist item-add $BOARD_ID $CARD_ID $CHECKLIST_ID "<step>"
+   ```
+
+### Step 7: Gap Analysis
+
+Spawn a fresh `Software Architect` agent as critical reviewer. Provide analysis + all created tasks.
+
+Must identify:
+- **Missing pieces**: testing gaps, error handling holes, security oversights, missing migrations, documentation needs
+- **Follow-ups**: natural extensions, performance optimizations, monitoring additions
+
+Present as tables. Ask user which to add (numbers, `all`, or `none`).
+
+Selected missing pieces → `Todo` column. Selected follow-ups → `Backlog` column.
+
+### Step 8: Summary
+
+```
+## Task Creation Complete
+
+**Source:** <input>
+**Space:** $REPO_NAME | **Board:** monomind-task
+
+| # | Title | Agent | Priority | Effort | Column | Deps |
+|---|-------|-------|----------|--------|--------|------|
+| 1 | ...   | ...   | high     | 3      | Todo   | —    |
+
+**Total:** N tasks (X in Todo, Y in Backlog)
+**Estimated effort:** Z points
+```
+
+### Step 9: Offer Execution
+
+> **N tasks ready.** Start `/monomind:do` to execute them autonomously?
+
+If yes: `Skill("monomind-do", "--space $SPACE_ID --board $BOARD_ID")`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.6.7",
+  "version": "1.6.9",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/dist/src/init/claudemd-generator.js

@@ -19,6 +19,36 @@ function behavioralRules() {
 - ALWAYS read a file before editing it
 - NEVER commit secrets, credentials, or .env files`;
 }
+function codingPrinciples() {
+    return `## Coding Principles
+
+### Think Before Coding
+- State assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them — don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+### Simplicity First
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+### Surgical Changes
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+- Every changed line should trace directly to the user's request.
+
+### Goal-Driven Execution
+- Transform tasks into verifiable goals with success criteria.
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- For multi-step tasks, state a brief plan with verification steps.`;
+}
 function fileOrganization() {
     return `## File Organization
 
@@ -376,7 +406,7 @@ npx monomind@latest daemon start
 npx monomind@latest doctor --fix
 \`\`\`
 
-> **Package name changed:** Use \`monomind@latest\` (not \`@monoes/cli@latest\` which is the old name and returns 404).
+> **Package name changed:** Use \`monomind@latest\` (not \`@monomind/cli@latest\` which is the old name and returns 404).
 
 ## Claude Code vs CLI Tools
 
@@ -396,6 +426,7 @@ npx monomind@latest doctor --fix
 const TEMPLATE_SECTIONS = {
     minimal: [
         behavioralRules,
+        (_opts) => codingPrinciples(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),
@@ -409,6 +440,7 @@ const TEMPLATE_SECTIONS = {
     ],
     standard: [
         behavioralRules,
+        (_opts) => codingPrinciples(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),
@@ -425,6 +457,7 @@ const TEMPLATE_SECTIONS = {
     ],
     full: [
         behavioralRules,
+        (_opts) => codingPrinciples(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),
@@ -446,6 +479,7 @@ const TEMPLATE_SECTIONS = {
     ],
     security: [
         behavioralRules,
+        (_opts) => codingPrinciples(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),
@@ -462,6 +496,7 @@ const TEMPLATE_SECTIONS = {
     ],
     performance: [
         behavioralRules,
+        (_opts) => codingPrinciples(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),
@@ -480,6 +515,7 @@ const TEMPLATE_SECTIONS = {
     ],
     solo: [
         behavioralRules,
+        (_opts) => codingPrinciples(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.6.7",
+  "version": "1.6.9",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",