@monoes/monomindcli 1.6.8 → 1.7.0

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

@@ -1,6 +1,6 @@
 ---
 name: monomind-createtask
-description: "Monomind — Ingest a prompt, file, or folder, deeply understand it, generate a full implementation plan, and create self-contained tasks on monotask that coder agents can pick up"
+description: "Monomind — Ingest a prompt, file, or folder, deeply understand it, generate agent-optimized tasks on monotask with smart grouping, prerequisites, and session memory"
 ---
 
 If `$ARGUMENTS` is empty, output this and STOP:
@@ -12,7 +12,7 @@ If `$ARGUMENTS` is empty, output this and STOP:
 > - `/monomind:createtask docs/superpowers/specs/2026-04-27-swarm-tab-redesign-design.md`
 > - `/monomind:createtask docs/superpowers/specs/`
 >
-> This command deeply analyzes your input, generates a full implementation plan, and creates self-contained tasks on monotask that simple coder agents can execute without additional context.
+> This command deeply analyzes your input, generates an implementation plan, and creates **agent-optimized** tasks on monotask — grouped so each agent gets full context, with prerequisites ensuring execution order.
 
 Do NOT proceed further if no arguments were provided.
 
@@ -125,12 +125,20 @@ The agent MUST produce a structured analysis:
       "name": "component or module name",
       "description": "what it does",
       "dependencies": ["other components it depends on"],
-      "files_likely_affected": ["paths from graphify or educated guesses"]
+      "files_likely_affected": ["paths from graphify or educated guesses"],
+      "shared_context_with": ["other component names that share state, models, or interfaces"]
     }
   ],
   "technical_constraints": ["any constraints, tech stack requirements, or limitations mentioned"],
   "acceptance_criteria": ["testable conditions for when this is done"],
-  "risks": ["potential pitfalls, ambiguities, or unknowns"]
+  "risks": ["potential pitfalls, ambiguities, or unknowns"],
+  "context_chains": [
+    {
+      "chain_name": "descriptive name for this context group",
+      "components": ["ordered list of components that share context and should be done by same agent or sequentially"],
+      "reason": "why these must share context (shared types, same file, state dependency, etc.)"
+    }
+  ]
 }
 ```
 
@@ -138,99 +146,49 @@ Store as `ANALYSIS`.
 
 ---
 
-## Step 4: Generate Implementation Plan
+## Step 4: Generate Agent-Optimized Implementation Plan
 
 Spawn a `planner` agent via the Agent tool. Provide it with:
 
-- The `ANALYSIS` from Step 3
+- The `ANALYSIS` from Step 3 (including `context_chains`)
 - The `FULL_CONTEXT`
 - The `REPO_NAME` and project info
+- **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 an ordered list of implementation tasks. Each task must be **completely self-contained** — a coder agent with NO prior context should be able to execute it by reading only the task card.
+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 task, produce:
+Store as `TASKS` array.
 
-```json
-{
-  "title": "Short action-oriented title (e.g. 'Add webhook retry logic with exponential backoff')",
-  "description": "Detailed description: WHAT to build, WHY it's needed, WHERE it fits in the system",
-  "context": "All relevant context a coder needs: existing patterns to follow, related files, API shapes, data models, config values. Include specific file paths from graphify results when available.",
-  "acceptance_criteria": ["list of testable conditions that prove this task is done"],
-  "checklist": ["step-by-step implementation steps the coder should follow"],
-  "agent_type": "recommended agent type (e.g. coder, backend-dev, Frontend Developer, Security Engineer)",
-  "priority": "critical | high | medium | low",
-  "effort": 1-10,
-  "dependencies": ["titles of other tasks that must complete first, or empty array"]
-}
-```
+---
 
-**Rules for task generation:**
-- Tasks MUST be ordered so dependencies come first.
-- Each task should take a single agent 5-30 minutes to complete.
-- Tasks that are too large MUST be split.
-- Every task MUST include enough context that the coder doesn't need to read the original document.
-- Include a test-writing step in every task's checklist.
-- Assign agent types from available agents (coder, backend-dev, Frontend Developer, Security Engineer, etc.) based on the task domain.
+## Step 5: Create Tasks, Store Memory, and Review
 
-Store as `TASKS` array.
+Invoke the `monomind-task-engine` skill (Sections 3-7) with these parameters:
 
----
+| Parameter | Value |
+|-----------|-------|
+| `TASKS` | The array from Step 4 |
+| `TASK_BOARD_ID` | From Step 2 (or let the engine set up the board) |
+| `REPO_NAME` | From Step 1c |
+| `SOURCE_TAG` | `"monomind-createtask"` |
+| `SOURCE_SUMMARY` | First 100 chars of `$ARGUMENTS` |
+| `PARENT_CARD_ID` | _(none — createtask has no parent card)_ |
 
-## Step 5: Create Tasks on Monotask Board
-
-For each task in the `TASKS` array, in dependency order:
-
-1. **Create the card** in the `Todo` column (dependency-free tasks) or `Backlog` column (has unfinished dependencies):
-   ```bash
-   monotask card create $TASK_BOARD_ID $COL_TODO "<title>" --json
-   ```
-   Store the returned `CARD_ID`.
-
-2. **Set description** with the full context block:
-   ```bash
-   monotask card set-description $TASK_BOARD_ID $CARD_ID "<description>\n\n## Context\n<context>"
-   ```
-
-3. **Add agent assignment comment**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "Assigned agent: <agent_type>"
-   ```
-
-4. **Add acceptance criteria comment**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "Acceptance criteria:\n- <criterion 1>\n- <criterion 2>\n..."
-   ```
-
-5. **Add dependency comment** (if any):
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "Dependencies: <task title 1>, <task title 2>"
-   ```
-
-6. **Set priority**:
-   ```bash
-   monotask card set-priority $TASK_BOARD_ID $CARD_ID <1-4>
-   ```
-   Map: critical=1, high=2, medium=3, low=4.
-
-7. **Create checklist** with implementation steps:
-   ```bash
-   monotask checklist add $TASK_BOARD_ID $CARD_ID "Implementation Steps" --json
-   ```
-   Store `CHECKLIST_ID`, then for each step:
-   ```bash
-   monotask checklist item-add $TASK_BOARD_ID $CARD_ID $CHECKLIST_ID "<step>"
-   ```
-
-Batch card creation commands where possible to reduce round-trips.
+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 6: Exploration Session — Suggest Missing Pieces
+## Step 7: Exploration Session — Suggest Missing Pieces
 
 After all tasks are created, spawn a **second** `Software Architect` agent (fresh context) via the Agent tool. Provide it with:
 
 - The `ANALYSIS` from Step 3
-- The complete list of `TASKS` already created (titles + descriptions)
+- The complete list of `TASKS` already created (titles + descriptions + context groups)
 - The `FULL_CONTEXT`
 
 The agent must act as a **critical reviewer** and identify:
@@ -241,7 +199,8 @@ The agent must act as a **critical reviewer** and identify:
     {
       "title": "What's missing",
       "description": "Why this matters and what should be done",
-      "category": "testing | documentation | error-handling | monitoring | security | performance | accessibility | deployment | migration"
+      "category": "testing | documentation | error-handling | monitoring | security | performance | accessibility | deployment | migration",
+      "context_group": "which existing context group this belongs to, or 'new'"
     }
   ],
   "upcoming_plans": [
@@ -254,17 +213,6 @@ The agent must act as a **critical reviewer** and identify:
 }
 ```
 
-**Areas to explore:**
-- Missing test coverage (unit, integration, e2e)
-- Error handling and edge cases not covered
-- Documentation that should be created or updated
-- Security considerations (input validation, auth, rate limiting)
-- Performance implications (caching, indexing, pagination)
-- Monitoring and observability (logging, metrics, alerts)
-- Migration or backwards compatibility concerns
-- Deployment steps or configuration changes needed
-- Accessibility requirements (for UI tasks)
-
 ### Present to User
 
 Output the suggestions in a clear format:
@@ -272,10 +220,10 @@ Output the suggestions in a clear format:
 ```
 ## Missing Pieces
 
-| # | Category     | Title                              | Description                |
-|---|-------------|------------------------------------|----------------------------|
-| 1 | testing     | Add integration tests for webhook  | Currently only unit tests  |
-| 2 | security    | Rate-limit webhook endpoints       | Prevent abuse              |
+| # | Category     | Title                              | Context Group | Description                |
+|---|-------------|------------------------------------|---------------|----------------------------|
+| 1 | testing     | Add integration tests for webhook  | webhook-chain | Currently only unit tests  |
+| 2 | security    | Rate-limit webhook endpoints       | independent   | Prevent abuse              |
 
 ## Potential Follow-ups
 
@@ -289,19 +237,19 @@ Then ask:
 > **Found N missing pieces and M potential follow-ups.**
 >
 > Reply with the numbers you want to add as tasks (e.g., `1, 3, 5` or `all` or `none`).
-> Missing pieces will be added to **Todo**. Follow-ups will be added to **Backlog**.
+> Missing pieces will be added to their context group. Follow-ups go to **Backlog**.
 
 ### Process User Selection
 
 If the user selects items:
-1. For each selected **missing piece**: Create a task card in `Todo` with full context (same Step 5 process). Add a comment: `"Source: exploration — missing piece"`.
-2. For each selected **follow-up**: Create a task card in `Backlog` with full context. Add a comment: `"Source: exploration — follow-up suggestion"`.
+1. For each selected **missing piece**: Create a task card following the same grouping rules (Step 4). If it belongs to an existing context group, add prerequisite links. Add comment: `"Source: exploration — missing piece"`.
+2. For each selected **follow-up**: Create a task card in `Backlog`. Add comment: `"Source: exploration — follow-up suggestion"`.
 
 If the user says `none` or declines, skip.
 
 ---
 
-## Step 7: Final Summary
+## Step 8: Final Summary
 
 Output:
 
@@ -311,30 +259,44 @@ Output:
 **Source:** <prompt text | file path | folder path>
 **Space:** $REPO_NAME (ID: $SPACE_ID)
 **Board:** monomind-task (ID: $TASK_BOARD_ID)
+**Execution strategy:** <parallel | minimal | sequential>
+
+### Context Groups
 
-### Tasks Created
+| Group              | Tasks | Agent           | Mode       |
+|--------------------|-------|-----------------|------------|
+| <group name>       | 3     | backend-dev     | sequential |
+| <group name>       | 2     | Frontend Developer | sequential |
+| independent        | 4     | mixed           | parallel   |
 
-| # | Title                                   | Agent        | Priority | Column  |
-|---|----------------------------------------|-------------|----------|---------|
-| 1 | <title>                                | backend-dev | high     | Todo    |
-| 2 | <title>                                | coder       | medium   | Todo    |
-| 3 | <title>                                | Frontend Developer | medium | Backlog |
+### All Tasks
 
-**Total:** N tasks in Todo, M tasks in Backlog
-**Estimated effort:** X points
+| # | Title                                   | Agent        | Priority | Group        | Prerequisites |
+|---|----------------------------------------|-------------|----------|--------------|---------------|
+| 1 | <title>                                | backend-dev | high     | api-chain    | —             |
+| 2 | <title>                                | backend-dev | high     | api-chain    | Task 1        |
+| 3 | <title>                                | coder       | medium   | independent  | —             |
+
+**Total:** N tasks (X in Todo, Y in Backlog)
+**Estimated effort:** Z points
+**Recommended mode:** <parallel | minimal | sequential> — <one-line reason>
 ```
 
 ---
 
-## Step 8: Offer to Execute
+## Step 9: Offer to Execute
 
 If there are tasks in Todo, ask:
 
-> **N tasks are ready for execution.** Want me to start `/monomind:do` to process them?
+> **N tasks are ready for execution.** How do you want to run them?
+>
+> 1. **Parallel** — Spawn one agent per context group + independent tasks run simultaneously. Fastest, best for independent work. (~N agents)
+> 2. **Minimal** — 2-3 agents: one per major context group, one for independents. Balanced cost/speed.
+> 3. **Sequential** — One agent processes tasks in order. Slowest but cheapest, best for heavy shared state.
 >
-> It will pick up tasks one by one, execute them with the assigned agent, review for bugs, and loop until the queue is empty.
+> Recommended: **<mode>** — <reason>
 
-If the user agrees, invoke:
+If the user agrees or picks a mode, invoke:
 ```
-Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID")
+Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
 ```