rbin-task-flow 1.2.0 → 1.4.0

package/.cursor/rules/git_control.mdc

@@ -5,11 +5,12 @@ alwaysApply: true
 ---
 
 - **General Command Permission:**
-  - **✅ CAN execute** any system command without asking
-  - **✅ CAN execute** npm, yarn, pnpm, docker, etc without confirmation
-  - **✅ CAN execute** scripts, tests, linters, formatters without asking
+  - **✅ CAN execute** any system command without asking (Claude may run commands without asking for approval)
+  - **✅ CAN execute** npm, yarn, pnpm, docker, scripts, tests, linters, formatters without confirmation
   - **✅ DON'T need to ask** before executing simple or common commands
-  - **❌ ONLY EXCEPTION**: `git` commands that modify the repository
+  - **❌ EXCEPTIONS** (do not execute without user approval):
+    - **Git**: `git` commands that modify the repository (add, commit, push, pull, merge, checkout, etc.)
+    - **Cloud/remote resources**: Commands that run or connect to cloud/remote resources (e.g. database connections, cloud CLI that provisions resources, migrations against remote DB, deploying to production)
 
 - **Read Commands - Automatic Execution:**
   - **✅ ALWAYS execute without asking** commands that only read information:
@@ -85,4 +86,4 @@ alwaysApply: true
   - RBIN Task Flow workflow should not include automatic git execution
 
 - **Fundamental Principle:**
-  > **User has complete control over the Git repository. AI can execute any system command without asking, EXCEPT git commands. For git, only suggests, analyzes, and informs. Never modifies git state.**
+  > **Claude may execute commands without asking, except: (1) git commands that modify the repository, and (2) commands that run cloud/remote resources (e.g. database, cloud provisioning). For those, only suggest or ask for approval.**

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

@@ -6,6 +6,7 @@ alwaysApply: true
 
 - **RBIN Task Flow - AI-Powered Task Management:**
   - This project uses **RBIN Task Flow** for task tracking and management
+  - **Models**: Claude and Cursor use the **default model** of each environment. Do not specify or require a particular model.
   - **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)
@@ -21,12 +22,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_generation.mdc

@@ -7,31 +7,32 @@ alwaysApply: true
 - **Task Generation - Direct and Efficient:**
   - When user asks to "Read tasks.input.txt and generate detailed subtasks updating task status":
     - **READ**: `.task-flow/tasks.input.txt` (only process lines starting with `- `)
-    - **READ**: `.task-flow/screens/` directory to list available screenshots (ALWAYS check this directory)
+    - **READ**: `.task-flow/contexts/` directory to list available context files (ALWAYS check this directory)
     - **GENERATE**: Two JSON files and one markdown file with the exact structure below
     - **SAVE**: All files to `.task-flow/`
     - **DON'T**: Check existing JSONs, explore codebase, or ask questions
 
-- **Screenshot Reference System:**
-  - **AUTOMATIC**: Always check `.task-flow/screens/` directory for available screenshots (PNG, JPG files)
-  - **NO LISTING NEEDED**: Don't require screenshots to be listed in tasks.input.txt - always scan the directory
-  - **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: "Visual reference: `.task-flow/screens/filename.png`"
+- **Context Reference System:**
+  - **PURPOSE**: `.task-flow/contexts/` is for AIs to consult reference material (any type: .md, .txt, .png, .jpg, .json, etc.) when generating and working on tasks
+  - **AUTOMATIC**: Always check `.task-flow/contexts/` directory for available context files (all file types)
+  - **NO LISTING NEEDED**: Don't require context files to be listed in tasks.input.txt - always scan the directory
+  - **AUTOMATIC MATCHING**: Match context files to tasks by keywords (e.g., "login" → `login-mockup.png` or `api-login.md`, "dashboard" → `dashboard.png`)
+  - **SPECIFIC REFERENCE**: If task contains `task-flow-screen nome_arquivo.ext`, reference that file from `.task-flow/contexts/`
+  - **PATH ALWAYS**: `task-flow-screen` always references files in `.task-flow/contexts/`
+  - **INCLUDE**: In subtask instructions, add the reference: "Context/reference: `.task-flow/contexts/filename.ext`" (or "Visual reference" for images)
 
 - **Required Actions:**
   1. Read `tasks.input.txt`:
      - Process task lines (only process lines starting with `- `)
      - Check for `task-flow-screen nome_do_arquivo.png` markers in task descriptions
-  2. **ALWAYS** list available screenshots from `.task-flow/screens/` directory (PNG, JPG files)
+  2. **ALWAYS** list available context files from `.task-flow/contexts/` directory (all file types: .md, .txt, .png, .jpg, .json, etc.)
   3. For each task line, create a task with sequential ID starting at 1
   4. Generate 3-8 subtasks per task with:
      - Clear title
      - Brief description
      - Step-by-step instructions (3-5 steps)
-     - **AUTOMATIC**: Include relevant screenshot references when applicable (match by keywords)
-     - **SPECIFIC**: If task has `task-flow-screen nome_do_arquivo.png`, reference that specific screenshot from `.task-flow/screens/`
+     - **AUTOMATIC**: Include relevant context references when applicable (match by keywords)
+     - **SPECIFIC**: If task has `task-flow-screen nome_arquivo.ext`, reference that file from `.task-flow/contexts/`
   5. Create `.task-flow/.internal/tasks.json` with structure below
   6. Create `.task-flow/.internal/status.json` with all tasks/subtasks as "pending"
   7. Create `.task-flow/tasks.status.md` with all tasks and subtasks marked as `- [ ]` (pending)
@@ -117,26 +118,27 @@ alwaysApply: true
 
 - **Example:**
   - Input (`tasks.input.txt`): `- Create authentication system`
-  - 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: "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
+  - Context files available: `login_recover_signup.png`
+  - Output: Task with ID 1, 5 subtasks with context references:
+    - Subtask 1: "Setup database schema" (no context)
+    - Subtask 2: "Create login form" → Instructions include: "Visual reference: `.task-flow/contexts/login_recover_signup.png`"
+    - Subtask 3: "Implement registration" → Instructions include context reference
+    - Subtask 4: "Add JWT authentication" (no context)
+    - Subtask 5: "Test authentication flow" → Instructions include context reference
   
-- **Screenshot Reference Examples:**
-  - 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
+- **Context Reference Examples:**
+  - Task: `- Dentist authentication system` → Automatically matches and references `login_recover_signup.png` from `.task-flow/contexts/`
+  - Task: `- Basic dashboard with structure task-flow-screen dashboard.png` → References specific `.task-flow/contexts/dashboard.png`
+  - Task: `- Complete patient CRUD` → Automatically matches and references `patient.png` and `patient_profile.png` from `.task-flow/contexts/` if available
+  - **IMPORTANT**: `task-flow-screen` always references files in `.task-flow/contexts/` - no need to specify full path
+  - **FILE TYPES**: Contexts can be any type (images, markdown, text, JSON, etc.) for the AI to read and use when working on tasks
 
 - **Critical Rules:**
   - ✅ Be direct: Read → Generate → Save
-  - ✅ **ALWAYS** check `.task-flow/screens/` directory for available screenshots (automatic, no need to list in tasks.input.txt)
-  - ✅ Automatically match and reference relevant screenshots in subtask instructions based on keywords
-  - ✅ Support `task-flow-screen nome_do_arquivo.png` format - always references `.task-flow/screens/nome_do_arquivo.png`
-  - ✅ No exploration of codebase beyond screenshots directory
+  - ✅ **ALWAYS** check `.task-flow/contexts/` directory for available context files (automatic, no need to list in tasks.input.txt)
+  - ✅ Automatically match and reference relevant context files in subtask instructions based on keywords
+  - ✅ Support `task-flow-screen nome_do_arquivo.png` format - always references `.task-flow/contexts/nome_do_arquivo.png`
+  - ✅ No exploration of codebase beyond `.task-flow/contexts/` directory
   - ✅ No questions - just generate
   - ✅ Use current timestamp for `createdAt`
   - ✅ All statuses start as "pending"

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`
@@ -56,8 +62,8 @@ alwaysApply: true
      - Skip "done" and "in_progress" subtasks
   3. **For each subtask**:
      - Read full instructions from `tasks.json`
-     - **CHECK**: If instructions mention screenshot references (`.task-flow/screens/...`), verify screenshot exists
-     - **REFERENCE**: Use screenshots as visual reference when implementing UI-related subtasks
+     - **CHECK**: If instructions mention context references (`.task-flow/contexts/...`), verify the context file exists
+     - **CONSULT**: Read and use context files from `.task-flow/contexts/` when implementing (images, .md, .txt, .json, etc. – any type that helps the task)
      - Implement following step-by-step instructions
      - Test/verify implementation
      - Update `status.json` to mark as "done"
@@ -85,8 +91,8 @@ alwaysApply: true
      - Skip "done" and "in_progress" subtasks
   4. **For each subtask** (only if dependency check passed):
      - Read full instructions from `tasks.json`
-     - **CHECK**: If instructions mention screenshot references (`.task-flow/screens/...`), verify screenshot exists
-     - **REFERENCE**: Use screenshots as visual reference when implementing UI-related subtasks
+     - **CHECK**: If instructions mention context references (`.task-flow/contexts/...`), verify the context file exists
+     - **CONSULT**: Read and use context files from `.task-flow/contexts/` when implementing (images, .md, .txt, .json, etc. – any type that helps the task)
      - Implement following step-by-step instructions
      - Test/verify implementation
      - Update `status.json` to mark as "done"
@@ -200,15 +206,16 @@ alwaysApply: true
   - If file doesn't exist → create it
   - If instructions unclear → ask for clarification (but try to infer first)
 
-- **Screenshot Support:**
-  - **AUTOMATIC**: When implementing subtasks, check if instructions reference screenshots
-  - **REFERENCE**: Use screenshots from `.task-flow/screens/` as visual reference for UI implementation
-  - **MATCHING**: Match screenshot references mentioned in subtask instructions
-  - **NO NEED**: User doesn't need to explicitly mention screenshots - they're automatically considered
+- **Context Support:**
+  - **PURPOSE**: `.task-flow/contexts/` holds reference material (any file type) for the AI to consult when working on tasks
+  - **AUTOMATIC**: When implementing subtasks, check if instructions reference context files
+  - **CONSULT**: Read and use files from `.task-flow/contexts/` as needed (specs, mockups, examples, .md, .txt, .png, .json, etc.)
+  - **MATCHING**: Use the context files mentioned in subtask instructions; support any extension, not only images
+  - **NO NEED**: User doesn't need to explicitly mention context files - they're automatically considered
 
 - **Integration:**
   - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) - same workflow
-  - Follows [task_generation.mdc](mdc:.cursor/rules/task_generation.mdc) - screenshots are automatically referenced in generated subtasks
+  - Follows [task_generation.mdc](mdc:.cursor/rules/task_generation.mdc) - context files are automatically referenced in generated subtasks
   - Follows [commit_practices.mdc](mdc:.cursor/rules/commit_practices.mdc) - suggest commit after completion
   - Respects [git_control.mdc](mdc:.cursor/rules/git_control.mdc) - never commit automatically
 

package/.cursor/settings.json

@@ -1,3 +1 @@
-{
-  "model": "claude-sonnet-4-5-20250929"
-}
+{}

package/.model-versions.json

@@ -1,17 +1 @@
-{
-  "claude": {
-    "current": "claude-sonnet-4-5-20250929",
-    "latest": "claude-sonnet-4-5-20250929",
-    "checkUrl": "https://docs.anthropic.com/claude/docs/models-overview"
-  },
-  "cursor": {
-    "current": "claude-sonnet-4-5-20250929",
-    "latest": "claude-sonnet-4-5-20250929",
-    "checkUrl": "https://docs.cursor.com/models"
-  },
-  "gemini": {
-    "current": "gemini-3-flash",
-    "latest": "gemini-3-flash",
-    "checkUrl": "https://ai.google.dev/models/gemini"
-  }
-}
+{"claude":{"current":"claude-sonnet-4-5-20250929","latest":"claude-sonnet-4-5-20250929","checkUrl":"https://docs.anthropic.com/claude/docs/models-overview"},"cursor":{"current":"claude-sonnet-4-5-20250929","latest":"claude-sonnet-4-5-20250929","checkUrl":"https://docs.cursor.com/models"}}

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/.task-flow/contexts/example.png.txt

@@ -0,0 +1,29 @@
+# Example Context
+
+This folder (`.task-flow/contexts/`) is for AIs to consult reference material when working on tasks.
+
+## Purpose
+
+- **Contexts** = any files that help the AI understand what to build or how to do it
+- The AI reads and uses these files when generating subtasks and when implementing them
+- Different file types are supported: images, docs, specs, examples, etc.
+
+## Supported file types (examples)
+
+- **Images:** `.png`, `.jpg` – mockups, screenshots, diagrams
+- **Text / docs:** `.md`, `.txt` – specs, requirements, notes
+- **Data / config:** `.json`, `.yaml` – examples, schema, sample data
+- **Other:** any file that is useful as context for the task
+
+## How to use
+
+1. Add your context files to this folder with descriptive names (e.g. kebab-case)
+2. RBIN Task Flow lists and references them when generating subtasks
+3. To reference a specific file in a task, use: `task-flow-screen filename.ext`
+
+## Example names
+
+- `login-mockup.png`
+- `api-contract.json`
+- `requirements.md`
+- `dashboard-spec.txt`

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

@@ -7,12 +7,13 @@
 3. Use `task-flow: sync` to generate subtasks from your tasks
 4. Use `task-flow: status` to view task progress
 
-## Screenshots:
+## Contexts:
 
-- 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`
+- The `.task-flow/contexts/` folder is for AIs to consult when working on tasks (different file types: .md, .txt, .png, .jpg, .json, etc.)
+- Add specs, mockups, requirements, examples, or any reference file to this folder
+- RBIN Task Flow detects and references them when generating and implementing subtasks
+- To reference a specific context in a task: `task-flow-screen filename.ext`
+- Example: `- Create login screen task-flow-screen login-mockup.png`
 
 ## Tasks: