rbin-task-flow 1.1.0 → 1.2.0

package/.cursor/rules/task_estimate.mdc

@@ -0,0 +1,88 @@
+---
+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 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":
+    - **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 task X` or `task-flow estimate task X`
+  - "estimate task X"
+  - "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"
+  
+  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

@@ -25,6 +25,8 @@ alwaysApply: true
   - `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
 
 - **Workflow Example:**
   ```markdown
@@ -80,7 +82,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 +95,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 +114,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_report.mdc

@@ -0,0 +1,108 @@
+---
+description: Generate implementation reports for completed tasks
+globs: **/*
+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":
+    - **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 task X` or `task-flow report task X`
+  - "generate report for task X"
+  - "create report task X"
+  - "document task X"
+  - "report for task X"
+  - Any variation asking for task report generation
+
+- **Example:**
+  ```
+  User: "task-flow: report task 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_work.mdc

@@ -7,12 +7,12 @@ 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":
+  - 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":
+  - 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
     - **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)
@@ -24,15 +24,15 @@ 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"
+  - "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:**
@@ -118,7 +118,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 +171,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)
 

package/.task-flow/README.md

@@ -1,66 +1,94 @@
-# RBIN Task Flow - Comandos Rápidos
+# RBIN Task Flow - Quick Commands
 
-## 🚀 Comandos Rápidos
+## 🚀 Quick Commands
 
-| Comando | Descrição |
-|---------|-----------|
-| `task-flow: sync` | Sincronização completa: adiciona novas, remove removidas, atualiza modificadas, preserva status |
-| `task-flow: think` | Analisa código e sugere novas tasks |
-| `task-flow: run next X` | Trabalha nas próximas X subtasks (ex: `task-flow: run next 4`) |
-| `task-flow: run task X` | Executa todas as subtasks pendentes da task X (ex: `task-flow: run task 1`) |
-| `task-flow: status` | Mostra status atual das tasks |
-| `task-flow: review` | Revisa tasks marcadas como "done" |
-| `task-flow: refactor` | Refatora código do commit atual |
+| Command | Description |
+|---------|-------------|
+| `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 |
 
-**Veja detalhes completos abaixo ↓**
+**See complete details below ↓**
 
 ---
 
-## Comandos Detalhados
+## Detailed Commands
 
 ### `task-flow: sync`
-Sincronização completa entre `tasks.input.txt` e o sistema:
-- ✅ Adiciona novas tasks do `tasks.input.txt`
-- ✅ Remove tasks que foram removidas do `tasks.input.txt`
-- ✅ Atualiza tasks que foram modificadas no `tasks.input.txt`
-- ✅ Preserva o status (done/pending) das tasks existentes
-- ✅ Sincroniza status entre `status.json` e `tasks.status.md` (garante que estão sempre alinhados)
+Complete synchronization between `tasks.input.txt` and the system:
+- ✅ Adds new tasks from `tasks.input.txt`
+- ✅ Removes tasks that were deleted from `tasks.input.txt`
+- ✅ Updates tasks that were modified in `tasks.input.txt`
+- ✅ Preserves status (done/pending) of existing tasks
+- ✅ Synchronizes status between `status.json` and `tasks.status.md` (ensures they are always aligned)
 
 ### `task-flow: think`
-Analisa código e sugere novas tasks. Pergunta antes de adicionar ao `tasks.input.txt`.
+Analyzes code and suggests new tasks. Asks before adding to `tasks.input.txt`.
 
 ### `task-flow: run next X`
-Trabalha nas próximas X subtasks pendentes em ordem sequencial. Implementa e marca como "done".
+Works on next X pending subtasks in sequential order. Implements and marks as "done".
 
-**Exemplos:**
-- `task-flow: run next 4` → Próximas 4 subtasks
-- `task-flow: run next` → Próxima 1 subtask
+**Examples:**
+- `task-flow: run next 4` → Next 4 subtasks
+- `task-flow: run next` → Next 1 subtask
 
 ### `task-flow: run task X`
-Executa todas as subtasks pendentes de uma task específica. Implementa e marca como "done".
+Executes all pending subtasks of a specific task. Implements and marks as "done".
 
-**⚠️ Verificação de Dependências:**
-- Só executa se todas as tasks anteriores (1, 2, ..., X-1) estiverem completamente concluídas
-- Permite trabalho paralelo por múltiplas IAs sem conflitos
-- Se houver tasks anteriores pendentes, avisa quais precisam ser concluídas primeiro
+**⚠️ Dependency Check:**
+- Only executes if all previous tasks (1, 2, ..., X-1) are completely finished
+- Allows parallel work by multiple AIs without conflicts
+- If there are pending previous tasks, warns which ones need to be completed first
 
-**Exemplos:**
-- `task-flow: run task 1` → Todas as subtasks pendentes da task 1 (sempre pode executar)
-- `task-flow: run task 3` → Só executa se tasks 1 e 2 estiverem completas
+**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: status`
-Mostra o status atual das tasks e subtasks do arquivo `tasks.status.md`.
+Shows current status of tasks and subtasks from the `tasks.status.md` file.
 
 ### `task-flow: review`
-Revisa tasks marcadas como "done" para verificar se estão realmente concluídas.
+Reviews tasks marked as "done" to verify they are actually completed.
 
 ### `task-flow: refactor`
-Refatora código do commit atual. Remove comentários explicativos, melhora código sem mudar funcionalidade.
+Refactors code from current commit. Removes explanatory comments, improves code without changing functionality.
+
+### `task-flow: estimate task X`
+Estimates time required to complete a task 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
+- Estimates in hours and business days
+- Recommendation for management with buffer
+
+**Examples:**
+- `task-flow: estimate task 1` → Shows time estimate for task 1
+
+### `task-flow: report task X`
+Generates a detailed implementation report for a completed task in Markdown format.
+
+**Report includes:**
+- Task overview and completion status
+- List of completed subtasks
+- Files created and modified (detected from git history)
+- Code change summaries with analysis
+- Task creation and completion dates
+
+**Report location:** `.task-flow/docs/task-X-implementation.md`
+
+**Examples:**
+- `task-flow: report task 1` → Generates report for task 1
 
 ---
 
-## Arquivos
+## Files
 
-- `.task-flow/tasks.input.txt` - Edite tasks aqui (formato: `- Task description`)
-- `.task-flow/tasks.status.md` - ⚠️ **NÃO EDITE** - Atualizado automaticamente pela IA
-- `.task-flow/.internal/` - ⚠️ **IGNORE** - Arquivos internos do sistema (não precisa ler nem editar)
+- `.task-flow/tasks.input.txt` - Edit tasks here (format: `- Task description`)
+- `.task-flow/tasks.status.md` - ⚠️ **DO NOT EDIT** - Automatically updated by AI
+- `.task-flow/.internal/` - ⚠️ **IGNORE** - Internal system files (no need to read or edit)

package/.task-flow/screens/example.png.txt

@@ -1,14 +1,14 @@
-# Screenshot de Exemplo
+# Example Screenshot
 
-Este é um arquivo placeholder. Substitua este arquivo por um screenshot real (PNG ou JPG).
+This is a placeholder file. Replace this file with a real screenshot (PNG or JPG).
 
-## Como adicionar screenshots:
+## How to add screenshots:
 
-1. Adicione seus arquivos de imagem (.png ou .jpg) nesta pasta
-2. Use nomes descritivos em kebab-case
-3. O RBIN Task Flow automaticamente detectará e referenciará os screenshots
+1. Add your image files (.png or .jpg) to this folder
+2. Use descriptive names in kebab-case
+3. RBIN Task Flow will automatically detect and reference the screenshots
 
-## Exemplos de nomes:
+## Example names:
 
 - `login_recover_signup.png`
 - `dashboard.png`
@@ -17,8 +17,7 @@ Este é um arquivo placeholder. Substitua este arquivo por um screenshot real (P
 - `prescriptions.png`
 - `medicine.png`
 
-## Referenciar em tasks:
-
-Para referenciar um screenshot específico em uma task, use:
-`task-flow-screen: nome_do_arquivo.png`
+## Reference in tasks:
 
+To reference a specific screenshot in a task, use:
+`task-flow-screen filename.png`

package/.task-flow/tasks.input.txt

@@ -9,14 +9,12 @@
 
 ## Screenshots:
 
-- Adicione seus screenshots na pasta `.task-flow/screens/` (PNG ou JPG)
-- O RBIN Task Flow automaticamente detecta e referencia os screenshots disponíveis ao gerar subtasks
-- Para referenciar um screenshot específico em uma task, use: `task-flow-screen nome_do_arquivo.png`
-- Exemplo: `- Criar tela de login task-flow-screen login.png`
+- Add your screenshots to the `.task-flow/screens/` folder (PNG or JPG)
+- RBIN Task Flow automatically detects and references available screenshots when generating subtasks
+- To reference a specific screenshot in a task, use: `task-flow-screen filename.png`
+- Example: `- Create login screen task-flow-screen login.png`
 
 ## Tasks:
 
-- Criar sistema de autenticação (login, registro, recuperação de senha)
-- Implementar dashboard com métricas principais
-- CRUD completo de usuários
-- Sistema de notificações
+- First task
+- Second task

package/.task-flow/tasks.status.md

@@ -1,16 +1,16 @@
 # 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**: 0
-- 📝 **Subtasks Restantes**: 0
+- ✅ **Completed Tasks**: 0
+- ⏳ **Tasks in Progress**: 0
+- 📝 **Remaining Subtasks**: 0
 
 **Tasks:**
-- ⏳ Task 1: First task (0 subtasks restantes de 0)
-- ⏳ Task 2: Second task (0 subtasks restantes de 0)
+- ⏳ Task 1: First task (0 remaining subtasks out of 0)
+- ⏳ Task 2: Second task (0 remaining subtasks out of 0)
 
 ---
 

package/CLAUDE.md

@@ -22,6 +22,8 @@ This project uses RBIN Task Flow for task management:
   - `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
 - **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

@@ -22,6 +22,8 @@ This project uses RBIN Task Flow for task management:
   - `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
 - **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

@@ -74,6 +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
 ```
 
 ### Comandos da IA - Por Que Usar?
@@ -89,6 +91,8 @@ Após inicializar, use estes comandos na IA (Cursor/Claude/Gemini) para gerencia
 | `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 |
 
 **Fluxo típico:**
 
@@ -433,6 +437,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
 ```
 
 ### AI Commands - Why Use Them?
@@ -448,6 +454,8 @@ After initializing, use these commands in your AI (Cursor/Claude/Gemini) to auto
 | `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 |
 
 **Typical workflow:**