rbin-task-flow 1.2.0 → 1.3.0

package/.cursor/rules/task_estimate.mdc

@@ -5,8 +5,10 @@ alwaysApply: true
 ---
 
 - **Task Estimation - Time Estimation for Tasks:**
-  - **FAST FORMAT**: `task-flow: estimate task X` → Estimate time for task X
-  - When user says "task-flow: estimate task X", "estimate task X", or "how long will task X take":
+  - **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)
@@ -57,16 +59,18 @@ alwaysApply: true
   ```
 
 - **Natural Language Phrases:**
-  - **FAST FORMAT**: `task-flow: estimate task X` or `task-flow estimate task X`
-  - "estimate task X"
+  - **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"
-  - "quanto tempo leva a task X"
   - Any variation asking for time estimation
 
 - **Example:**
   ```
-  User: "task-flow: estimate task 1"
+  User: "task-flow: estimate 1"
   
   Task 1 has 5 subtasks:
   

package/.cursor/rules/task_execution.mdc

@@ -21,12 +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: estimate task X` - Estimate time for task X based on subtasks and experience level
-  - `task-flow: report task X` - Generate implementation report for completed task X
+  - `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

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

@@ -5,8 +5,10 @@ alwaysApply: true
 ---
 
 - **Task Report - Generate Implementation Reports:**
-  - **FAST FORMAT**: `task-flow: report task X` → Generate implementation report for task X
-  - When user says "task-flow: report task X", "generate report for task X", or "create report task X":
+  - **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)
@@ -73,8 +75,11 @@ alwaysApply: true
   6. **Notes**: Additional considerations or follow-up items
 
 - **Natural Language Phrases:**
-  - **FAST FORMAT**: `task-flow: report task X` or `task-flow report task X`
-  - "generate report for task X"
+  - **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"
@@ -82,7 +87,7 @@ alwaysApply: true
 
 - **Example:**
   ```
-  User: "task-flow: report task 1"
+  User: "task-flow: report 1"
   
   AI Action:
   1. Read tasks.json and status.json

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)
+  - **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" 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,7 +26,7 @@ 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")
+  - **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"
   - "next 2 subtasks"
@@ -39,14 +42,17 @@ alwaysApply: true
   - `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`

package/.task-flow/README.md

@@ -6,13 +6,15 @@
 |---------|-------------|
 | `task-flow: sync` | Complete synchronization: adds new, removes deleted, updates modified, preserves status |
 | `task-flow: think` | Analyzes code and suggests new tasks |
-| `task-flow: run next X` | Works on next X subtasks (e.g., `task-flow: run next 4`) |
-| `task-flow: run task X` | Executes all pending subtasks of task X (e.g., `task-flow: run task 1`) |
 | `task-flow: status` | Shows current task status |
-| `task-flow: review` | Reviews tasks marked as "done" |
-| `task-flow: refactor` | Refactors code from current commit |
-| `task-flow: estimate task X` | Estimates time for task X based on subtasks and experience level |
-| `task-flow: report task X` | Generates implementation report for completed task X |
+| `task-flow: run next X` | Works on next X subtasks (e.g., `task-flow: run next 4`) |
+| `task-flow: run X` | Executes all pending subtasks of task X (e.g., `task-flow: run 1`) |
+| `task-flow: run X,Y` | Executes multiple tasks (e.g., `task-flow: run 10,11`) |
+| `task-flow: run all` | Executes all tasks |
+| `task-flow: review X` | Reviews specific task(s) (e.g., `task-flow: review 1` or `task-flow: review 10,11` or `task-flow: review all`) |
+| `task-flow: refactor X` | Refactors specific task(s) (e.g., `task-flow: refactor 1` or `task-flow: refactor 10,11` or `task-flow: refactor all`) |
+| `task-flow: estimate X` | Estimates time for task X (e.g., `task-flow: estimate 1` or `task-flow: estimate 10,11`) |
+| `task-flow: report X` | Generates implementation report for task X (e.g., `task-flow: report 1` or `task-flow: report 10,11`) |
 
 **See complete details below ↓**
 
@@ -31,6 +33,13 @@ Complete synchronization between `tasks.input.txt` and the system:
 ### `task-flow: think`
 Analyzes code and suggests new tasks. Asks before adding to `tasks.input.txt`.
 
+### `task-flow: status`
+Shows current status of tasks and subtasks from the `tasks.status.md` file.
+
+---
+
+## Commands with Task ID
+
 ### `task-flow: run next X`
 Works on next X pending subtasks in sequential order. Implements and marks as "done".
 
@@ -38,7 +47,7 @@ Works on next X pending subtasks in sequential order. Implements and marks as "d
 - `task-flow: run next 4` → Next 4 subtasks
 - `task-flow: run next` → Next 1 subtask
 
-### `task-flow: run task X`
+### `task-flow: run X` (simplified syntax)
 Executes all pending subtasks of a specific task. Implements and marks as "done".
 
 **⚠️ Dependency Check:**
@@ -47,20 +56,29 @@ Executes all pending subtasks of a specific task. Implements and marks as "done"
 - If there are pending previous tasks, warns which ones need to be completed first
 
 **Examples:**
-- `task-flow: run task 1` → All pending subtasks of task 1 (can always execute)
-- `task-flow: run task 3` → Only executes if tasks 1 and 2 are complete
+- `task-flow: run 1` → All pending subtasks of task 1 (can always execute)
+- `task-flow: run 10,11` → All pending subtasks of tasks 10 and 11
+- `task-flow: run all` → All pending subtasks of all tasks
+- `task-flow: run 3` → Only executes if tasks 1 and 2 are complete
 
-### `task-flow: status`
-Shows current status of tasks and subtasks from the `tasks.status.md` file.
+### `task-flow: review X`
+Reviews specific task(s) marked as "done" to verify they are actually completed.
 
-### `task-flow: review`
-Reviews tasks marked as "done" to verify they are actually completed.
+**Examples:**
+- `task-flow: review 1` → Reviews task 1
+- `task-flow: review 10,11` → Reviews tasks 10 and 11
+- `task-flow: review all` → Reviews all tasks
+
+### `task-flow: refactor X`
+Refactors code from specific task(s). Removes explanatory comments, improves code without changing functionality.
 
-### `task-flow: refactor`
-Refactors code from current commit. Removes explanatory comments, improves code without changing functionality.
+**Examples:**
+- `task-flow: refactor 1` → Refactors task 1
+- `task-flow: refactor 10,11` → Refactors tasks 10 and 11
+- `task-flow: refactor all` → Refactors all tasks
 
-### `task-flow: estimate task X`
-Estimates time required to complete a task based on the number of subtasks and developer experience level.
+### `task-flow: estimate X` (simplified syntax)
+Estimates time required to complete task(s) based on the number of subtasks and developer experience level.
 
 **Output includes:**
 - Time estimates for Junior (0-2 years), Mid-level (3-5 years), and Senior (6+ years) developers
@@ -68,10 +86,12 @@ Estimates time required to complete a task based on the number of subtasks and d
 - Recommendation for management with buffer
 
 **Examples:**
-- `task-flow: estimate task 1` → Shows time estimate for task 1
+- `task-flow: estimate 1` → Shows time estimate for task 1
+- `task-flow: estimate 10,11` → Shows time estimates for tasks 10 and 11
+- `task-flow: estimate all` → Shows time estimates for all tasks
 
-### `task-flow: report task X`
-Generates a detailed implementation report for a completed task in Markdown format.
+### `task-flow: report X` (simplified syntax)
+Generates a detailed implementation report for completed task(s) in Markdown format.
 
 **Report includes:**
 - Task overview and completion status
@@ -83,7 +103,9 @@ Generates a detailed implementation report for a completed task in Markdown form
 **Report location:** `.task-flow/docs/task-X-implementation.md`
 
 **Examples:**
-- `task-flow: report task 1` → Generates report for task 1
+- `task-flow: report 1` → Generates report for task 1
+- `task-flow: report 10,11` → Generates reports for tasks 10 and 11
+- `task-flow: report all` → Generates reports for all tasks
 
 ---
 

package/CLAUDE.md

@@ -16,14 +16,20 @@ This project uses RBIN Task Flow for task management:
 - **Task Definition**: Edit `.task-flow/tasks.input.txt` using simple format: `- Task description`
 - **AI Commands**: Use AI-powered commands for task management:
   - `task-flow: sync` - Synchronize tasks from tasks.input.txt
-  - `task-flow: run next X` - Work on next X subtasks
-  - `task-flow: run task X` - Execute all pending subtasks of task X
-  - `task-flow: status` - View current task status
-  - `task-flow: review` - Review completed tasks
   - `task-flow: think` - Analyze code and suggest new tasks
-  - `task-flow: refactor` - Refactor code from current commit
-  - `task-flow: estimate task X` - Estimate time for task X based on subtasks and experience level
-  - `task-flow: report task X` - Generate implementation report for completed task X
+  - `task-flow: status` - View current task status
+  - `task-flow: run next X` - Work on next X subtasks
+  - `task-flow: run X` - Execute all pending subtasks of task X (simplified - no "task" needed)
+  - `task-flow: run X,Y` - Execute multiple tasks (comma-separated)
+  - `task-flow: run all` - Execute all tasks
+  - `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
 - **Files**:
   - `.task-flow/tasks.input.txt` - Define your tasks here
   - `.task-flow/tasks.status.md` - Auto-generated status (DO NOT EDIT manually)

package/GEMINI.md

@@ -16,14 +16,20 @@ This project uses RBIN Task Flow for task management:
 - **Task Definition**: Edit `.task-flow/tasks.input.txt` using simple format: `- Task description`
 - **AI Commands**: Use AI-powered commands for task management:
   - `task-flow: sync` - Synchronize tasks from tasks.input.txt
-  - `task-flow: run next X` - Work on next X subtasks
-  - `task-flow: run task X` - Execute all pending subtasks of task X
-  - `task-flow: status` - View current task status
-  - `task-flow: review` - Review completed tasks
   - `task-flow: think` - Analyze code and suggest new tasks
-  - `task-flow: refactor` - Refactor code from current commit
-  - `task-flow: estimate task X` - Estimate time for task X based on subtasks and experience level
-  - `task-flow: report task X` - Generate implementation report for completed task X
+  - `task-flow: status` - View current task status
+  - `task-flow: run next X` - Work on next X subtasks
+  - `task-flow: run X` - Execute all pending subtasks of task X (simplified - no "task" needed)
+  - `task-flow: run X,Y` - Execute multiple tasks (comma-separated)
+  - `task-flow: run all` - Execute all tasks
+  - `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
 - **Files**:
   - `.task-flow/tasks.input.txt` - Define your tasks here
   - `.task-flow/tasks.status.md` - Auto-generated status (DO NOT EDIT manually)

package/README.md

@@ -60,7 +60,7 @@ rbin-task-flow init
 # Edite .task-flow/tasks.input.txt e use:
 # - task-flow: sync
 # - task-flow: run next X
-# - task-flow: run task X
+# - task-flow: run X (ou task-flow: run X,Y ou task-flow: run all)
 ```
 
 **Pronto!** RBIN Task Flow agora está disponível globalmente no seu sistema.
@@ -74,8 +74,8 @@ rbin-task-flow init          # Inicializa no projeto atual
 rbin-task-flow update        # Atualiza configurações
 rbin-task-flow version-check # Verifica atualizações de modelos
 rbin-task-flow info          # Mostra informações
-rbin-task-flow estimate <id> # Estima tempo para uma task
-rbin-task-flow report <id>  # Gera relatório de implementação de uma task
+rbin-task-flow estimate <ids> # Estima tempo (ex: "1" ou "1,2" ou "all")
+rbin-task-flow report <ids>  # Gera relatório (ex: "1" ou "1,2" ou "all")
 ```
 
 ### Comandos da IA - Por Que Usar?
@@ -86,13 +86,15 @@ Após inicializar, use estes comandos na IA (Cursor/Claude/Gemini) para gerencia
 |---------|--------------|-------------------|
 | `task-flow: sync` | **Sincroniza** tarefas do arquivo texto com o sistema | Mantém tudo sincronizado automaticamente - adiciona novas, remove deletadas, preserva seu progresso |
 | `task-flow: think` | **Descobre** tarefas que você esqueceu | Analisa código e sugere tarefas que faltam (testes, refatoração, documentação) |
-| `task-flow: run next X` | **Automatiza** o trabalho nas próximas subtarefas | A IA trabalha nas próximas X subtarefas sequencialmente, você só acompanha |
-| `task-flow: run task X` | **Completa** uma tarefa inteira de uma vez | Executa todas as subtarefas de uma tarefa específica (permite trabalho paralelo) |
 | `task-flow: status` | **Visualiza** o progresso rapidamente | Vê resumo com tasks completas, em andamento e quantas subtarefas faltam |
-| `task-flow: review` | **Garante** qualidade do trabalho | Verifica se tarefas marcadas como "done" estão realmente concluídas |
-| `task-flow: refactor` | **Melhora** código sem quebrar | Refatora código do commit atual removendo comentários e melhorando qualidade |
-| `task-flow: estimate task X` | **Estima** tempo para gestão | Calcula estimativa de tempo baseada em subtasks e nível de experiência do desenvolvedor |
-| `task-flow: report task X` | **Documenta** implementação | Gera relatório detalhado em Markdown do que foi feito para resolver a task |
+| `task-flow: run next X` | **Automatiza** o trabalho nas próximas subtarefas | A IA trabalha nas próximas X subtarefas sequencialmente, você só acompanha |
+| `task-flow: run X` | **Completa** uma tarefa inteira de uma vez | Executa todas as subtarefas de uma tarefa específica (permite trabalho paralelo) |
+| `task-flow: run X,Y` | **Completa** múltiplas tarefas | Executa tarefas separadas por vírgula (ex: `task-flow: run 10,11`) |
+| `task-flow: run all` | **Completa** todas as tarefas | Executa todas as tarefas pendentes |
+| `task-flow: review X` | **Garante** qualidade do trabalho | Verifica tarefas específicas (ex: `task-flow: review 1` ou `task-flow: review 10,11` ou `task-flow: review all`) |
+| `task-flow: refactor X` | **Melhora** código sem quebrar | Refatora tarefas específicas (ex: `task-flow: refactor 1` ou `task-flow: refactor 10,11` ou `task-flow: refactor all`) |
+| `task-flow: estimate X` | **Estima** tempo para gestão | Calcula estimativa de tempo (ex: `task-flow: estimate 1` ou `task-flow: estimate 10,11`) |
+| `task-flow: report X` | **Documenta** implementação | Gera relatório detalhado (ex: `task-flow: report 1` ou `task-flow: report 10,11`) |
 
 **Fluxo típico:**
 
@@ -423,7 +425,7 @@ rbin-task-flow init
 # Edit .task-flow/tasks.input.txt and use:
 # - task-flow: sync
 # - task-flow: run next X
-# - task-flow: run task X
+# - task-flow: run X (or task-flow: run X,Y or task-flow: run all)
 ```
 
 **That's it!** RBIN Task Flow is now available globally on your system.
@@ -437,8 +439,8 @@ rbin-task-flow init          # Initialize in current project
 rbin-task-flow update        # Update configurations
 rbin-task-flow version-check # Check for model updates
 rbin-task-flow info          # Show information
-rbin-task-flow estimate <id> # Estimate time for a task
-rbin-task-flow report <id>   # Generate implementation report for a task
+rbin-task-flow estimate <ids> # Estimate time (e.g., "1" or "1,2" or "all")
+rbin-task-flow report <ids>   # Generate report (e.g., "1" or "1,2" or "all")
 ```
 
 ### AI Commands - Why Use Them?
@@ -449,13 +451,15 @@ After initializing, use these commands in your AI (Cursor/Claude/Gemini) to auto
 |---------|------------|-------------|
 | `task-flow: sync` | **Sync** tasks from text file with system | Keeps everything synchronized automatically - adds new, removes deleted, preserves your progress |
 | `task-flow: think` | **Discover** tasks you forgot | Analyzes code and suggests missing tasks (tests, refactoring, documentation) |
-| `task-flow: run next X` | **Automate** work on next subtasks | AI works on next X subtasks sequentially, you just follow along |
-| `task-flow: run task X` | **Complete** an entire task at once | Executes all subtasks of a specific task (allows parallel work) |
 | `task-flow: status` | **Visualize** progress quickly | See summary with completed tasks, in progress, and remaining subtasks |
-| `task-flow: review` | **Ensure** work quality | Verifies that tasks marked as "done" are actually completed |
-| `task-flow: refactor` | **Improve** code without breaking | Refactors code from current commit removing comments and improving quality |
-| `task-flow: estimate task X` | **Estimate** time for management | Calculates time estimate based on subtasks and developer experience level |
-| `task-flow: report task X` | **Document** implementation | Generates detailed Markdown report of what was done to resolve the task |
+| `task-flow: run next X` | **Automate** work on next subtasks | AI works on next X subtasks sequentially, you just follow along |
+| `task-flow: run X` | **Complete** an entire task at once | Executes all subtasks of a specific task (allows parallel work) |
+| `task-flow: run X,Y` | **Complete** multiple tasks | Executes comma-separated tasks (e.g., `task-flow: run 10,11`) |
+| `task-flow: run all` | **Complete** all tasks | Executes all pending tasks |
+| `task-flow: review X` | **Ensure** work quality | Verifies specific tasks (e.g., `task-flow: review 1` or `task-flow: review 10,11` or `task-flow: review all`) |
+| `task-flow: refactor X` | **Improve** code without breaking | Refactors specific tasks (e.g., `task-flow: refactor 1` or `task-flow: refactor 10,11` or `task-flow: refactor all`) |
+| `task-flow: estimate X` | **Estimate** time for management | Calculates time estimate (e.g., `task-flow: estimate 1` or `task-flow: estimate 10,11`) |
+| `task-flow: report X` | **Document** implementation | Generates detailed report (e.g., `task-flow: report 1` or `task-flow: report 10,11`) |
 
 **Typical workflow:**
 

package/bin/cli.js

@@ -40,22 +40,22 @@ program
 
 program
   .command('estimate')
-  .description('Estimate time for a task based on subtasks and experience level')
-  .argument('<taskId>', 'Task ID to estimate')
+  .description('Estimate time for task(s) based on subtasks and experience level')
+  .argument('<taskIds>', 'Task ID(s) to estimate (comma-separated or "all")')
   .option('-p, --path <path>', 'Target directory (default: current directory)')
-  .action(async (taskId, options) => {
+  .action(async (taskIds, options) => {
     const targetPath = options.path || process.cwd();
-    await estimateTask(taskId, targetPath);
+    await estimateTask(taskIds, targetPath);
   });
 
 program
   .command('report')
-  .description('Generate implementation report for a completed task')
-  .argument('<taskId>', 'Task ID to generate report for')
+  .description('Generate implementation report for completed task(s)')
+  .argument('<taskIds>', 'Task ID(s) to generate report for (comma-separated or "all")')
   .option('-p, --path <path>', 'Target directory (default: current directory)')
-  .action(async (taskId, options) => {
+  .action(async (taskIds, options) => {
     const targetPath = options.path || process.cwd();
-    await generateReport(taskId, targetPath);
+    await generateReport(taskIds, targetPath);
   });
 
 program
@@ -72,8 +72,8 @@ program
     console.log(chalk.cyan('  rbin-task-flow init') + '         - Initialize in current directory');
     console.log(chalk.cyan('  rbin-task-flow update') + '       - Update configurations');
     console.log(chalk.cyan('  rbin-task-flow version-check') + ' - Check for model updates');
-    console.log(chalk.cyan('  rbin-task-flow estimate <id>') + ' - Estimate time for a task');
-    console.log(chalk.cyan('  rbin-task-flow report <id>') + '  - Generate implementation report');
+    console.log(chalk.cyan('  rbin-task-flow estimate <ids>') + ' - Estimate time (e.g., "1" or "1,2" or "all")');
+    console.log(chalk.cyan('  rbin-task-flow report <ids>') + '  - Generate report (e.g., "1" or "1,2" or "all")');
     console.log(chalk.cyan('  rbin-task-flow info') + '         - Show this information\n');
   });
 

package/lib/estimate.js

@@ -1,8 +1,9 @@
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
+const { parseTaskIds } = require('./utils');
 
-async function estimateTask(taskId, targetPath = process.cwd()) {
+async function estimateTask(taskIdsInput, targetPath = process.cwd()) {
   const tasksPath = path.join(targetPath, '.task-flow/.internal/tasks.json');
 
   if (!fs.existsSync(tasksPath)) {
@@ -12,57 +13,81 @@ async function estimateTask(taskId, targetPath = process.cwd()) {
 
   try {
     const tasksData = await fs.readJSON(tasksPath);
-    const task = tasksData.tasks.find(t => t.id === parseInt(taskId));
-
-    if (!task) {
-      console.log(chalk.red(`❌ Task ${taskId} not found.`));
+    const taskIds = parseTaskIds(taskIdsInput, tasksData.tasks);
+    
+    if (taskIds.length === 0) {
+      console.log(chalk.red('❌ No valid task IDs provided.'));
       return;
     }
 
-    const subtaskCount = task.subtasks ? task.subtasks.length : 0;
-
-    if (subtaskCount === 0) {
-      console.log(chalk.yellow(`⚠️  Task ${taskId} has no subtasks. Cannot estimate.`));
-      return;
+    let successCount = 0;
+    let errorCount = 0;
+
+    for (const taskId of taskIds) {
+      const task = tasksData.tasks.find(t => t.id === taskId);
+
+      if (!task) {
+        console.log(chalk.red(`❌ Task ${taskId} not found.`));
+        errorCount++;
+        continue;
+      }
+
+      const subtaskCount = task.subtasks ? task.subtasks.length : 0;
+
+      if (subtaskCount === 0) {
+        console.log(chalk.yellow(`⚠️  Task ${taskId} has no subtasks. Cannot estimate.`));
+        errorCount++;
+        continue;
+      }
+
+      const estimates = calculateEstimates(subtaskCount);
+
+      if (taskIds.length > 1) {
+        console.log('\n' + chalk.cyan('═'.repeat(70)));
+      } else {
+        console.log('\n' + chalk.cyan('═'.repeat(70)));
+      }
+      console.log(chalk.magenta('📊 Task Estimation Report'));
+      console.log(chalk.cyan('═'.repeat(70)) + '\n');
+
+      console.log(chalk.blue.bold('Task:'), chalk.yellow(`#${taskId} - ${task.title}\n`));
+      console.log(chalk.blue(`Complexity: ${chalk.yellow(subtaskCount)} subtasks\n`));
+
+      console.log(chalk.cyan('─'.repeat(70)));
+      console.log(chalk.magenta.bold('Time Estimates by Experience Level:\n'));
+
+      const juniorDays = Math.ceil(estimates.junior.upper / 8);
+      const midDays = Math.ceil(estimates.mid.upper / 8);
+      const seniorDays = Math.ceil(estimates.senior.upper / 8);
+
+      console.log(chalk.gray('👶 Junior Developer (0-2 years):'));
+      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.junior.lower}-${estimates.junior.upper} hours`));
+      console.log(chalk.white('   Days: '), chalk.yellow(`~${juniorDays} business day(s)`));
+      console.log('');
+
+      console.log(chalk.gray('👨‍💼 Mid-level Developer (3-5 years):'));
+      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.mid.lower}-${estimates.mid.upper} hours`));
+      console.log(chalk.white('   Days: '), chalk.yellow(`~${midDays} business day(s)`));
+      console.log('');
+
+      console.log(chalk.gray('👴 Senior Developer (6+ years):'));
+      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.senior.lower}-${estimates.senior.upper} hours`));
+      console.log(chalk.white('   Days: '), chalk.yellow(`~${seniorDays} business day(s)`));
+      console.log('');
+
+      console.log(chalk.cyan('─'.repeat(70)));
+      console.log(chalk.magenta.bold('Recommendation for Management:\n'));
+      console.log(chalk.white('   Recommended estimate:'), chalk.yellow(`${estimates.mid.lower}-${estimates.mid.upper} hours`), chalk.gray('(mid-level baseline)'));
+      console.log(chalk.white('   Buffer recommended:'), chalk.yellow(`+20%`), chalk.gray('for unexpected issues'));
+      console.log(chalk.white('   Total estimate:'), chalk.yellow(`${Math.round(estimates.mid.upper * 1.2)} hours`), chalk.gray(`(~${Math.ceil(estimates.mid.upper * 1.2 / 8)} business days)`));
+      console.log('');
+
+      successCount++;
     }
 
-    const estimates = calculateEstimates(subtaskCount);
-
-    console.log('\n' + chalk.cyan('═'.repeat(70)));
-    console.log(chalk.magenta('📊 Task Estimation Report'));
-    console.log(chalk.cyan('═'.repeat(70)) + '\n');
-
-    console.log(chalk.blue.bold('Task:'), chalk.yellow(`#${taskId} - ${task.title}\n`));
-    console.log(chalk.blue(`Complexity: ${chalk.yellow(subtaskCount)} subtasks\n`));
-
-    console.log(chalk.cyan('─'.repeat(70)));
-    console.log(chalk.magenta.bold('Time Estimates by Experience Level:\n'));
-
-    const juniorDays = Math.ceil(estimates.junior.upper / 8);
-    const midDays = Math.ceil(estimates.mid.upper / 8);
-    const seniorDays = Math.ceil(estimates.senior.upper / 8);
-
-    console.log(chalk.gray('👶 Junior Developer (0-2 years):'));
-    console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.junior.lower}-${estimates.junior.upper} hours`));
-    console.log(chalk.white('   Days: '), chalk.yellow(`~${juniorDays} business day(s)`));
-    console.log('');
-
-    console.log(chalk.gray('👨‍💼 Mid-level Developer (3-5 years):'));
-    console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.mid.lower}-${estimates.mid.upper} hours`));
-    console.log(chalk.white('   Days: '), chalk.yellow(`~${midDays} business day(s)`));
-    console.log('');
-
-    console.log(chalk.gray('👴 Senior Developer (6+ years):'));
-    console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.senior.lower}-${estimates.senior.upper} hours`));
-    console.log(chalk.white('   Days: '), chalk.yellow(`~${seniorDays} business day(s)`));
-    console.log('');
-
-    console.log(chalk.cyan('─'.repeat(70)));
-    console.log(chalk.magenta.bold('Recommendation for Management:\n'));
-    console.log(chalk.white('   Recommended estimate:'), chalk.yellow(`${estimates.mid.lower}-${estimates.mid.upper} hours`), chalk.gray('(mid-level baseline)'));
-    console.log(chalk.white('   Buffer recommended:'), chalk.yellow(`+20%`), chalk.gray('for unexpected issues'));
-    console.log(chalk.white('   Total estimate:'), chalk.yellow(`${Math.round(estimates.mid.upper * 1.2)} hours`), chalk.gray(`(~${Math.ceil(estimates.mid.upper * 1.2 / 8)} business days)`));
-    console.log('');
+    if (taskIds.length > 1) {
+      console.log(chalk.cyan(`\n📊 Estimated ${successCount} task(s), ${errorCount} error(s)`));
+    }
 
   } catch (error) {
     console.error(chalk.red('Error reading tasks:'), error.message);

package/lib/report.js

@@ -2,8 +2,9 @@ const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
 const { execSync } = require('child_process');
+const { parseTaskIds } = require('./utils');
 
-async function generateReport(taskId, targetPath = process.cwd()) {
+async function generateReport(taskIdsInput, targetPath = process.cwd()) {
   const tasksPath = path.join(targetPath, '.task-flow/.internal/tasks.json');
   const statusPath = path.join(targetPath, '.task-flow/.internal/status.json');
   const docsDir = path.join(targetPath, '.task-flow/docs');
@@ -22,36 +23,54 @@ async function generateReport(taskId, targetPath = process.cwd()) {
     const tasksData = await fs.readJSON(tasksPath);
     const statusData = await fs.readJSON(statusPath);
     
-    const task = tasksData.tasks.find(t => t.id === parseInt(taskId));
-
-    if (!task) {
-      console.log(chalk.red(`❌ Task ${taskId} not found.`));
+    const taskIds = parseTaskIds(taskIdsInput, tasksData.tasks);
+    
+    if (taskIds.length === 0) {
+      console.log(chalk.red('❌ No valid task IDs provided.'));
       return;
     }
 
-    const taskStatus = statusData.tasks[taskId.toString()];
-    
-    if (!taskStatus) {
-      console.log(chalk.yellow(`⚠️  Task ${taskId} has no status information.`));
-    }
+    await fs.ensureDir(docsDir);
 
-    const isCompleted = taskStatus && taskStatus.status === 'done';
-    const allSubtasksDone = taskStatus && taskStatus.subtasks 
-      ? Object.values(taskStatus.subtasks).every(status => status === 'done')
-      : false;
+    let successCount = 0;
+    let errorCount = 0;
 
-    if (!isCompleted && !allSubtasksDone) {
-      console.log(chalk.yellow(`⚠️  Task ${taskId} is not completed. Generating partial report...`));
-    }
+    for (const taskId of taskIds) {
+      const task = tasksData.tasks.find(t => t.id === taskId);
 
-    await fs.ensureDir(docsDir);
+      if (!task) {
+        console.log(chalk.red(`❌ Task ${taskId} not found.`));
+        errorCount++;
+        continue;
+      }
 
-    const reportContent = await buildReport(task, taskStatus, targetPath);
-    const reportPath = path.join(docsDir, `task-${taskId}-implementation.md`);
+      const taskStatus = statusData.tasks[taskId.toString()];
+      
+      if (!taskStatus) {
+        console.log(chalk.yellow(`⚠️  Task ${taskId} has no status information.`));
+      }
+
+      const isCompleted = taskStatus && taskStatus.status === 'done';
+      const allSubtasksDone = taskStatus && taskStatus.subtasks 
+        ? Object.values(taskStatus.subtasks).every(status => status === 'done')
+        : false;
+
+      if (!isCompleted && !allSubtasksDone) {
+        console.log(chalk.yellow(`⚠️  Task ${taskId} is not completed. Generating partial report...`));
+      }
 
-    await fs.writeFile(reportPath, reportContent, 'utf8');
+      const reportContent = await buildReport(task, taskStatus, targetPath);
+      const reportPath = path.join(docsDir, `task-${taskId}-implementation.md`);
 
-    console.log(chalk.green(`✅ Report generated: ${reportPath}`));
+      await fs.writeFile(reportPath, reportContent, 'utf8');
+
+      console.log(chalk.green(`✅ Report generated: ${reportPath}`));
+      successCount++;
+    }
+
+    if (taskIds.length > 1) {
+      console.log(chalk.cyan(`\n📊 Generated ${successCount} report(s), ${errorCount} error(s)`));
+    }
 
   } catch (error) {
     console.error(chalk.red('Error generating report:'), error.message);

package/lib/utils.js

@@ -35,11 +35,26 @@ function showNextSteps(targetPath) {
   console.log(chalk.blue('\n  See'), chalk.yellow('.task-flow/README.md'), chalk.blue('for all available commands\n'));
 }
 
+function parseTaskIds(input, allTasks = []) {
+  if (!input || input.trim().toLowerCase() === 'all') {
+    return allTasks.map(t => t.id);
+  }
+  
+  const ids = input.split(',')
+    .map(id => id.trim())
+    .filter(id => id.length > 0)
+    .map(id => parseInt(id))
+    .filter(id => !isNaN(id));
+  
+  return ids;
+}
+
 module.exports = {
   showHeader,
   showSuccess,
   showError,
   showWarning,
   showInfo,
-  showNextSteps
+  showNextSteps,
+  parseTaskIds
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rbin-task-flow",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "AI-powered task management for Claude, Cursor, and Gemini",
   "main": "index.js",
   "bin": {