rbin-task-flow 1.2.0 → 1.4.0

package/CLAUDE.md

@@ -1,5 +1,9 @@
 # Claude Code Instructions
 
+## Models
+
+Claude and Cursor use the **default model** of each environment. No specific model is set in this project; do not specify or require a particular model.
+
 ## Development Rules
 
 All development rules are automatically loaded from `.cursor/rules/` directory. These rules include:
@@ -16,14 +20,20 @@ This project uses RBIN Task Flow for task management:
 - **Task Definition**: Edit `.task-flow/tasks.input.txt` using simple format: `- Task description`
 - **AI Commands**: Use AI-powered commands for task management:
   - `task-flow: sync` - Synchronize tasks from tasks.input.txt
-  - `task-flow: run next X` - Work on next X subtasks
-  - `task-flow: run task X` - Execute all pending subtasks of task X
-  - `task-flow: status` - View current task status
-  - `task-flow: review` - Review completed tasks
   - `task-flow: think` - Analyze code and suggest new tasks
-  - `task-flow: refactor` - Refactor code from current commit
-  - `task-flow: estimate task X` - Estimate time for task X based on subtasks and experience level
-  - `task-flow: report task X` - Generate implementation report for completed task X
+  - `task-flow: status` - View current task status
+  - `task-flow: run next X` - Work on next X subtasks
+  - `task-flow: run X` - Execute all pending subtasks of task X (simplified - no "task" needed)
+  - `task-flow: run X,Y` - Execute multiple tasks (comma-separated)
+  - `task-flow: run all` - Execute all tasks
+  - `task-flow: review X` - Review specific task(s) (comma-separated or "all")
+  - `task-flow: refactor X` - Refactor specific task(s) (comma-separated or "all")
+  - `task-flow: estimate X` - Estimate time for task X (simplified - no "task" needed)
+  - `task-flow: estimate X,Y` - Estimate multiple tasks (comma-separated)
+  - `task-flow: estimate all` - Estimate all tasks
+  - `task-flow: report X` - Generate implementation report for task X (simplified - no "task" needed)
+  - `task-flow: report X,Y` - Generate reports for multiple tasks (comma-separated)
+  - `task-flow: report all` - Generate reports for all tasks
 - **Files**:
   - `.task-flow/tasks.input.txt` - Define your tasks here
   - `.task-flow/tasks.status.md` - Auto-generated status (DO NOT EDIT manually)

package/README.md

@@ -3,13 +3,12 @@
 <div align="center">
 
 ![Claude](https://img.shields.io/badge/Claude-Sonnet%204.5-8A2BE2?style=for-the-badge&logo=anthropic&logoColor=white)
-![Gemini](https://img.shields.io/badge/Gemini-3%20Flash-4285F4?style=for-the-badge&logo=google&logoColor=white)
 ![Cursor](https://img.shields.io/badge/Cursor-IDE-blue?style=for-the-badge&logo=visual-studio-code&logoColor=white)
 ![Task Flow](https://img.shields.io/badge/Task%20Flow-AI%20Powered-green?style=for-the-badge)
 ![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)
 ![npm](https://img.shields.io/npm/v/rbin-task-flow?style=for-the-badge)
 
-**Configuração com um comando para Claude Code, Gemini, Cursor e RBIN Task Flow em qualquer projeto**
+**Configuração com um comando para Claude Code, Cursor e RBIN Task Flow em qualquer projeto**
 
 <div style="margin-top: 20px; margin-bottom: 20px;">
   <a href="#português">🇧🇷 Português</a> | <a href="#english">🇬🇧 English</a>
@@ -36,13 +35,13 @@
 
 ## O Que É Este Projeto?
 
-RBIN Task Flow é um sistema de gerenciamento de tarefas alimentado por IA que configura automaticamente Claude Code, Gemini e Cursor IDE em qualquer projeto. Você define tarefas em texto simples e a IA gera subtarefas detalhadas e acionáveis automaticamente.
+RBIN Task Flow é um sistema de gerenciamento de tarefas alimentado por IA que configura automaticamente Claude Code e Cursor IDE em qualquer projeto. Você define tarefas em texto simples e a IA gera subtarefas detalhadas e acionáveis automaticamente.
 
 **Principais benefícios:**
 - ✅ Instalação global NPM - instale uma vez, use em qualquer projeto
 - ✅ Zero configuração - pronto para usar imediatamente
 - ✅ Gerenciamento simples - escreva tarefas em texto, a IA faz o resto
-- ✅ Múltiplos modelos de IA - Claude, Gemini e Cursor configurados
+- ✅ Múltiplos modelos de IA - Claude e Cursor configurados
 
 ## Instalação
 
@@ -60,7 +59,7 @@ rbin-task-flow init
 # Edite .task-flow/tasks.input.txt e use:
 # - task-flow: sync
 # - task-flow: run next X
-# - task-flow: run task X
+# - task-flow: run X (ou task-flow: run X,Y ou task-flow: run all)
 ```
 
 **Pronto!** RBIN Task Flow agora está disponível globalmente no seu sistema.
@@ -74,25 +73,27 @@ rbin-task-flow init          # Inicializa no projeto atual
 rbin-task-flow update        # Atualiza configurações
 rbin-task-flow version-check # Verifica atualizações de modelos
 rbin-task-flow info          # Mostra informações
-rbin-task-flow estimate <id> # Estima tempo para uma task
-rbin-task-flow report <id>  # Gera relatório de implementação de uma task
+rbin-task-flow estimate <ids> # Estima tempo (ex: "1" ou "1,2" ou "all")
+rbin-task-flow report <ids>  # Gera relatório (ex: "1" ou "1,2" ou "all")
 ```
 
 ### Comandos da IA - Por Que Usar?
 
-Após inicializar, use estes comandos na IA (Cursor/Claude/Gemini) para gerenciar tarefas automaticamente:
+Após inicializar, use estes comandos na IA (Cursor/Claude) para gerenciar tarefas automaticamente:
 
 | Comando | Por Que Usar | Feature Principal |
 |---------|--------------|-------------------|
 | `task-flow: sync` | **Sincroniza** tarefas do arquivo texto com o sistema | Mantém tudo sincronizado automaticamente - adiciona novas, remove deletadas, preserva seu progresso |
 | `task-flow: think` | **Descobre** tarefas que você esqueceu | Analisa código e sugere tarefas que faltam (testes, refatoração, documentação) |
-| `task-flow: run next X` | **Automatiza** o trabalho nas próximas subtarefas | A IA trabalha nas próximas X subtarefas sequencialmente, você só acompanha |
-| `task-flow: run task X` | **Completa** uma tarefa inteira de uma vez | Executa todas as subtarefas de uma tarefa específica (permite trabalho paralelo) |
 | `task-flow: status` | **Visualiza** o progresso rapidamente | Vê resumo com tasks completas, em andamento e quantas subtarefas faltam |
-| `task-flow: review` | **Garante** qualidade do trabalho | Verifica se tarefas marcadas como "done" estão realmente concluídas |
-| `task-flow: refactor` | **Melhora** código sem quebrar | Refatora código do commit atual removendo comentários e melhorando qualidade |
-| `task-flow: estimate task X` | **Estima** tempo para gestão | Calcula estimativa de tempo baseada em subtasks e nível de experiência do desenvolvedor |
-| `task-flow: report task X` | **Documenta** implementação | Gera relatório detalhado em Markdown do que foi feito para resolver a task |
+| `task-flow: run next X` | **Automatiza** o trabalho nas próximas subtarefas | A IA trabalha nas próximas X subtarefas sequencialmente, você só acompanha |
+| `task-flow: run X` | **Completa** uma tarefa inteira de uma vez | Executa todas as subtarefas de uma tarefa específica (permite trabalho paralelo) |
+| `task-flow: run X,Y` | **Completa** múltiplas tarefas | Executa tarefas separadas por vírgula (ex: `task-flow: run 10,11`) |
+| `task-flow: run all` | **Completa** todas as tarefas | Executa todas as tarefas pendentes |
+| `task-flow: review X` | **Garante** qualidade do trabalho | Verifica tarefas específicas (ex: `task-flow: review 1` ou `task-flow: review 10,11` ou `task-flow: review all`) |
+| `task-flow: refactor X` | **Melhora** código sem quebrar | Refatora tarefas específicas (ex: `task-flow: refactor 1` ou `task-flow: refactor 10,11` ou `task-flow: refactor all`) |
+| `task-flow: estimate X` | **Estima** tempo para gestão | Calcula estimativa de tempo (ex: `task-flow: estimate 1` ou `task-flow: estimate 10,11`) |
+| `task-flow: report X` | **Documenta** implementação | Gera relatório detalhado (ex: `task-flow: report 1` ou `task-flow: report 10,11`) |
 
 **Fluxo típico:**
 
@@ -114,13 +115,13 @@ cd meu-projeto && rbin-task-flow init
 
 ## Visão Geral
 
-Repositório centralizado de configurações e regras de desenvolvimento que podem ser instaladas instantaneamente em qualquer projeto. Fornece configuração completa para Claude Code, Gemini, Cursor IDE e RBIN Task Flow - um sistema simples de gerenciamento de tarefas alimentado por IA.
+Repositório centralizado de configurações e regras de desenvolvimento que podem ser instaladas instantaneamente em qualquer projeto. Fornece configuração completa para Claude Code, Cursor IDE e RBIN Task Flow - um sistema simples de gerenciamento de tarefas alimentado por IA.
 
 ### Principais Recursos
 
 - **Instalação Global NPM** - Instale uma vez, use em qualquer lugar com `npm install -g rbin-task-flow`
 - **Gerenciamento Simples de Tarefas** - Defina tarefas em texto simples, a IA gera subtarefas detalhadas
-- **Múltiplos Modelos de IA** - Claude Code Sonnet e Gemini 3 Flash configurados e prontos para uso
+- **Múltiplos Modelos de IA** - Claude Code Sonnet configurado e pronto para uso
 - **.gitignore Discreto** - Configurações de IA ocultas com comentários genéricos
 - **Zero Configuração** - Pronto para usar imediatamente
 - **RBIN Task Flow** - Gerenciamento de tarefas alimentado por IA com interface de texto simples
@@ -129,7 +130,7 @@ Repositório centralizado de configurações e regras de desenvolvimento que pod
 
 - **Sistema Operacional:** macOS, Linux ou Windows (WSL)
 - **Ferramentas:** Git, Bash, Node.js
-- **Necessário:** Claude Code CLI, acesso à API Gemini ou Cursor IDE (com assinatura Pro)
+- **Necessário:** Claude Code CLI ou Cursor IDE (com assinatura Pro)
 
 ### Alternativa: Instalação Legacy (Sem NPM)
 
@@ -163,9 +164,6 @@ seu-projeto/
 ├── .claude/
 │   └── settings.json             # Configurações do Claude Code
 │
-├── .gemini/
-│   └── settings.json             # Configurações do Gemini
-│
 ├── .task-flow/                   # RBIN Task Flow
 │   ├── tasks.input.txt           # Definições de tarefas em texto simples (edite isso!)
 │   ├── tasks.status.md           # ⚠️ Status das tarefas (atualizado automaticamente, NÃO EDITE)
@@ -180,7 +178,6 @@ seu-projeto/
 
 Nenhuma configuração adicional necessária! Apenas certifique-se de ter:
 - Claude Code CLI instalado, OU
-- Acesso à API Gemini configurado, OU
 - Cursor IDE com assinatura Pro ativa
 
 **Você está pronto!**
@@ -205,13 +202,6 @@ O Claude Code vem pré-configurado com:
 - Integração com RBIN Task Flow
 - Melhores práticas de desenvolvimento
 
-### Integração com Gemini
-
-O Gemini vem pré-configurado com:
-- Configurações personalizadas
-- Integração com RBIN Task Flow
-- Melhores práticas de desenvolvimento
-
 ## O Que Está Configurado
 
 ### Regras de Desenvolvimento
@@ -239,11 +229,9 @@ O instalador adiciona estas entradas ao `.gitignore`:
 
 ```gitignore
 .claude/
-.gemini/
 .cursor/
 .task-flow/
 CLAUDE.md
-GEMINI.md
 ```
 
 **Por que discreto?**
@@ -288,9 +276,6 @@ rbin-task-flow/
 ├── .claude/
 │   └── settings.json             # Configurações do Claude Code
 │
-├── .gemini/
-│   └── settings.json             # Configurações do Gemini
-│
 ├── .task-flow/
 │   ├── README.md                 # Referência rápida de comandos
 │   ├── tasks.input.txt           # Template de definições de tarefas
@@ -302,7 +287,6 @@ rbin-task-flow/
 ├── .gitignore                    # Template gitignore
 ├── .model-versions.json          # Referência de versão do modelo (atualize quando novos modelos forem lançados)
 ├── CLAUDE.md                     # Instruções principais do Claude
-├── GEMINI.md                     # Instruções principais do Gemini
 ├── install.sh                    # Script de instalação
 └── README.md                     # Este arquivo
 ```
@@ -313,11 +297,11 @@ rbin-task-flow/
 - ✅ Use RBIN Task Flow em **projetos que recebem** as configurações via instalação
 - 🔄 O instalador **sempre sobrescreve** configurações existentes
 - 🤫 As entradas do .gitignore são **discretas** (sem menções a IA)
-- 🎯 Funciona com **Claude Code CLI**, **API Gemini** ou **Cursor Pro**
+- 🎯 Funciona com **Claude Code CLI** ou **Cursor Pro**
 - 📦 O diretório Task Flow (`.task-flow/`) é **automaticamente gitignored**
 - 📝 Defina tarefas em `.task-flow/tasks.input.txt` usando formato simples: `- Descrição da tarefa`
 - 🚀 **Instalação Global NPM**: `npm install -g rbin-task-flow`, depois use `rbin-task-flow init` em qualquer projeto
-- 🔒 **Chaves de API podem ser necessárias** - depende do seu provedor de IA (Claude Code, API Gemini ou Cursor Pro)
+- 🔒 **Chaves de API podem ser necessárias** - depende do seu provedor de IA (Claude Code ou Cursor Pro)
 - 🔔 **Verificação de versão do modelo** - Use `rbin-task-flow version-check` para verificar versões mais recentes dos modelos (verificação rápida e local)
 
 ## Atualizando Versões dos Modelos
@@ -335,16 +319,11 @@ Quando novas versões de modelos forem lançadas, atualize `.model-versions.json
     "current": "claude-sonnet-4-5-20250929",
     "latest": "NOVA_VERSÃO_AQUI",
     "checkUrl": "https://docs.cursor.com/models"
-  },
-  "gemini": {
-    "current": "gemini-3-flash",
-    "latest": "NOVA_VERSÃO_AQUI",
-    "checkUrl": "https://ai.google.dev/models/gemini"
   }
 }
 ```
 
-O instalador verificará automaticamente versões mais recentes dos modelos e **perguntará individualmente** se você deseja atualizar cada um (Claude, Cursor, Gemini). Esta verificação é **rápida e local** - sem chamadas de API, sem solicitações de rede, apenas uma simples comparação de strings.
+O instalador verificará automaticamente versões mais recentes dos modelos e **perguntará individualmente** se você deseja atualizar cada um (Claude, Cursor). Esta verificação é **rápida e local** - sem chamadas de API, sem solicitações de rede, apenas uma simples comparação de strings.
 
 **Atualizações Interativas:** Quando uma versão mais recente estiver disponível, o instalador irá:
 - Mostrar versões atuais e mais recentes
@@ -399,13 +378,13 @@ Para problemas ou perguntas:
 
 ## What Is This Project?
 
-RBIN Task Flow is an AI-powered task management system that automatically configures Claude Code, Gemini, and Cursor IDE in any project. You define tasks in plain text and the AI automatically generates detailed, actionable subtasks.
+RBIN Task Flow is an AI-powered task management system that automatically configures Claude Code and Cursor IDE in any project. You define tasks in plain text and the AI automatically generates detailed, actionable subtasks.
 
 **Key benefits:**
 - ✅ Global NPM installation - install once, use in any project
 - ✅ Zero configuration - ready to use immediately
 - ✅ Simple management - write tasks in text, AI does the rest
-- ✅ Multiple AI models - Claude, Gemini, and Cursor configured
+- ✅ Multiple AI models - Claude and Cursor configured
 
 ## Installation
 
@@ -423,7 +402,7 @@ rbin-task-flow init
 # Edit .task-flow/tasks.input.txt and use:
 # - task-flow: sync
 # - task-flow: run next X
-# - task-flow: run task X
+# - task-flow: run X (or task-flow: run X,Y or task-flow: run all)
 ```
 
 **That's it!** RBIN Task Flow is now available globally on your system.
@@ -437,25 +416,27 @@ rbin-task-flow init          # Initialize in current project
 rbin-task-flow update        # Update configurations
 rbin-task-flow version-check # Check for model updates
 rbin-task-flow info          # Show information
-rbin-task-flow estimate <id> # Estimate time for a task
-rbin-task-flow report <id>   # Generate implementation report for a task
+rbin-task-flow estimate <ids> # Estimate time (e.g., "1" or "1,2" or "all")
+rbin-task-flow report <ids>   # Generate report (e.g., "1" or "1,2" or "all")
 ```
 
 ### AI Commands - Why Use Them?
 
-After initializing, use these commands in your AI (Cursor/Claude/Gemini) to automatically manage tasks:
+After initializing, use these commands in your AI (Cursor/Claude) to automatically manage tasks:
 
 | Command | Why Use It | Key Feature |
 |---------|------------|-------------|
 | `task-flow: sync` | **Sync** tasks from text file with system | Keeps everything synchronized automatically - adds new, removes deleted, preserves your progress |
 | `task-flow: think` | **Discover** tasks you forgot | Analyzes code and suggests missing tasks (tests, refactoring, documentation) |
-| `task-flow: run next X` | **Automate** work on next subtasks | AI works on next X subtasks sequentially, you just follow along |
-| `task-flow: run task X` | **Complete** an entire task at once | Executes all subtasks of a specific task (allows parallel work) |
 | `task-flow: status` | **Visualize** progress quickly | See summary with completed tasks, in progress, and remaining subtasks |
-| `task-flow: review` | **Ensure** work quality | Verifies that tasks marked as "done" are actually completed |
-| `task-flow: refactor` | **Improve** code without breaking | Refactors code from current commit removing comments and improving quality |
-| `task-flow: estimate task X` | **Estimate** time for management | Calculates time estimate based on subtasks and developer experience level |
-| `task-flow: report task X` | **Document** implementation | Generates detailed Markdown report of what was done to resolve the task |
+| `task-flow: run next X` | **Automate** work on next subtasks | AI works on next X subtasks sequentially, you just follow along |
+| `task-flow: run X` | **Complete** an entire task at once | Executes all subtasks of a specific task (allows parallel work) |
+| `task-flow: run X,Y` | **Complete** multiple tasks | Executes comma-separated tasks (e.g., `task-flow: run 10,11`) |
+| `task-flow: run all` | **Complete** all tasks | Executes all pending tasks |
+| `task-flow: review X` | **Ensure** work quality | Verifies specific tasks (e.g., `task-flow: review 1` or `task-flow: review 10,11` or `task-flow: review all`) |
+| `task-flow: refactor X` | **Improve** code without breaking | Refactors specific tasks (e.g., `task-flow: refactor 1` or `task-flow: refactor 10,11` or `task-flow: refactor all`) |
+| `task-flow: estimate X` | **Estimate** time for management | Calculates time estimate (e.g., `task-flow: estimate 1` or `task-flow: estimate 10,11`) |
+| `task-flow: report X` | **Document** implementation | Generates detailed report (e.g., `task-flow: report 1` or `task-flow: report 10,11`) |
 
 **Typical workflow:**
 
@@ -477,13 +458,13 @@ cd my-project && rbin-task-flow init
 
 ## Overview
 
-A centralized repository of development configurations and rules that can be instantly installed in any project. Provides complete setup for Claude Code, Gemini, Cursor IDE, and RBIN Task Flow - a simple AI-powered task management system.
+A centralized repository of development configurations and rules that can be instantly installed in any project. Provides complete setup for Claude Code, Cursor IDE, and RBIN Task Flow - a simple AI-powered task management system.
 
 ### Key Features
 
 - **NPM Global Installation** - Install once, use everywhere with `npm install -g rbin-task-flow`
 - **Simple Task Management** - Define tasks in plain text, AI generates detailed subtasks
-- **Multiple AI Models** - Claude Code Sonnet and Gemini 3 Flash configured and ready to use
+- **Multiple AI Models** - Claude Code Sonnet configured and ready to use
 - **Discrete .gitignore** - AI configs hidden with generic comments
 - **Zero Configuration** - Ready to use immediately
 - **RBIN Task Flow** - AI-powered task management with simple text interface
@@ -492,7 +473,7 @@ A centralized repository of development configurations and rules that can be ins
 
 - **Operating System:** macOS, Linux, or Windows (WSL)
 - **Tools:** Git, Bash, Node.js
-- **Required:** Claude Code CLI, Gemini API access, or Cursor IDE (with Pro subscription)
+- **Required:** Claude Code CLI or Cursor IDE (with Pro subscription)
 
 ### Alternative: Legacy Installation (Without NPM)
 
@@ -526,9 +507,6 @@ your-project/
 ├── .claude/
 │   └── settings.json             # Claude Code settings
 │
-├── .gemini/
-│   └── settings.json             # Gemini settings
-│
 ├── .task-flow/                   # RBIN Task Flow
 │   ├── tasks.input.txt           # Plain text task definitions (edit this!)
 │   ├── tasks.status.md           # ⚠️ Task status (auto-updated, DO NOT EDIT)
@@ -543,7 +521,6 @@ your-project/
 
 No additional configuration required! Just make sure you have:
 - Claude Code CLI installed, OR
-- Gemini API access configured, OR
 - Cursor IDE with an active Pro subscription
 
 **You're ready!**
@@ -568,13 +545,6 @@ Claude Code is pre-configured with:
 - RBIN Task Flow integration
 - Development best practices
 
-### Gemini Integration
-
-Gemini is pre-configured with:
-- Custom settings
-- RBIN Task Flow integration
-- Development best practices
-
 ## What's Configured
 
 ### Development Rules
@@ -602,11 +572,9 @@ The installer adds these entries to `.gitignore`:
 
 ```gitignore
 .claude/
-.gemini/
 .cursor/
 .task-flow/
 CLAUDE.md
-GEMINI.md
 ```
 
 **Why discrete?**
@@ -651,9 +619,6 @@ rbin-task-flow/
 ├── .claude/
 │   └── settings.json             # Claude Code settings
 │
-├── .gemini/
-│   └── settings.json             # Gemini settings
-│
 ├── .task-flow/
 │   ├── README.md                 # Quick commands reference
 │   ├── tasks.input.txt           # Task definitions template
@@ -665,7 +630,6 @@ rbin-task-flow/
 ├── .gitignore                    # Template gitignore
 ├── .model-versions.json          # Model version reference (update when new models are released)
 ├── CLAUDE.md                     # Main Claude instructions
-├── GEMINI.md                     # Main Gemini instructions
 ├── install.sh                    # Installation script
 └── README.md                     # This file
 ```
@@ -676,11 +640,11 @@ rbin-task-flow/
 - ✅ Use RBIN Task Flow in **projects that receive** the configs via installation
 - 🔄 Installer **always overwrites** existing configs
 - 🤫 .gitignore entries are **discrete** (no AI mentions)
-- 🎯 Works with **Claude Code CLI**, **Gemini API**, or **Cursor Pro**
+- 🎯 Works with **Claude Code CLI** or **Cursor Pro**
 - 📦 Task Flow directory (`.task-flow/`) is **automatically gitignored**
 - 📝 Define tasks in `.task-flow/tasks.input.txt` using simple format: `- Task description`
 - 🚀 **NPM Global Install**: `npm install -g rbin-task-flow`, then use `rbin-task-flow init` in any project
-- 🔒 **API keys may be required** - depends on your AI provider (Claude Code, Gemini API, or Cursor Pro)
+- 🔒 **API keys may be required** - depends on your AI provider (Claude Code or Cursor Pro)
 - 🔔 **Model version checking** - Use `rbin-task-flow version-check` to check for newer model versions (fast, local check)
 
 ## Updating Model Versions
@@ -698,16 +662,11 @@ When new model versions are released, update `.model-versions.json` in this repo
     "current": "claude-sonnet-4-5-20250929",
     "latest": "NEW_VERSION_HERE",
     "checkUrl": "https://docs.cursor.com/models"
-  },
-  "gemini": {
-    "current": "gemini-3-flash",
-    "latest": "NEW_VERSION_HERE",
-    "checkUrl": "https://ai.google.dev/models/gemini"
   }
 }
 ```
 
-The installer will automatically check for newer model versions and **ask you individually** if you want to update each one (Claude, Cursor, Gemini). This check is **fast and local** - no API calls, no network requests, just a simple string comparison.
+The installer will automatically check for newer model versions and **ask you individually** if you want to update each one (Claude, Cursor). This check is **fast and local** - no API calls, no network requests, just a simple string comparison.
 
 **Interactive Updates:** When a newer version is available, the installer will:
 - Show current and latest versions

package/bin/cli.js

@@ -10,7 +10,7 @@ const chalk = require('chalk');
 
 program
   .name('rbin-task-flow')
-  .description('AI-powered task management for Claude, Cursor, and Gemini')
+  .description('AI-powered task management for Claude and Cursor')
   .version(require('../package.json').version);
 
 program
@@ -40,22 +40,22 @@ program
 
 program
   .command('estimate')
-  .description('Estimate time for a task based on subtasks and experience level')
-  .argument('<taskId>', 'Task ID to estimate')
+  .description('Estimate time for task(s) based on subtasks and experience level')
+  .argument('<taskIds>', 'Task ID(s) to estimate (comma-separated or "all")')
   .option('-p, --path <path>', 'Target directory (default: current directory)')
-  .action(async (taskId, options) => {
+  .action(async (taskIds, options) => {
     const targetPath = options.path || process.cwd();
-    await estimateTask(taskId, targetPath);
+    await estimateTask(taskIds, targetPath);
   });
 
 program
   .command('report')
-  .description('Generate implementation report for a completed task')
-  .argument('<taskId>', 'Task ID to generate report for')
+  .description('Generate implementation report for completed task(s)')
+  .argument('<taskIds>', 'Task ID(s) to generate report for (comma-separated or "all")')
   .option('-p, --path <path>', 'Target directory (default: current directory)')
-  .action(async (taskId, options) => {
+  .action(async (taskIds, options) => {
     const targetPath = options.path || process.cwd();
-    await generateReport(taskId, targetPath);
+    await generateReport(taskIds, targetPath);
   });
 
 program
@@ -65,15 +65,15 @@ program
     console.log('\n' + chalk.cyan('╔════════════════════════════════════════════════════════════════╗'));
     console.log(chalk.cyan('║') + '        ' + chalk.magenta('✨ RBIN Task Flow ✨') + '                           ' + chalk.cyan('║'));
     console.log(chalk.cyan('╚════════════════════════════════════════════════════════════════╝') + '\n');
-    console.log(chalk.blue('AI-powered task management for Claude, Cursor, and Gemini'));
+    console.log(chalk.blue('AI-powered task management for Claude and Cursor'));
     console.log(chalk.yellow('\nVersion:'), require('../package.json').version);
     console.log(chalk.yellow('Repository:'), 'https://github.com/rbinoliveira/rbin-task-flow');
     console.log(chalk.yellow('\nCommands:'));
     console.log(chalk.cyan('  rbin-task-flow init') + '         - Initialize in current directory');
     console.log(chalk.cyan('  rbin-task-flow update') + '       - Update configurations');
     console.log(chalk.cyan('  rbin-task-flow version-check') + ' - Check for model updates');
-    console.log(chalk.cyan('  rbin-task-flow estimate <id>') + ' - Estimate time for a task');
-    console.log(chalk.cyan('  rbin-task-flow report <id>') + '  - Generate implementation report');
+    console.log(chalk.cyan('  rbin-task-flow estimate <ids>') + ' - Estimate time (e.g., "1" or "1,2" or "all")');
+    console.log(chalk.cyan('  rbin-task-flow report <ids>') + '  - Generate report (e.g., "1" or "1,2" or "all")');
     console.log(chalk.cyan('  rbin-task-flow info') + '         - Show this information\n');
   });
 

package/lib/estimate.js

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