rbin-task-flow 1.1.2 → 1.3.0

package/.cursor/rules/task_estimate.mdc

@@ -0,0 +1,92 @@
+---
+description: Task time estimation based on task complexity and developer experience level
+globs: **/*
+alwaysApply: true
+---
+
+- **Task Estimation - Time Estimation for Tasks:**
+  - **FAST FORMAT**: `task-flow: estimate X` → Estimate time for task X (simplified - no "task" needed)
+  - **MULTIPLE TASKS**: `task-flow: estimate X,Y` → Estimate multiple tasks
+  - **ALL TASKS**: `task-flow: estimate all` → Estimate all tasks
+  - When user says "task-flow: estimate X", "estimate X", "estimate X,Y", "estimate all", or "how long will task X take":
+    - **READ**: `.task-flow/.internal/tasks.json` to get task details
+    - **CALCULATE**: Time estimate based on number of subtasks and developer experience level
+    - **DISPLAY**: Show time estimate with intervals for 3 experience levels (junior, mid, senior)
+    - **FORMAT**: Show estimates in hours with ranges (e.g., "10-14 hours" for mid-level)
+
+- **Estimation Rules:**
+  1. **Base Calculation**: Count total number of subtasks in the task
+  2. **Experience Levels**:
+     - **Junior** (0-2 years): Base time × 1.5 multiplier
+     - **Mid-level** (3-5 years): Base time × 1.0 multiplier (baseline)
+     - **Senior** (6+ years): Base time × 0.7 multiplier
+  3. **Time per Subtask**:
+     - Simple subtask: 1-2 hours (mid-level baseline)
+     - Medium subtask: 2-4 hours (mid-level baseline)
+     - Complex subtask: 4-6 hours (mid-level baseline)
+  4. **Default Assumption**: Average 2-3 hours per subtask for mid-level (baseline)
+  5. **Range Calculation**: 
+     - Lower bound: (subtasks × 2) × multiplier
+     - Upper bound: (subtasks × 3) × multiplier
+     - Round to nearest hour
+
+- **Estimation Formula:**
+  ```
+  Base hours per subtask: 2-3 hours (mid-level)
+  
+  Junior (0-2 years):
+    Lower: (subtasks × 2) × 1.5
+    Upper: (subtasks × 3) × 1.5
+  
+  Mid-level (3-5 years):
+    Lower: subtasks × 2
+    Upper: subtasks × 3
+  
+  Senior (6+ years):
+    Lower: (subtasks × 2) × 0.7
+    Upper: (subtasks × 3) × 0.7
+  ```
+
+- **Display Format:**
+  ```
+  📊 Time Estimation for Task X: [Task Title]
+  
+  Based on [N] subtasks:
+  
+  👶 Junior (0-2 years):     [X-Y] hours
+  👨‍💼 Mid-level (3-5 years): [X-Y] hours
+  👴 Senior (6+ years):      [X-Y] hours
+  ```
+
+- **Natural Language Phrases:**
+  - **FAST FORMAT**: `task-flow: estimate X` or `task-flow estimate X` (simplified)
+  - **MULTIPLE**: `task-flow: estimate X,Y` or `task-flow: estimate all`
+  - "estimate task X" or "estimate X"
+  - "estimate tasks 10,11"
+  - "estimate all tasks"
+  - "how long will task X take"
+  - "time estimate for task X"
+  - Any variation asking for time estimation
+
+- **Example:**
+  ```
+  User: "task-flow: estimate 1"
+  
+  Task 1 has 5 subtasks:
+  
+  📊 Time Estimation for Task 1: Create authentication system
+  
+  Based on 5 subtasks:
+  
+  👶 Junior (0-2 years):     15-23 hours
+  👨‍💼 Mid-level (3-5 years): 10-15 hours
+  👴 Senior (6+ years):     7-11 hours
+  ```
+
+- **Integration:**
+  - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) workflow
+  - Uses task data from `.task-flow/.internal/tasks.json`
+  - Estimates are informational only (not stored)
+
+- **Principle:**
+  > **Provide realistic time estimates based on task complexity (number of subtasks) and developer experience level. Show ranges to account for variability in implementation speed.**

package/.cursor/rules/task_execution.mdc

@@ -21,10 +21,18 @@ alwaysApply: true
   - `task-flow: sync` - Sync new tasks from tasks.input.txt
   - `task-flow: think` - Analyze codebase and suggest new tasks
   - `task-flow: run next X` - Work on next X subtasks sequentially
-  - `task-flow: run task X` - Work on all pending subtasks of task X
+  - `task-flow: run X` - Work on all pending subtasks of task X (simplified - no "task" needed)
+  - `task-flow: run X,Y` - Work on multiple tasks (comma-separated)
+  - `task-flow: run all` - Work on all tasks
   - `task-flow: status` - Show current task status
-  - `task-flow: review` - Review completed tasks
-  - `task-flow: refactor` - Refactor code from current commit
+  - `task-flow: review X` - Review specific task(s) (comma-separated or "all")
+  - `task-flow: refactor X` - Refactor specific task(s) (comma-separated or "all")
+  - `task-flow: estimate X` - Estimate time for task X (simplified - no "task" needed)
+  - `task-flow: estimate X,Y` - Estimate multiple tasks (comma-separated)
+  - `task-flow: estimate all` - Estimate all tasks
+  - `task-flow: report X` - Generate implementation report for task X (simplified - no "task" needed)
+  - `task-flow: report X,Y` - Generate reports for multiple tasks (comma-separated)
+  - `task-flow: report all` - Generate reports for all tasks
 
 - **Workflow Example:**
   ```markdown
@@ -80,7 +88,7 @@ alwaysApply: true
 
 - **Simplified Task Work:**
   - See [task_work.mdc](mdc:.cursor/rules/task_work.mdc) for simplified "do next X subtasks" commands
-  - When user says "faça as próximas X subtasks", automatically find and implement them
+  - When user says "work on next X subtasks" or similar phrases, automatically find and implement them
 
 - **Task Review:**
   - See [task_review.mdc](mdc:.cursor/rules/task_review.mdc) for reviewing completed tasks
@@ -93,10 +101,10 @@ alwaysApply: true
 - **Task Flow Commands - Natural Language Interpretation:**
   - **CRITICAL**: When user mentions **"task flow"**, they **ALWAYS** refer to **RBIN Task Flow**
   - Common phrases that mean "work on RBIN Task Flow subtasks":
-    - "trabalhe nas próximas x subtasks do task flow"
     - "work on next x subtasks from task flow"
-    - "próximas subtasks do task flow"
+    - "next subtasks from task flow"
     - "task flow subtasks"
+    - "do next x subtasks"
     - Any variation mentioning "task flow" + "subtasks"
 
 - **When User Asks to Work on Subtasks:**
@@ -112,7 +120,7 @@ alwaysApply: true
   - **STEP 4**: If all subtasks of a task are done, update task status to "done" in both files
 
 - **Example:**
-  - User: "trabalhe nas próximas 3 subtasks do task flow"
+  - User: "work on next 3 subtasks from task flow"
   - Interpretation: Work on next 3 pending subtasks from RBIN Task Flow
   - Action:
     1. Read `.task-flow/.internal/tasks.json` and `.task-flow/.internal/status.json`

package/.cursor/rules/task_generation.mdc

@@ -18,7 +18,7 @@ alwaysApply: true
   - **AUTOMATIC MATCHING**: Automatically match screenshots to tasks based on keywords (e.g., "login" → `login_recover_signup.png`, "dashboard" → `dashboard.png`, "paciente" → `patient.png`)
   - **SPECIFIC REFERENCE**: If task contains `task-flow-screen nome_do_arquivo.png`, reference that specific screenshot from `.task-flow/screens/`
   - **PATH ALWAYS**: `task-flow-screen` always references files in `.task-flow/screens/` directory
-  - **INCLUDE**: Add screenshot reference in instructions: "Referência visual: `.task-flow/screens/nome_do_arquivo.png`"
+  - **INCLUDE**: Add screenshot reference in instructions: "Visual reference: `.task-flow/screens/filename.png`"
 
 - **Required Actions:**
   1. Read `tasks.input.txt`:
@@ -79,17 +79,17 @@ alwaysApply: true
   ```markdown
   # Task Status
 
-  <!-- ⚠️ AVISO: Este arquivo é atualizado automaticamente pela IA. NÃO edite manualmente. -->
+  <!-- ⚠️ WARNING: This file is automatically updated by AI. DO NOT edit manually. -->
 
-  ## 📊 Resumo
+  ## 📊 Summary
 
-  - ✅ **Tasks Completas**: 0
-  - ⏳ **Tasks em Andamento**: 2
-  - 📝 **Subtasks Restantes**: 8
+  - ✅ **Completed Tasks**: 0
+  - ⏳ **Tasks in Progress**: 2
+  - 📝 **Remaining Subtasks**: 8
 
   **Tasks:**
-  - ✅ Task 1: First task (completa)
-  - ⏳ Task 2: Second task (3 subtasks restantes de 5)
+  - ✅ Task 1: First task (complete)
+  - ⏳ Task 2: Second task (3 remaining subtasks out of 5)
 
   ---
 
@@ -107,10 +107,10 @@ alwaysApply: true
     - [ ] Subtask Title 3
   ```
   - **ALWAYS include summary section** at the top with:
-    - ✅ Tasks completas (all subtasks done)
-    - ⏳ Tasks em andamento (some subtasks done)
-    - 📝 Total de subtasks restantes
-    - Lista de tasks com status e quantas subtasks faltam
+    - ✅ Completed tasks (all subtasks done)
+    - ⏳ Tasks in progress (some subtasks done)
+    - 📝 Total remaining subtasks
+    - List of tasks with status and how many subtasks remain
   - All tasks and subtasks start as `- [ ]` (pending)
   - Format: Task title with `- [ ]` or `- [x]`, then subtasks indented with `  - [ ]` or `  - [x]`
   - **CRITICAL**: Always regenerate summary when updating tasks.status.md
@@ -120,15 +120,15 @@ alwaysApply: true
   - Screenshots available: `login_recover_signup.png`
   - Output: Task with ID 1, 5 subtasks with screenshot references:
     - Subtask 1: "Setup database schema" (no screenshot)
-    - Subtask 2: "Create login form" → Instructions include: "Referência visual: `.task-flow/screens/login_recover_signup.png`"
+    - Subtask 2: "Create login form" → Instructions include: "Visual reference: `.task-flow/screens/login_recover_signup.png`"
     - Subtask 3: "Implement registration" → Instructions include screenshot reference
     - Subtask 4: "Add JWT authentication" (no screenshot)
     - Subtask 5: "Test authentication flow" → Instructions include screenshot reference
   
 - **Screenshot Reference Examples:**
-  - Task: `- Sistema de autenticação do dentista` → Automatically matches and references `login_recover_signup.png` from `.task-flow/screens/`
-  - Task: `- Dashboard básico com estrutura task-flow-screen dashboard.png` → References specific `.task-flow/screens/dashboard.png`
-  - Task: `- CRUD completo de pacientes` → Automatically matches and references `patient.png` and `patient_profile.png` from `.task-flow/screens/` if available
+  - Task: `- Dentist authentication system` → Automatically matches and references `login_recover_signup.png` from `.task-flow/screens/`
+  - Task: `- Basic dashboard with structure task-flow-screen dashboard.png` → References specific `.task-flow/screens/dashboard.png`
+  - Task: `- Complete patient CRUD` → Automatically matches and references `patient.png` and `patient_profile.png` from `.task-flow/screens/` if available
   - **IMPORTANT**: `task-flow-screen` always references files in `.task-flow/screens/` - no need to specify full path
 
 - **Critical Rules:**

package/.cursor/rules/task_refactor.mdc

@@ -5,8 +5,10 @@ alwaysApply: true
 ---
 
 - **Task Refactor - Improve Code Quality:**
-  - **FAST FORMAT**: `task-flow: refactor` → Refactor code from current commit
-  - When user says "task-flow: refactor" or "refactor current tasks":
+  - **FAST FORMAT**: `task-flow: refactor X` or `task-flow: refactor X,Y` or `task-flow: refactor all` → Refactor specific task(s)
+  - **SIMPLIFIED SYNTAX**: No need to say "task" - just use the number: `task-flow: refactor 1` instead of `task-flow: refactor task 1`
+  - **REQUIRED**: Task ID is required - use `task-flow: refactor all` to refactor all tasks
+  - When user says "task-flow: refactor X", "task-flow: refactor X,Y", "task-flow: refactor all", or "refactor tasks":
     - **IDENTIFY**: Files changed in current commit (or staged changes)
     - **REFACTOR**: Improve code quality without changing functionality
     - **REMOVE**: All explanatory comments (following code_comments.mdc rules)
@@ -51,20 +53,21 @@ alwaysApply: true
   5. Show summary of changes
 
 - **Natural Language Phrases:**
-  - **FAST FORMAT**: `task-flow: refactor` or `task-flow refactor`
-  - "refactor current tasks"
-  - "refactor code from commit"
+  - **FAST FORMAT**: `task-flow: refactor X` or `task-flow: refactor X,Y` or `task-flow: refactor all`
+  - "refactor task 1"
+  - "refactor tasks 10,11"
+  - "refactor all tasks"
   - "improve code quality"
   - "clean up code"
-  - Any variation asking to refactor/improve code
+  - Any variation asking to refactor/improve code (must include task ID or "all")
 
 - **Example:**
   ```
-  User: "task-flow: refactor"
+  User: "task-flow: refactor 1"
   
   AI Action:
-  1. Check git diff or staged files
-  2. Identify files changed in current commit
+  1. Identify files related to task 1 (from git history or task implementation)
+  2. Read each file
   3. For each file:
      - Remove explanatory comments
      - Improve code structure
@@ -73,6 +76,14 @@ alwaysApply: true
   4. Preserve separation comments
   5. Verify functionality unchanged
   6. Show refactoring summary
+  
+  User: "task-flow: refactor all"
+  
+  AI Action:
+  1. Process all tasks
+  2. Identify files for each task
+  3. Refactor all files
+  4. Show summary
   ```
 
 - **Integration:**

package/.cursor/rules/task_report.mdc

@@ -0,0 +1,113 @@
+---
+description: Generate implementation reports for completed tasks
+globs: **/*
+alwaysApply: true
+---
+
+- **Task Report - Generate Implementation Reports:**
+  - **FAST FORMAT**: `task-flow: report X` → Generate implementation report for task X (simplified - no "task" needed)
+  - **MULTIPLE TASKS**: `task-flow: report X,Y` → Generate reports for multiple tasks
+  - **ALL TASKS**: `task-flow: report all` → Generate reports for all tasks
+  - When user says "task-flow: report X", "report X", "report X,Y", "report all", "generate report for task X", or "create report task X":
+    - **READ**: `.task-flow/.internal/tasks.json` to get task details
+    - **READ**: `.task-flow/.internal/status.json` to verify task is completed
+    - **ANALYZE**: Codebase changes related to the task (git history, file changes)
+    - **GENERATE**: Markdown report documenting what was implemented
+    - **SAVE**: Report to `.task-flow/docs/task-X-implementation.md`
+
+- **Report Generation Rules:**
+  1. **Verify Completion**: Task must be marked as "done" in status.json (all subtasks completed)
+  2. **Report Structure**:
+     - Task title and description
+     - List of all subtasks with their status
+     - Implementation details (files created/modified)
+     - Code changes summary
+     - Testing information (if applicable)
+     - Notes and considerations
+  3. **File Location**: `.task-flow/docs/task-X-implementation.md`
+  4. **File Naming**: `task-{taskId}-implementation.md` (e.g., `task-1-implementation.md`)
+  5. **Directory Creation**: Create `.task-flow/docs/` if it doesn't exist
+
+- **Report Template:**
+  ```markdown
+  # Task {X}: {Task Title}
+  
+  **Status**: ✅ Completed
+  **Date**: {completion date}
+  
+  ## Description
+  
+  {Task description from tasks.json}
+  
+  ## Subtasks Completed
+  
+  {List all subtasks with their status}
+  
+  ## Implementation Details
+  
+  ### Files Created
+  - {file path}
+  - {file path}
+  
+  ### Files Modified
+  - {file path}
+  - {file path}
+  
+  ## Code Changes Summary
+  
+  {Summary of what was implemented}
+  
+  ## Testing
+  
+  {Testing information if applicable}
+  
+  ## Notes
+  
+  {Additional notes or considerations}
+  ```
+
+- **Report Content:**
+  1. **Task Information**: Title, description, completion date
+  2. **Subtasks**: List all subtasks with their completion status
+  3. **Files**: List files created and modified (from git history or file system)
+  4. **Implementation**: Summary of what was implemented
+  5. **Testing**: Testing information if tests were added
+  6. **Notes**: Additional considerations or follow-up items
+
+- **Natural Language Phrases:**
+  - **FAST FORMAT**: `task-flow: report X` or `task-flow report X` (simplified)
+  - **MULTIPLE**: `task-flow: report X,Y` or `task-flow: report all`
+  - "generate report for task X" or "report X"
+  - "report tasks 10,11"
+  - "report all tasks"
+  - "create report task X"
+  - "document task X"
+  - "report for task X"
+  - Any variation asking for task report generation
+
+- **Example:**
+  ```
+  User: "task-flow: report 1"
+  
+  AI Action:
+  1. Read tasks.json and status.json
+  2. Verify task 1 is completed
+  3. Analyze codebase for changes related to task 1
+  4. Generate markdown report
+  5. Save to .task-flow/docs/task-1-implementation.md
+  6. Show confirmation message
+  ```
+
+- **Error Handling:**
+  - If task is not completed: Show warning and ask if user wants to generate partial report
+  - If task doesn't exist: Show error message
+  - If docs directory doesn't exist: Create it automatically
+
+- **Integration:**
+  - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) workflow
+  - Uses task data from `.task-flow/.internal/tasks.json` and `.task-flow/.internal/status.json`
+  - Reports are stored in `.task-flow/docs/` directory
+  - Can reference git history for implementation details
+
+- **Principle:**
+  > **Generate comprehensive implementation reports documenting what was completed in each task. Reports should be useful for code reviews, documentation, and project tracking.**

package/.cursor/rules/task_review.mdc

@@ -5,8 +5,10 @@ alwaysApply: true
 ---
 
 - **Task Review - Verify Completed Tasks:**
-  - **FAST FORMAT**: `task-flow: review` → Review all completed tasks
-  - When user says "task-flow: review" or "review completed tasks":
+  - **FAST FORMAT**: `task-flow: review X` or `task-flow: review X,Y` or `task-flow: review all` → Review specific task(s)
+  - **SIMPLIFIED SYNTAX**: No need to say "task" - just use the number: `task-flow: review 1` instead of `task-flow: review task 1`
+  - **REQUIRED**: Task ID is required - use `task-flow: review all` to review all tasks
+  - When user says "task-flow: review X", "task-flow: review X,Y", "task-flow: review all", or "review completed tasks":
     - **READ**: `.task-flow/.internal/tasks.json` and `.task-flow/.internal/status.json`
     - **IDENTIFY**: All tasks/subtasks marked as "done"
     - **VERIFY**: Check if each completed task/subtask is actually implemented
@@ -44,20 +46,22 @@ alwaysApply: true
   ```
 
 - **Natural Language Phrases:**
-  - **FAST FORMAT**: `task-flow: review` or `task-flow review`
-  - "review completed tasks"
+  - **FAST FORMAT**: `task-flow: review X` or `task-flow: review X,Y` or `task-flow: review all`
+  - "review task 1"
+  - "review tasks 10,11"
+  - "review all tasks"
   - "verify done tasks"
   - "check if tasks are really done"
   - "review task status"
-  - Any variation asking to review/verify completed tasks
+  - Any variation asking to review/verify completed tasks (must include task ID or "all")
 
 - **Example:**
   ```
-  User: "task-flow: review"
+  User: "task-flow: review 1"
   
   AI Action:
   1. Read tasks.json and status.json
-  2. Find all "done" tasks/subtasks
+  2. Find task 1 and its "done" subtasks
   3. Verify each one:
      - Check if files exist
      - Check if code matches requirements
@@ -65,6 +69,15 @@ alwaysApply: true
   4. Report findings
   5. Ask if user wants to correct status
   6. If confirmed, update status.json
+  
+  User: "task-flow: review all"
+  
+  AI Action:
+  1. Read tasks.json and status.json
+  2. Find all "done" tasks/subtasks
+  3. Verify each one
+  4. Report findings
+  5. Ask if user wants to correct status
   ```
 
 - **Integration:**

package/.cursor/rules/task_work.mdc

@@ -6,14 +6,17 @@ alwaysApply: true
 
 - **Task Work - Simplified Commands:**
   - **FASTEST FORMAT**: `task-flow: run next X` (e.g., "task-flow: run next 4" → work on next 4 subtasks)
-  - **TASK SPECIFIC**: `task-flow: run task X` (e.g., "task-flow: run task 1" → work on all subtasks of task 1)
-  - When user says "task-flow: run next X", "faça as próximas X subtasks", or "work on next X subtasks":
+  - **TASK SPECIFIC**: `task-flow: run X` or `task-flow: run X,Y` or `task-flow: run all` (e.g., "task-flow: run 1" → work on all subtasks of task 1)
+  - **SIMPLIFIED SYNTAX**: No need to say "task" - just use the number: `task-flow: run 1` instead of `task-flow: run task 1`
+  - When user says "task-flow: run next X" or "work on next X subtasks":
     - **INTERPRET**: User wants to work on the next X pending subtasks from RBIN Task Flow
     - **AUTOMATIC**: Read tasks, find next X pending, implement them sequentially
     - **UPDATE**: Mark each subtask as done after completion
     - **NO NEED**: To specify "task flow" explicitly - it's implied
-  - When user says "task-flow: run task X", "execute todas as subtasks da task X", or "work on task X":
-    - **INTERPRET**: User wants to work on all pending subtasks of a specific task
+  - When user says "task-flow: run X" or "task-flow: run X,Y" or "task-flow: run all":
+    - **INTERPRET**: User wants to work on all pending subtasks of specific task(s) or all tasks
+    - **MULTIPLE TASKS**: Comma-separated IDs (e.g., "10,11") processes multiple tasks sequentially
+    - **ALL TASKS**: "all" processes all tasks in order
     - **DEPENDENCY CHECK**: Before executing, verify that all tasks before X (1, 2, ..., X-1) are completely done
     - **CONFLICT PREVENTION**: Only execute subtasks of task X if no previous tasks have pending subtasks (allows parallel work by multiple AIs)
     - **PARTIAL EXECUTION**: If previous tasks have pending subtasks, inform user that task X cannot be fully executed until previous tasks are complete
@@ -23,30 +26,33 @@ alwaysApply: true
 
 - **Natural Language Phrases:**
   - **FAST FORMAT**: `task-flow: run next X` or `task-flow run next X` (e.g., "task-flow: run next 4")
-  - **TASK FORMAT**: `task-flow: run task X` or `task-flow run task X` (e.g., "task-flow: run task 1")
-  - "faça as próximas 3 subtasks"
+  - **TASK FORMAT**: `task-flow: run X` or `task-flow: run X,Y` or `task-flow: run all` (e.g., "task-flow: run 1" or "task-flow: run 10,11" or "task-flow: run all")
+  - "work on next 3 subtasks"
   - "work on next 5 subtasks"
-  - "próximas 2 subtasks"
-  - "faça próximas subtasks"
+  - "next 2 subtasks"
+  - "work on next subtasks"
   - "implement next X subtasks"
-  - "trabalhe nas próximas X subtasks"
-  - "execute todas as subtasks da task 1"
+  - "work on next X subtasks"
+  - "execute all subtasks of task 1"
   - "work on all subtasks of task 2"
-  - Any phrase with "próximas" + number + "subtasks" or "next" + number + "subtasks"
+  - Any phrase with "next" + number + "subtasks"
   - Any phrase with "task" + number + "subtasks" or "all subtasks" + "task" + number
   
 - **Fast Command Format:**
   - `task-flow: run next X` → Work on next X subtasks sequentially (fastest way)
   - `task-flow run next X` → Same as above (without colon)
   - `task-flow: run next` → Work on next 1 subtask (default)
-  - `task-flow: run task X` → Work on all pending subtasks of task X
-  - `task-flow run task X` → Same as above (without colon)
+  - `task-flow: run X` → Work on all pending subtasks of task X (simplified - no "task" needed)
+  - `task-flow: run X,Y` → Work on all pending subtasks of tasks X and Y
+  - `task-flow: run all` → Work on all pending subtasks of all tasks
+  - `task-flow run X` → Same as above (without colon)
   - Examples:
     - "task-flow: run next 4" → Work on next 4 subtasks
     - "task-flow run next 3" → Work on next 3 subtasks
     - "task-flow: run next" → Work on next 1 subtask
-    - "task-flow: run task 1" → Work on all pending subtasks of task 1
-    - "task-flow run task 2" → Work on all pending subtasks of task 2
+    - "task-flow: run 1" → Work on all pending subtasks of task 1
+    - "task-flow: run 10,11" → Work on all pending subtasks of tasks 10 and 11
+    - "task-flow: run all" → Work on all pending subtasks of all tasks
 
 - **Required Actions for `task-flow: run next X`:**
   1. **Read task files**: `.task-flow/.internal/tasks.json` and `.task-flow/.internal/status.json`
@@ -118,7 +124,7 @@ alwaysApply: true
     3. Update `.task-flow/tasks.status.md`:
        - Change `- [ ]` to `- [x]` for the subtask
        - If all subtasks of a task are done, mark task as `- [x]`
-       - **REGENERATE SUMMARY**: Always update the "📊 Resumo" section at the top with:
+       - **REGENERATE SUMMARY**: Always update the "📊 Summary" section at the top with:
          - Count of completed tasks (✅)
          - Count of in-progress tasks (⏳)
          - Total remaining subtasks (📝)
@@ -171,16 +177,16 @@ alwaysApply: true
   7. Mark task 3 as "done" if all subtasks completed
   8. Show completion summary
   
-  User: "faça as próximas 3 subtasks"
+  User: "work on next 3 subtasks"
   AI Action: Same workflow as "run next 3", works with natural language too
   
-  User: "execute todas as subtasks da task 2"
+  User: "execute all subtasks of task 2"
   AI Action: Same workflow as "run task 2", includes dependency check
   ```
 
 - **Default Behavior:**
-  - If user says "próximas subtasks" without number → assume 1 subtask
-  - If user says "próximas X subtasks" → work on exactly X subtasks
+  - If user says "next subtasks" without number → assume 1 subtask
+  - If user says "next X subtasks" → work on exactly X subtasks
   - If user says "task X" without "next" → interpret as "run task X" (all subtasks of that task)
   - Always work sequentially (don't skip or reorder)