rbin-task-flow 1.0.0

package/.cursor/rules/task_analysis.mdc

@@ -0,0 +1,190 @@
+---
+description: Sync .task-flow-tasks.txt with task system and analyze codebase for new tasks
+globs: **/*
+alwaysApply: true
+---
+
+- **Task Sync - Complete Synchronization:**
+  - **FASTEST FORMAT**: `task-flow: sync` → Complete sync of tasks.input.txt with system
+  - When user says "task-flow: sync" or "task-flow sync":
+    - **READ**: `.task-flow/tasks.input.txt` to find all tasks
+    - **READ**: `.task-flow/.internal/tasks.json` and `.task-flow/.internal/status.json` to see existing tasks and their status
+    - **SYNC**: Fully synchronize tasks and status between tasks.input.txt and system files
+    - **PRESERVE**: Keep status of existing tasks (done/pending/in_progress) when possible
+
+- **Complete Sync Process:**
+  1. **Read files**:
+     - Read `.task-flow/tasks.input.txt` (all tasks from user input)
+     - Read `.task-flow/.internal/tasks.json` (existing generated tasks)
+     - Read `.task-flow/.internal/status.json` (existing task status)
+  
+  2. **Compare and identify changes**:
+     - **New tasks**: Tasks in tasks.input.txt that don't exist in tasks.json (by comparing `originalRequest`)
+     - **Removed tasks**: Tasks in tasks.json that don't exist in tasks.input.txt
+     - **Modified tasks**: Tasks that exist in both but `originalRequest` changed (text modified)
+     - **Unchanged tasks**: Tasks that exist in both with same `originalRequest`
+  
+  3. **Process new tasks**:
+     - For each new task in tasks.input.txt:
+       - Generate subtasks following [task_generation.mdc](mdc:.cursor/rules/task_generation.mdc) rules
+       - Add to tasks.json with sequential ID
+       - Add to status.json with "pending" status for task and all subtasks
+       - Add to tasks.status.md with `- [ ]` format
+  
+  4. **Process removed tasks**:
+     - For each task in tasks.json not found in tasks.input.txt:
+       - Remove from tasks.json
+       - Remove from status.json
+       - Remove from tasks.status.md
+  
+  5. **Process modified tasks**:
+     - For each task where `originalRequest` changed:
+       - Update title and description in tasks.json based on new text
+       - Regenerate subtasks (following task_generation.mdc rules)
+       - **PRESERVE STATUS**: Keep existing status from status.json (task and subtasks)
+       - Update tasks.status.md with new subtasks but preserve status marks (`- [x]` for done, `- [ ]` for pending)
+  
+  6. **Process unchanged tasks**:
+     - Keep tasks.json unchanged
+     - Keep status.json unchanged
+     - Keep tasks.status.md unchanged (preserve all status marks)
+  
+  7. **Synchronize status between files**:
+     - Read current `status.json` to get all existing statuses
+     - Read current `tasks.status.md` to get status marks
+     - **Compare and sync**: Ensure `status.json` and `tasks.status.md` are perfectly aligned
+     - If there are inconsistencies:
+       - Use `status.json` as source of truth for status values
+       - Update `tasks.status.md` to match `status.json` (convert "done" → `- [x]`, "pending" → `- [ ]`)
+       - Ensure both files reflect the same status for all tasks and subtasks
+  
+  8. **Rebuild files**:
+     - Rebuild tasks.json with all tasks in correct order (matching tasks.input.txt order)
+     - Rebuild status.json preserving all existing statuses (or updating if needed)
+     - Rebuild tasks.status.md with all tasks and correct status marks (synchronized with status.json)
+     - **ALWAYS regenerate summary section** at the top of tasks.status.md:
+       - Count completed tasks (all subtasks done)
+       - Count in-progress tasks (some subtasks done)
+       - Total remaining subtasks
+       - List each task with status and remaining subtasks count
+  
+  **Critical Rules:**
+  - ✅ Always preserve status of existing tasks/subtasks when possible
+  - ✅ **SYNC STATUS**: Ensure `status.json` and `tasks.status.md` are always synchronized
+  - ✅ Use `status.json` as source of truth, update `tasks.status.md` to match
+  - ✅ When regenerating subtasks for modified tasks, try to match existing subtasks by title/description
+  - ✅ If subtasks change significantly, mark new ones as "pending" but keep old ones as "done" if they were done
+  - ✅ Maintain sequential task IDs (1, 2, 3...) matching order in tasks.input.txt
+  - ✅ When removing tasks, remove all associated data (subtasks, status)
+  - ✅ After any status change, update BOTH `status.json` and `tasks.status.md` to keep them in sync
+
+- **Task Analysis - Suggest New Tasks:**
+  - **FAST FORMAT**: `task-flow: think` → Analyze codebase and suggest new tasks
+  - When user says "task-flow: think", "analyze if there are new tasks to create", "check for new tasks", or "suggest tasks":
+    - **ANALYZE**: Current codebase, recent changes, TODOs, FIXMEs, and project structure
+    - **SUGGEST**: New tasks that should be added to `.task-flow/tasks.input.txt`
+    - **FORMAT**: Use RBIN Task Flow format: `- Task description` (no [ ] needed)
+    - **ASK**: Always ask user if they want to add the suggested tasks
+    - **ONLY ACTION**: If user confirms, add tasks to `.task-flow/tasks.input.txt` - nothing else
+    - **DON'T**: Automatically add tasks without confirmation
+
+- **Analysis Process:**
+  1. **Read existing tasks**: Check `.task-flow/tasks.input.txt` to see what's already planned
+  2. **Analyze codebase**: Look for:
+     - TODO/FIXME comments in code
+     - Missing tests or incomplete test coverage
+     - Incomplete features or half-implemented functionality
+     - Code quality issues (refactoring opportunities)
+     - Missing documentation
+     - Security improvements needed
+     - Performance optimizations
+     - Missing error handling
+  3. **Check recent changes**: Review git history or recent file modifications
+  4. **Identify gaps**: Compare what exists vs what should exist
+  5. **Suggest tasks**: Propose specific, actionable tasks
+
+- **Task Suggestion Format:**
+  ```markdown
+  ## Suggested Tasks for tasks.input.txt
+  
+  - Add unit tests for UserService
+  - Implement error handling in API endpoints
+  - Refactor authentication middleware
+  - Add API documentation with Swagger
+  - Optimize database queries in ReportService
+  ```
+
+- **When User Confirms:**
+  - If user wants to add suggested tasks:
+    - Read `.task-flow/tasks.input.txt`
+    - Append new tasks (maintaining existing format)
+    - Don't remove or modify existing tasks
+    - Keep one task per line with `- ` format (no [ ] needed)
+
+- **Natural Language Phrases:**
+  - **FAST FORMAT**: `task-flow: sync` or `task-flow sync` → Sync tasks.input.txt with system
+  - **FAST FORMAT**: `task-flow: think` or `task-flow think` → Analyze and suggest new tasks
+  - "sync tasks" → Same as task-flow: sync
+  - "sincronizar tasks" → Same as task-flow: sync
+  - "analise se tem tasks novas para criar" → Same as task-flow: think
+  - "check for new tasks" → Same as task-flow: think
+  - "suggest tasks" → Same as task-flow: think
+  - "what tasks should I add?" → Same as task-flow: think
+  - "analyze codebase for tasks" → Same as task-flow: think
+  - "find missing tasks" → Same as task-flow: think
+
+- **Example Workflows:**
+  ```
+  User: "task-flow: sync"
+  
+  AI Action (Complete Sync):
+  1. Read .task-flow/tasks.input.txt:
+     - Task 1: "Create auth system" (exists, unchanged)
+     - Task 2: "Add database" (MODIFIED - was "Setup database")
+     - Task 3: "New feature" (NEW - not in tasks.json)
+     - Task 4: REMOVED (was in tasks.json, not in tasks.input.txt)
+  
+  2. Read .task-flow/.internal/tasks.json:
+     - Task 1: exists, status: done
+     - Task 2: exists, status: in_progress (subtask 2.1 done, 2.2 pending)
+     - Task 4: exists, status: pending
+  
+  3. Process changes:
+     - Task 1: Unchanged → Keep as is, preserve status "done"
+     - Task 2: Modified → Update title/description, regenerate subtasks, PRESERVE status (2.1 done, 2.2 pending)
+     - Task 3: New → Generate subtasks, add with status "pending"
+     - Task 4: Removed → Remove from all files
+  
+  4. Sync status between files:
+     - Compare status.json and tasks.status.md
+     - Ensure both reflect same status (done → `- [x]`, pending → `- [ ]`)
+     - Update tasks.status.md to match status.json if inconsistencies found
+  
+  5. Rebuild files:
+     - tasks.json: Tasks 1, 2 (updated), 3 (new) - in order
+     - status.json: Preserve Task 1 (done), Task 2 (in_progress with preserved subtask status), Task 3 (pending)
+     - tasks.status.md: Reflect all changes with correct status marks, synchronized with status.json
+  
+  User: "task-flow: think"
+  AI Action (Analyze):
+  1. Read .task-flow/tasks/tasks.input.txt (existing tasks)
+  2. Analyze codebase for TODOs, missing features, etc.
+  3. Suggest new tasks:
+     - Add input validation to login endpoint
+     - Create migration for user preferences table
+     - Write tests for PaymentService
+  4. Ask: "Do you want to add these tasks to tasks.input.txt? [y/N]"
+  5. If user confirms (y): Add tasks to tasks.input.txt
+  6. If user declines (n): Do nothing, just show suggestions
+  
+  User: "analise se tem tasks novas para criar no task flow"
+  AI Action: Same as task-flow: think
+  ```
+
+- **Integration:**
+  - Works with [task_generation.mdc](mdc:.cursor/rules/task_generation.mdc) - after adding tasks, user can generate subtasks
+  - Follows [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) workflow
+  - Respects [git_control.mdc](mdc:.cursor/rules/git_control.mdc) - never commit automatically
+
+- **Principle:**
+  > **Analyze the codebase intelligently to suggest meaningful tasks. Don't add tasks automatically - let the user review and decide. Focus on actionable, specific tasks that improve the project.**

package/.cursor/rules/task_execution.mdc

@@ -0,0 +1,124 @@
+---
+description: Task management workflow with RBIN Task Flow
+globs: **/*
+alwaysApply: true
+---
+
+- **RBIN Task Flow - AI-Powered Task Management:**
+  - This project uses **RBIN Task Flow** for task tracking and management
+  - **IMPORTANT**: When user mentions "task flow", they always refer to **RBIN Task Flow**
+  - Tasks are defined in plain text: `.task-flow/tasks.input.txt`
+  - Task data is stored in: `.task-flow/.internal/` (do not edit directly - internal system files)
+  - Task files: `.internal/tasks.json` (definitions), `.internal/status.json` (progress tracking), and `tasks.status.md` (human-readable status)
+
+- **Task Definition:**
+  - Edit `.task-flow/tasks.input.txt` to define tasks
+  - Use simple format: `- Task description` (no [ ] needed)
+  - AI will generate detailed subtasks from descriptions
+  - Keep descriptions clear and actionable
+
+- **AI Commands:**
+  - `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: status` - Show current task status
+  - `task-flow: review` - Review completed tasks
+  - `task-flow: refactor` - Refactor code from current commit
+
+- **Workflow Example:**
+  ```markdown
+  1. Add tasks to `.task-flow/tasks.input.txt`:
+     - Implement user authentication
+     - Add database migrations
+     - Create API endpoints
+
+  2. Use AI command: task-flow: sync (generates detailed subtasks)
+  3. Use AI command: task-flow: status (view all tasks and progress)
+  4. Use AI command: task-flow: run next X (work on next X subtasks)
+  5. Tasks are automatically marked as done when completed
+  6. Use AI command: task-flow: review (verify completed tasks)
+  ```
+
+- **Commit Workflow:**
+  - After completing tasks, follow [commit_practices.mdc](mdc:.cursor/rules/commit_practices.mdc)
+  - Never execute git commands directly - follow [git_control.mdc](mdc:.cursor/rules/git_control.mdc)
+  - Suggest commits with descriptive messages referencing completed tasks
+
+- **Commit Message Format:**
+  ```bash
+  git add .
+  git commit -m "feat(module): Complete tasks from RBIN Task Flow
+
+  - Task 1: [description]
+  - Task 2: [description]
+
+  Completed via RBIN Task Flow"
+  ```
+
+- **Integration with Other Rules:**
+  - Follow [commit_practices.mdc](mdc:.cursor/rules/commit_practices.mdc) for commit format
+  - Follow [git_control.mdc](mdc:.cursor/rules/git_control.mdc) - NEVER execute git, only suggest
+  - See `CLAUDE.md` for complete RBIN Task Flow documentation
+  - See `README.md` for installation and setup instructions
+
+- **Best Practices:**
+  - Keep task descriptions concise but clear
+  - Let AI generate detailed implementation steps
+  - Review generated subtasks before starting work
+  - Update task status regularly through the menu
+  - Commit work frequently referencing task progress
+
+- **Task Generation:**
+  - See [task_generation.mdc](mdc:.cursor/rules/task_generation.mdc) for direct task generation rules
+  - When generating tasks, be efficient: read tasks.input.txt, generate JSONs, save files
+  - No need to explore codebase or read other files
+
+- **Task Analysis:**
+  - See [task_analysis.mdc](mdc:.cursor/rules/task_analysis.mdc) for analyzing codebase to suggest new tasks
+  - When user asks to analyze for new tasks, intelligently scan codebase and suggest additions
+
+- **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
+
+- **Task Review:**
+  - See [task_review.mdc](mdc:.cursor/rules/task_review.mdc) for reviewing completed tasks
+  - When user says "task-flow: review", verify if completed tasks are actually done
+
+- **Task Refactor:**
+  - See [task_refactor.mdc](mdc:.cursor/rules/task_refactor.mdc) for refactoring code from current commit
+  - When user says "task-flow: refactor", improve code quality without changing functionality
+
+- **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"
+    - "task flow subtasks"
+    - Any variation mentioning "task flow" + "subtasks"
+
+- **When User Asks to Work on Subtasks:**
+  - **STEP 1**: Read `.task-flow/.internal/tasks.json` and `.task-flow/.internal/status.json`
+  - **STEP 2**: Find next X pending subtasks in sequential order:
+    - Order: Task 1 → Subtask 1, 2, 3... → Task 2 → Subtask 1, 2, 3...
+    - Only count subtasks with status "pending"
+    - Skip subtasks already "done" or "in_progress"
+  - **STEP 3**: For each subtask:
+    - Read instructions from `.internal/tasks.json`
+    - Implement following step-by-step instructions
+    - After completion: Update `.internal/status.json` (subtask → "done") and `tasks.status.md` (mark as `- [x]`)
+  - **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"
+  - 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`
+    2. Find first 3 pending subtasks (e.g., 1.1, 1.2, 1.3 if all pending)
+    3. Work on 1.1 → mark done in .internal/status.json and tasks.status.md → work on 1.2 → mark done → work on 1.3 → mark done
+    4. Update both .internal/status.json and tasks.status.md after each completion
+
+- **Principle:**
+  > **Use RBIN Task Flow's AI commands for all task management. Define tasks in plain text, let AI generate details, track progress through tasks.status.md, and commit work with descriptive messages.**

package/.cursor/rules/task_generation.mdc

@@ -0,0 +1,118 @@
+---
+description: Direct task generation from tasks.input.txt - be efficient and direct
+globs: .task-flow/tasks.input.txt, .task-flow/.internal/tasks.json, .task-flow/.internal/status.json
+alwaysApply: true
+---
+
+- **Task Generation - Direct and Efficient:**
+  - When user asks to "Read tasks.input.txt and generate detailed subtasks updating task status":
+    - **READ ONLY**: `.task-flow/tasks.input.txt`
+    - **GENERATE**: Two JSON files and one markdown file with the exact structure below
+    - **SAVE**: All files to `.task-flow/`
+    - **DON'T**: Read other files, check existing JSONs, explore codebase, or ask questions
+
+- **Required Actions:**
+  1. Read `tasks.input.txt` (ignore comments, only process lines starting with `- `)
+  2. For each task line, create a task with sequential ID starting at 1
+  3. Generate 3-8 subtasks per task with:
+     - Clear title
+     - Brief description
+     - Step-by-step instructions (3-5 steps)
+  4. Create `.task-flow/.internal/tasks.json` with structure below
+  5. Create `.task-flow/.internal/status.json` with all tasks/subtasks as "pending"
+  6. Create `.task-flow/tasks.status.md` with all tasks and subtasks marked as `- [ ]` (pending)
+  7. Write all three files immediately
+
+- **tasks.json Structure:**
+  ```json
+  {
+    "tasks": [
+      {
+        "id": 1,
+        "title": "Task Title",
+        "description": "Task description",
+        "originalRequest": "- Task description from tasks.input.txt",
+        "createdAt": "ISO 8601 timestamp",
+        "subtasks": [
+          {
+            "id": 1,
+            "title": "Subtask Title",
+            "description": "What this subtask does",
+            "instructions": "Step 1: Action\nStep 2: Action\nStep 3: Verify"
+          }
+        ]
+      }
+    ]
+  }
+  ```
+
+- **status.json Structure:**
+  ```json
+  {
+    "tasks": {
+      "1": {
+        "status": "pending",
+        "subtasks": {
+          "1": "pending",
+          "2": "pending"
+        }
+      }
+    }
+  }
+  ```
+
+- **tasks.status.md Structure:**
+  ```markdown
+  # Task Status
+
+  <!-- ⚠️ AVISO: Este arquivo é atualizado automaticamente pela IA. NÃO edite manualmente. -->
+
+  ## 📊 Resumo
+
+  - ✅ **Tasks Completas**: 0
+  - ⏳ **Tasks em Andamento**: 2
+  - 📝 **Subtasks Restantes**: 8
+
+  **Tasks:**
+  - ✅ Task 1: First task (completa)
+  - ⏳ Task 2: Second task (3 subtasks restantes de 5)
+
+  ---
+
+  ## Tasks
+
+  - [x] First task
+
+    - [x] Subtask Title 1
+    - [x] Subtask Title 2
+
+  - [ ] Second task
+
+    - [x] Subtask Title 1
+    - [ ] Subtask Title 2
+    - [ ] 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
+  - 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
+
+- **Example:**
+  - Input (`tasks.input.txt`): `- Create authentication system`
+  - Output: Task with ID 1, 5 subtasks (setup database, create models, implement login, add JWT, test)
+
+- **Critical Rules:**
+  - ✅ Be direct: Read → Generate → Save
+  - ✅ No unnecessary file reads
+  - ✅ No exploration of codebase
+  - ✅ No questions - just generate
+  - ✅ Use current timestamp for `createdAt`
+  - ✅ All statuses start as "pending"
+  - ✅ Subtask IDs are sequential per task (1, 2, 3...)
+
+- **Principle:**
+  > **When generating tasks, be fast and direct. Read tasks.input.txt, generate JSONs and tasks.status.md with proper structure, save files. No exploration needed.**

package/.cursor/rules/task_refactor.mdc

@@ -0,0 +1,84 @@
+---
+description: Refactor code from current commit tasks without changing functionality
+globs: **/*
+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":
+    - **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)
+    - **PRESERVE**: Only separation comments in format: `// ────────────────────────────────`
+    - **IMPROVE**: Code structure, naming, organization, but keep behavior identical
+
+- **Refactoring Rules:**
+  1. **No Functional Changes**: Code must behave exactly the same
+  2. **Remove Comments**: Remove all explanatory comments
+  3. **Keep Separation Comments**: Preserve comments that separate code blocks:
+     ```typescript
+     // ────────────────────────────────
+     // Section Name
+     // ────────────────────────────────
+     ```
+  4. **Improve Code Quality**:
+     - Better variable/function names
+     - Extract repeated code
+     - Improve code organization
+     - Better error handling
+     - Remove dead code
+     - Simplify complex logic
+  5. **Follow Project Rules**: Respect [code_comments.mdc](mdc:.cursor/rules/code_comments.mdc)
+
+- **Comment Removal:**
+  - ❌ Remove: `// This function does X`
+  - ❌ Remove: `// Check if user exists`
+  - ❌ Remove: `// TODO: fix this later`
+  - ✅ Keep: `// ────────────────────────────────`
+  - ✅ Keep: `// ────────────────────────────────\n// Section Name\n// ────────────────────────────────`
+
+- **Process:**
+  1. Identify files changed in current commit/staged changes
+  2. Read each file
+  3. Refactor:
+     - Remove explanatory comments
+     - Improve code structure
+     - Better naming
+     - Extract functions if needed
+     - Simplify logic
+  4. Verify: Code still works the same way
+  5. Show summary of changes
+
+- **Natural Language Phrases:**
+  - **FAST FORMAT**: `task-flow: refactor` or `task-flow refactor`
+  - "refactor current tasks"
+  - "refactor code from commit"
+  - "improve code quality"
+  - "clean up code"
+  - Any variation asking to refactor/improve code
+
+- **Example:**
+  ```
+  User: "task-flow: refactor"
+  
+  AI Action:
+  1. Check git diff or staged files
+  2. Identify files changed in current commit
+  3. For each file:
+     - Remove explanatory comments
+     - Improve code structure
+     - Better naming
+     - Simplify logic
+  4. Preserve separation comments
+  5. Verify functionality unchanged
+  6. Show refactoring summary
+  ```
+
+- **Integration:**
+  - Follows [code_comments.mdc](mdc:.cursor/rules/code_comments.mdc) - comment removal rules
+  - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) workflow
+  - Respects [git_control.mdc](mdc:.cursor/rules/git_control.mdc) - never commit automatically
+
+- **Principle:**
+  > **Refactor code to improve quality without changing behavior. Remove explanatory comments, keep only separation comments, improve structure and naming. Code must work exactly the same.**

package/.cursor/rules/task_review.mdc

@@ -0,0 +1,75 @@
+---
+description: Review completed tasks to verify they are actually done or erroneously marked
+globs: **/*
+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":
+    - **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
+    - **REPORT**: List tasks that are erroneously marked as done
+    - **SUGGEST**: Mark incorrectly completed tasks back to "pending" or "in_progress"
+
+- **Review Process:**
+  1. Read `.task-flow/.internal/tasks.json` to get all task definitions
+  2. Read `.task-flow/.internal/status.json` to get completion status
+  3. For each task/subtask marked as "done":
+     - Check if the implementation exists in codebase
+     - Verify if implementation matches the task requirements
+     - Check if tests exist (if required by task)
+     - Verify if documentation is updated (if required)
+  4. Identify discrepancies:
+     - Task marked "done" but code doesn't exist
+     - Task marked "done" but implementation incomplete
+     - Task marked "done" but tests missing
+     - Task marked "done" but requirements not met
+  5. Report findings and ask user if they want to correct status
+
+- **Review Report Format:**
+  ```
+  📋 Task Review Results:
+  
+  ✅ Correctly Completed:
+  - Task 1.2: User authentication (verified)
+  - Task 2.1: Database migration (verified)
+  
+  ⚠️  Erroneously Marked as Done:
+  - Task 1.3: API endpoint - Code exists but tests missing
+  - Task 2.4: Error handling - Implementation incomplete
+  
+  Do you want to update status for erroneous tasks? [y/N]
+  ```
+
+- **Natural Language Phrases:**
+  - **FAST FORMAT**: `task-flow: review` or `task-flow review`
+  - "review completed tasks"
+  - "verify done tasks"
+  - "check if tasks are really done"
+  - "review task status"
+  - Any variation asking to review/verify completed tasks
+
+- **Example:**
+  ```
+  User: "task-flow: review"
+  
+  AI Action:
+  1. Read tasks.json and status.json
+  2. Find all "done" tasks/subtasks
+  3. Verify each one:
+     - Check if files exist
+     - Check if code matches requirements
+     - Check if tests exist
+  4. Report findings
+  5. Ask if user wants to correct status
+  6. If confirmed, update status.json
+  ```
+
+- **Integration:**
+  - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) workflow
+  - Respects [git_control.mdc](mdc:.cursor/rules/git_control.mdc) - never commit automatically
+
+- **Principle:**
+  > **Review completed tasks to ensure quality. Verify that "done" means actually done, not just marked. Help maintain accurate task status.**

package/.cursor/rules/task_status.mdc

@@ -0,0 +1,45 @@
+---
+description: Show task status from tasks.status.md - simple and direct
+globs: **/*
+alwaysApply: true
+---
+
+- **Task Status - Show Current Status:**
+  - **FAST FORMAT**: `task-flow: status` → Show current task status
+  - When user says "task-flow: status" or "task-flow status":
+    - **READ**: `.task-flow/tasks.status.md`
+    - **DISPLAY**: Show the current status of all tasks and subtasks
+    - **FORMAT**: Display in a clear, readable format showing done/pending tasks
+
+- **Status Display:**
+  - Read `.task-flow/tasks.status.md` file
+  - Show tasks marked as `- [x]` (done) and `- [ ]` (pending)
+  - Display subtasks with their status
+  - Show progress summary if available
+
+- **Natural Language Phrases:**
+  - **FAST FORMAT**: `task-flow: status` or `task-flow status`
+  - "show task status"
+  - "status das tasks"
+  - "ver status"
+  - "task status"
+  - Any variation asking to show/display task status
+
+- **Example:**
+  ```
+  User: "task-flow: status"
+  
+  AI Action:
+  1. Read .task-flow/tasks.status.md
+  2. Display current status showing:
+     - Tasks marked as done [x]
+     - Tasks marked as pending [ ]
+     - Subtasks status
+  ```
+
+- **Integration:**
+  - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) workflow
+  - Status is maintained in tasks.status.md file
+
+- **Principle:**
+  > **Show task status quickly and clearly. Read tasks.status.md and display in a readable format.**