rbin-task-flow 1.19.3 → 1.19.5

package/.cursor/rules/task_estimate.mdc

@@ -1,5 +1,5 @@
 ---
-description: Task time estimation based on task complexity and developer experience level
+description: Task time estimation based on real task complexity for an average developer pace
 globs: **/*
 alwaysApply: true
 ---
@@ -10,41 +10,36 @@ alwaysApply: true
   - **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 task level, complexity signals, and developer experience level
-    - **DISPLAY**: Show time estimate with intervals for 3 experience levels (junior, mid, senior)
-    - **FORMAT**: Show estimates in hours with ranges (e.g., "10-14 hours" for intermediate)
+    - **CALCULATE**: Time estimate based on task level, intrinsic complexity signals, and average development pace
+    - **DISPLAY**: Show a single estimate range for the majority of developers
+    - **FORMAT**: Show estimates in hours with ranges (e.g. "10-14 hours")
 
 - **Estimation Rules:**
-  1. **Base Analysis**: Evaluate the task title and subtasks to infer real task level
-  2. **Experience Levels** (use internally; display "Intermediate" not "Mid-level" to user):
-     - **Junior** (0-2 years): Base time × 1.5 multiplier
-     - **Intermediate** (3-5 years): Base time × 1.0 multiplier (baseline)
-     - **Senior** (6+ years): Base time × 0.7 multiplier
+  1. **Base Analysis**: Evaluate the task title, description, and subtasks to infer the real complexity of the task itself
+  2. **Assumption**: Estimate for an average developer working at an average development pace, without AI acceleration
   3. **Task Level Heuristics**:
      - **Low**: localized change, clear requirement, low ambiguity, low regression risk
      - **Medium**: multi-file implementation, moderate ambiguity, moderate validation needs
      - **High**: architectural, cross-cutting, migration, security, performance, or high-risk change
-  4. **Subtask count is only one signal**: use it to inform scope, but never as the sole estimate driver
-  5. **Intermediate baseline per subtask**:
+  4. **Intrinsic complexity matters first**: scope, ambiguity, dependencies, validation, integration points, and regression risk must outweigh raw subtask count
+  5. **Subtask count is only one signal**: use it to inform scope, but never as the sole estimate driver
+  6. **Baseline per subtask for average pace**:
      - Low-level task: 1.5-2.5 hours
      - Medium-level task: 2.5-4 hours
      - High-level task: 4-6.5 hours
-  6. **Risk and scope adjustment**:
+  7. **Risk and scope adjustment**:
      - Increase estimate when the task mentions integrations, migrations, refactors, security, performance, billing, or architecture work
-  7. **Range Calculation**:
-     - Lower bound: (subtasks × baseline lower) × risk factor × experience multiplier
-     - Upper bound: (subtasks × baseline upper) × risk factor × experience multiplier
+  8. **Range Calculation**:
+     - Lower bound: subtasks × baseline lower × risk factor
+     - Upper bound: subtasks × baseline upper × risk factor
      - Round to nearest hour
 
 - **Estimation Formula:**
   ```
   1. Infer task level: low, medium, or high
-  2. Choose intermediate baseline per subtask from task level
+  2. Choose average-pace baseline per subtask from task level
   3. Apply risk/scope multiplier when complexity indicators exist
-  4. Apply experience multiplier:
-     Junior: × 1.5
-     Intermediate: × 1.0
-     Senior: × 0.7
+  4. Return one range that represents the majority of developers
   ```
 
 - **Display Format:**
@@ -52,10 +47,8 @@ alwaysApply: true
   📊 Time Estimation for Task X: [Task Title]
   
   Based on [N] subtasks and task-level analysis:
-  
-  👶 Junior (0-2 years):      [X-Y] hours
-  👨‍💼 Intermediate (3-5 years): [X-Y] hours
-  👴 Senior (6+ years):       [X-Y] hours
+
+  Average developer, average pace, no AI acceleration: [X-Y] hours
   ```
 
 - **Natural Language Phrases:**
@@ -78,9 +71,7 @@ alwaysApply: true
   
   Based on 5 subtasks and task-level analysis:
   
-  👶 Junior (0-2 years):      15-23 hours
-  👨‍💼 Intermediate (3-5 years): 10-15 hours
-  👴 Senior (6+ years):      7-11 hours
+  Average developer, average pace, no AI acceleration: 10-15 hours
   ```
 
 - **Integration:**
@@ -89,4 +80,4 @@ alwaysApply: true
   - Estimates are informational only (not stored)
 
 - **Principle:**
-  > **Provide realistic time estimates based on real task level, scope, ambiguity, and risk. Subtask count informs scope, but must not be the sole estimation criterion.**
+  > **Provide realistic time estimates for an average developer, based on the real complexity of the task itself. Subtask count informs scope, but must not be the sole estimation criterion, and estimates must not assume AI acceleration.**

package/.task-flow/README.md

@@ -95,10 +95,10 @@ Refactors code from specific task(s). Removes explanatory comments, improves cod
 - `task-flow: refactor all` → Refactors all tasks
 
 ### `task-flow: estimate X` (simplified syntax)
-Estimates time required to complete task(s) based on task level, scope, risk, and developer experience level. Subtask count informs scope, but is not the sole criterion.
+Estimates time required to complete task(s) based on the real complexity of the task, assuming an average developer working at an average pace without AI acceleration. Subtask count informs scope, but is not the sole criterion.
 
 **Output includes:**
-- Time estimates for Junior (0-2 years), Intermediate (3-5 years), and Senior (6+ years) developers
+- A single estimate range for the majority of developers
 - Estimates in hours and business days
 - Recommendation for management with buffer
 

package/README.md

@@ -71,6 +71,7 @@ rbin-task-flow init
 ```bash
 rbin-task-flow init          # Inicializa no projeto atual
 rbin-task-flow update        # Atualiza configurações
+rbin-task-flow reset         # Reinstala o Task Flow do zero
 rbin-task-flow version-check # Verifica atualizações de modelos
 rbin-task-flow info          # Mostra informações
 rbin-task-flow check         # Roda lint/fix e build quando existirem
@@ -253,6 +254,9 @@ Para atualizar configurações em um projeto existente:
 cd /caminho/para/seu/projeto
 rbin-task-flow update
 
+# Para reiniciar o Task Flow do zero, incluindo .task-flow/.internal
+rbin-task-flow reset
+
 # Ou usando método legacy
 ~/.rbin-task-flow/install.sh
 # Digite o caminho do projeto
@@ -418,6 +422,7 @@ rbin-task-flow init
 ```bash
 rbin-task-flow init          # Initialize in current project
 rbin-task-flow update        # Update configurations
+rbin-task-flow reset         # Reinstall Task Flow from scratch
 rbin-task-flow version-check # Check for model updates
 rbin-task-flow info          # Show information
 rbin-task-flow check         # Run lint/fix and build when available
@@ -600,6 +605,9 @@ To update configs in an existing project:
 cd /path/to/your/project
 rbin-task-flow update
 
+# To reset Task Flow from scratch, including .task-flow/.internal
+rbin-task-flow reset
+
 # Or using legacy method
 ~/.rbin-task-flow/install.sh
 # Enter the project path

package/bin/cli.js

@@ -33,6 +33,15 @@ program
     await installInProject(targetPath, { update: true });
   });
 
+program
+  .command('reset')
+  .description('Reset RBIN Task Flow in current directory')
+  .option('-p, --path <path>', 'Target directory (default: current directory)')
+  .action(async (options) => {
+    const targetPath = options.path || process.cwd();
+    await installInProject(targetPath, { reset: true });
+  });
+
 program
   .command('version-check')
   .description('Check for model version updates')
@@ -42,7 +51,7 @@ program
 
 program
   .command('estimate')
-  .description('Estimate time for task(s) based on subtasks and experience level')
+  .description('Estimate time for task(s) based on real task complexity and average development pace')
   .argument('<taskIds>', 'Task ID(s) to estimate (comma-separated or "all")')
   .option('-p, --path <path>', 'Target directory (default: current directory)')
   .action(async (taskIds, options) => {
@@ -91,6 +100,7 @@ program
     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 reset') + '        - Reset task flow files from scratch');
     console.log(chalk.cyan('  rbin-task-flow version-check') + ' - Check for model updates');
     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")');

package/lib/estimate.js

@@ -55,34 +55,22 @@ async function estimateTask(taskIdsInput, targetPath = process.cwd()) {
       console.log(chalk.blue(`Complexity: ${chalk.yellow(analysis.level)} (${subtaskCount} subtasks)\n`));
 
       console.log(chalk.cyan('─'.repeat(70)));
-      console.log(chalk.magenta.bold('Time Estimates by Experience Level:\n'));
+      console.log(chalk.magenta.bold('Time Estimate for Average Development Pace:\n'));
 
       console.log(chalk.gray(`Signals: ${analysis.signals.join(', ')}\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);
+      const estimateDays = Math.ceil(estimates.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('👨‍💼 Intermediate (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(chalk.gray('Assumption: average developer, average delivery pace, without AI acceleration.'));
+      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.lower}-${estimates.upper} hours`));
+      console.log(chalk.white('   Days: '), chalk.yellow(`~${estimateDays} 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('(3-5 years baseline)'));
+      console.log(chalk.white('   Recommended estimate:'), chalk.yellow(`${estimates.lower}-${estimates.upper} hours`), chalk.gray('(average developer 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(chalk.white('   Total estimate:'), chalk.yellow(`${Math.round(estimates.upper * 1.2)} hours`), chalk.gray(`(~${Math.ceil(estimates.upper * 1.2 / 8)} business days)`));
       console.log('');
 
       successCount++;
@@ -109,18 +97,8 @@ function calculateEstimates(analysis) {
   const baseUpper = subtaskCount * baseRange.upper * riskMultiplier;
 
   return {
-    junior: {
-      lower: Math.round(baseLower * 1.5),
-      upper: Math.round(baseUpper * 1.5)
-    },
-    mid: {
-      lower: baseLower,
-      upper: baseUpper
-    },
-    senior: {
-      lower: Math.round(baseLower * 0.7),
-      upper: Math.round(baseUpper * 0.7)
-    }
+    lower: Math.round(baseLower),
+    upper: Math.round(baseUpper)
   };
 }
 

package/lib/install.js

@@ -8,10 +8,13 @@ const TEMPLATE_DIR = path.join(__dirname, '..');
 
 async function installInProject(targetPath, options = {}) {
   const isUpdate = options.update || false;
+  const isReset = options.reset || false;
 
   showHeader();
 
-  if (isUpdate) {
+  if (isReset) {
+    console.log(chalk.blue('♻️  Resetting RBIN Task Flow...'));
+  } else if (isUpdate) {
     console.log(chalk.blue('🔄 Updating RBIN Task Flow...'));
   } else {
     console.log(chalk.blue('🚀 Installing RBIN Task Flow...'));
@@ -36,6 +39,10 @@ async function installInProject(targetPath, options = {}) {
 
     spinner.text = 'Creating directories...';
 
+    if (isReset) {
+      await fs.remove(path.join(targetPath, '.task-flow'));
+    }
+
     const dirs = [
       '.cursor/rules',
       '.claude',
@@ -48,7 +55,7 @@ async function installInProject(targetPath, options = {}) {
 
     spinner.text = 'Copying configuration files...';
 
-    await copyConfigs(targetPath, isUpdate);
+    await copyConfigs(targetPath, { update: isUpdate, reset: isReset });
 
     spinner.text = 'Updating .gitignore...';
 
@@ -69,11 +76,14 @@ async function installInProject(targetPath, options = {}) {
   }
 }
 
-async function copyConfigs(targetPath, isUpdate = false) {
+async function copyConfigs(targetPath, options = {}) {
+  const isUpdate = options.update || false;
+  const isReset = options.reset || false;
+
   const cursorRulesPath = path.join(TEMPLATE_DIR, '.cursor/rules');
   const cursorRulesDest = path.join(targetPath, '.cursor/rules');
   if (fs.existsSync(cursorRulesPath)) {
-    if (isUpdate && fs.existsSync(cursorRulesDest)) {
+    if ((isUpdate || isReset) && fs.existsSync(cursorRulesDest)) {
       await fs.emptyDir(cursorRulesDest);
     }
     await fs.copy(cursorRulesPath, cursorRulesDest, { overwrite: true });
@@ -120,10 +130,12 @@ async function copyConfigs(targetPath, isUpdate = false) {
     showSuccess('Codex instructions (AGENTS.md)');
   }
 
-  await copyTaskFlow(targetPath, isUpdate);
+  await copyTaskFlow(targetPath, { update: isUpdate, reset: isReset });
 }
 
-async function copyTaskFlow(targetPath, isUpdate = false) {
+async function copyTaskFlow(targetPath, options = {}) {
+  const isUpdate = options.update || false;
+  const isReset = options.reset || false;
   const taskFlowSrc = path.join(TEMPLATE_DIR, '.task-flow');
   const taskFlowDest = path.join(targetPath, '.task-flow');
 
@@ -141,6 +153,10 @@ async function copyTaskFlow(targetPath, isUpdate = false) {
   await fs.copy(taskFlowSrc, taskFlowDest, {
     overwrite: true,
     filter: (src, dest) => {
+      if (isReset) {
+        return true;
+      }
+
       if (PROTECTED.some((p) => src.startsWith(p) || dest.startsWith(p))) {
         return false;
       }
@@ -168,7 +184,9 @@ async function copyTaskFlow(targetPath, isUpdate = false) {
   }
 
   showSuccess('Task Flow directory');
-  if (isUpdate) {
+  if (isReset) {
+    showWarning('Reset completed: .task-flow was recreated from scratch');
+  } else if (isUpdate) {
     showInfo('Protected: .internal/ (your task data is safe)');
   } else {
     showInfo('Protected on init: .internal/, tasks.input.txt, tasks.status.md, tasks.flow.md');

package/package.json

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