@polymorphism-tech/morph-spec 4.8.12 → 4.8.15

package/bin/{task-manager.cjs → task-manager.js}

@@ -7,84 +7,21 @@
  * Part of MORPH-SPEC 3.0 - Event-driven state management.
  */
 
-const fs = require('fs').promises;
-const fsSync = require('fs');
-const path = require('path');
-
-// Simple ANSI color helpers (chalk v5 is ESM-only, can't require in CJS)
-const chalk = {
-  red: (s) => `\x1b[31m${s}\x1b[0m`,
-  green: (s) => `\x1b[32m${s}\x1b[0m`,
-  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
-  blue: (s) => `\x1b[34m${s}\x1b[0m`,
-  magenta: (s) => `\x1b[35m${s}\x1b[0m`,
-  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
-  gray: (s) => `\x1b[90m${s}\x1b[0m`,
-  bold: (s) => `\x1b[1m${s}\x1b[0m`,
-};
+import { fileURLToPath } from 'url';
+import { join, dirname } from 'path';
+import { access } from 'fs/promises';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
 
-// ============================================================================
-// v3 Schema Helpers
-// ============================================================================
-
-/**
- * Parse tasks.md to extract task stubs for v3 state format.
- * Looks for headings like: ### T001 — Task title
- */
-async function parseTasksMd(featureName) {
-  const tasksPath = path.join(process.cwd(), `.morph/features/${featureName}/3-tasks/tasks.md`);
-  let content = '';
-  try {
-    content = await fs.readFile(tasksPath, 'utf-8');
-  } catch {
-    return [];
-  }
-
-  const tasks = [];
-  const headingRe = /^###\s+(T\d+)\s+[—–-]\s+(.+)$/gm;
-  let match;
-  while ((match = headingRe.exec(content)) !== null) {
-    tasks.push({
-      id: match[1],
-      title: match[2].trim(),
-      status: 'pending',
-      dependencies: [],
-      files: [],
-      checkpoint: null
-    });
-  }
-  return tasks;
-}
+import { loadState, saveState } from '../src/core/state/state-manager.js';
+import { parseTasksMd, ensureTaskList, syncCounters } from '../src/lib/tasks/task-parser.js';
 
-/**
- * Ensure feature.taskList exists (array of individual task objects).
- * In v3 state, feature.tasks is a counter object {total, completed, ...}.
- * Individual task objects live in feature.taskList.
- */
-async function ensureTaskList(feature, featureName) {
-  if (Array.isArray(feature.tasks)) {
-    // v2 format: tasks IS the array
-    return feature.tasks;
-  }
-  // v3 format: use taskList or build from tasks.md
-  if (!feature.taskList || feature.taskList.length === 0) {
-    feature.taskList = await parseTasksMd(featureName);
-  }
-  return feature.taskList;
-}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
-/**
- * After modifying taskList, sync counts back to feature.tasks counter.
- * tasks.total is derived from the actual taskList length (Problem 3 fix).
- */
-function syncCounters(feature) {
-  if (Array.isArray(feature.tasks)) return; // v2, nothing to sync
-  const list = feature.taskList || [];
-  feature.tasks.total = list.length; // Auto-sync total from parsed taskList
-  feature.tasks.completed = list.filter(t => t.status === 'completed').length;
-  feature.tasks.inProgress = list.filter(t => t.status === 'in_progress').length;
-  feature.tasks.pending = list.filter(t => t.status === 'pending').length;
-}
+// ============================================================================
+// Breaking-Change Detection
+// ============================================================================
 
 /**
  * Detect potentially broken consumers of recently removed exports.
@@ -102,7 +39,6 @@ function syncCounters(feature) {
  */
 async function detectBreakingChanges() {
   try {
-    const { execSync } = require('child_process');
     const execOpts = { cwd: process.cwd(), stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: 5 * 1024 * 1024 };
 
     // Collect diff from staged + unstaged changes in source files
@@ -133,7 +69,6 @@ async function detectBreakingChanges() {
     const warnings = [];
     for (const sym of removedExports) {
       try {
-        // git grep returns exit code 1 when nothing found — that's handled by catch
         const result = execSync(`git grep -l "${sym}"`, execOpts).toString().trim();
         if (result) {
           const consumers = result.split('\n').filter(Boolean);
@@ -150,39 +85,11 @@ async function detectBreakingChanges() {
   }
 }
 
-class TaskManager {
-  constructor(statePath = '.morph/state.json') {
-    this.statePath = statePath;
-  }
-
-  /**
-   * Load state.json
-   */
-  async loadState() {
-    try {
-      const content = await fs.readFile(this.statePath, 'utf-8');
-      return JSON.parse(content);
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new Error(`State file not found: ${this.statePath}. Run 'npx morph-spec state init' first.`);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Save state.json
-   */
-  async saveState(state) {
-    // v3 state uses metadata.lastUpdated, v2 used project.updatedAt
-    if (state.metadata) {
-      state.metadata.lastUpdated = new Date().toISOString();
-    } else if (state.project) {
-      state.project.updatedAt = new Date().toISOString();
-    }
-    await fs.writeFile(this.statePath, JSON.stringify(state, null, 2), 'utf-8');
-  }
+// ============================================================================
+// TaskManager
+// ============================================================================
 
+class TaskManager {
   /**
    * Complete one or more tasks (runs validation first)
    * @param {string} featureName - Feature name
@@ -191,7 +98,7 @@ class TaskManager {
    * @param {boolean} options.skipValidation - Skip code validation
    */
   async completeTasks(featureName, taskIds, options = {}) {
-    const state = await this.loadState();
+    const state = loadState();
     const feature = state.features[featureName];
 
     if (!feature) {
@@ -201,12 +108,12 @@ class TaskManager {
     const taskList = await ensureTaskList(feature, featureName);
 
     if (taskList.length === 0) {
-      const tasksPath = path.join(process.cwd(), `.morph/features/${featureName}/3-tasks/tasks.md`);
-      const tasksExist = await fs.access(tasksPath).then(() => true).catch(() => false);
+      const tasksPath = join(process.cwd(), `.morph/features/${featureName}/3-tasks/tasks.md`);
+      const tasksExist = await access(tasksPath).then(() => true).catch(() => false);
       if (!tasksExist) {
         throw new Error(`No tasks found for '${featureName}' — tasks.md not generated yet.\n  Complete the tasks phase first: run /phase-tasks`);
       }
-      throw new Error(`tasks.md found but no tasks could be parsed for '${featureName}'.\n  Ensure tasks use the format: ### T001 — Title`);
+      throw new Error(`tasks.md found but no tasks could be parsed for '${featureName}'.\n  Ensure tasks use the format: ### T001 — Title  or  ### T001: Title`);
     }
 
     const results = [];
@@ -237,13 +144,60 @@ class TaskManager {
 
     // Run validation BEFORE marking tasks as complete
     if (tasksToComplete.length > 0 && !options.skipValidation) {
-      const validationPassed = await this.runValidation(featureName);
-      if (!validationPassed) {
-        console.error(chalk.red('\n❌ Validation failed — tasks NOT marked as complete'));
-        console.log(chalk.gray('   Fix the issues above, then run task done again'));
+      const validationResult = await this.runValidation(featureName);
+      if (options.dryRun) {
+        console.log(chalk.cyan('\n  ℹ️  Dry-run — tasks NOT marked as complete'));
+        return [];
+      }
+      if (!validationResult.passed) {
+        // Reload state to ensure we have the latest (may have been modified by validation)
+        const currentState = loadState();
+        const currentFeature = currentState.features[featureName];
+        if (currentFeature) {
+          for (const task of tasksToComplete) {
+            this.persistValidationHistory(currentFeature, task.id, validationResult);
+          }
+          saveState(currentState);
+
+          // Check escalation status
+          const blockedTasks = tasksToComplete.filter(t => {
+            const hist = currentFeature.validationHistory?.[t.id];
+            return hist?.status === 'blocked';
+          });
+          if (blockedTasks.length > 0) {
+            console.error(chalk.red(`\n⛔ ESCALATION — Task(s) ${blockedTasks.map(t => t.id).join(', ')} have failed 3 times`));
+            console.error(chalk.red('   Human review required. Mark resolved with: morph-spec state set <feature> validationHistory.<taskId>.status passed'));
+          } else {
+            const attempt = currentFeature.validationHistory?.[tasksToComplete[0]?.id]?.attempt || 1;
+            console.error(chalk.red(`\n❌ Validation failed (attempt ${attempt}/3) — tasks NOT marked as complete`));
+            console.log(chalk.gray('   Fix the issues above, then run task done again'));
+            if (attempt >= 2) {
+              console.log(chalk.yellow(`   ⚠️  Next failure will escalate to human review`));
+            }
+          }
+        } else {
+          console.error(chalk.red('\n❌ Validation failed — tasks NOT marked as complete'));
+          console.log(chalk.gray('   Fix the issues above, then run task done again'));
+        }
         console.log(chalk.gray('   Or use --skip-validation to bypass (not recommended)\n'));
         process.exit(1);
       }
+
+      // Validation passed — mark any pending history as passed
+      const successState = loadState();
+      const successFeature = successState.features[featureName];
+      if (successFeature) {
+        for (const task of tasksToComplete) {
+          if (successFeature.validationHistory?.[task.id]) {
+            successFeature.validationHistory[task.id].status = 'passed';
+            successFeature.validationHistory[task.id].updatedAt = new Date().toISOString();
+          }
+        }
+        saveState(successState);
+      }
+    } else if (options.dryRun) {
+      console.log(chalk.cyan('\n  ℹ️  Dry-run — tasks NOT marked as complete (validation skipped)'));
+      return [];
     }
 
     // Breaking change detection (non-blocking warning)
@@ -296,8 +250,8 @@ class TaskManager {
       }
     }
 
-    // Save state
-    await this.saveState(state);
+    // Persist state (atomic write via state-manager)
+    saveState(state);
 
     // Run TaskCompleted agent-teams hook for each completed task (non-blocking)
     for (const task of results) {
@@ -335,9 +289,11 @@ class TaskManager {
   }
 
   /**
-   * Run validation for a feature using the ValidationRunner (ESM dynamic import)
+   * Run validation for a feature using the ValidationRunner (ESM dynamic import).
+   * Returns a structured result with per-validator breakdown for validationHistory.
+   *
    * @param {string} featureName - Feature name
-   * @returns {boolean} True if validation passed
+   * @returns {{ passed: boolean, validators: Object, passRate: number }}
    */
   async runValidation(featureName) {
     try {
@@ -347,15 +303,74 @@ class TaskManager {
       const result = await runValidation('.', featureName, { verbose: true });
 
       formatValidationResults(result);
-      return result.passed;
+
+      // Build structured validators map from result
+      const validators = {};
+      if (result.results && typeof result.results === 'object') {
+        for (const [name, vResult] of Object.entries(result.results)) {
+          const issues = (vResult.errors || []).map(e => ({
+            message: typeof e === 'string' ? e : (e.message || String(e)),
+            file: e.file,
+            line: e.line,
+            rule: e.rule,
+          }));
+          validators[name] = {
+            passed: vResult.passed ?? (issues.length === 0),
+            issues,
+          };
+        }
+      } else if (!result.passed && result.errors?.length > 0) {
+        // Flat format fallback — wrap as single 'validation' validator
+        validators['validation'] = {
+          passed: false,
+          issues: result.errors.map(e => ({
+            message: typeof e === 'string' ? e : (e.message || String(e)),
+            file: e.file,
+            line: e.line,
+            rule: e.rule || 'validation',
+          })),
+        };
+      }
+
+      const validatorEntries = Object.values(validators);
+      const passRate = validatorEntries.length > 0
+        ? validatorEntries.filter(v => v.passed).length / validatorEntries.length
+        : (result.passed ? 1.0 : 0.0);
+
+      return { passed: result.passed, validators, passRate };
     } catch (error) {
       // If validation runner fails to load, warn but don't block task completion.
       // This is fail-open by design: a broken validator shouldn't block commits.
-      // Common cause: ESM import failure on Windows or missing optional deps.
+      // Common cause: missing optional deps.
       console.log(chalk.yellow(`\n⚠️  Validation skipped (${error.message})`));
       console.log(chalk.gray('   Run manually: npx morph-spec validate --verbose'));
-      return true;
+      return { passed: true, validators: {}, passRate: 1.0 };
+    }
+  }
+
+  /**
+   * Persist a validation result to feature.validationHistory[taskId].
+   * Increments attempt counter and sets status to 'failed' or 'blocked' (attempt >= 3).
+   *
+   * @param {Object} feature - Mutable feature state object
+   * @param {string} taskId - Task ID
+   * @param {{ passed: boolean, validators: Object, passRate: number }} validationResult
+   */
+  persistValidationHistory(feature, taskId, validationResult) {
+    if (!feature.validationHistory) {
+      feature.validationHistory = {};
     }
+    const existing = feature.validationHistory[taskId] || { attempt: 0 };
+    const attempt = (existing.attempt || 0) + 1;
+    const status = attempt >= 3 ? 'blocked' : 'failed';
+
+    feature.validationHistory[taskId] = {
+      attempt,
+      validators: validationResult.validators || {},
+      passRate: validationResult.passRate || 0,
+      status,
+      updatedAt: new Date().toISOString(),
+    };
   }
 
   /**
@@ -382,13 +397,7 @@ class TaskManager {
     const pending = tasks.filter(t => t.status === 'pending').length;
     const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
 
-    return {
-      total,
-      completed,
-      inProgress,
-      pending,
-      percentage
-    };
+    return { total, completed, inProgress, pending, percentage };
   }
 
   /**
@@ -420,7 +429,6 @@ class TaskManager {
     let checkpointResult = null;
     let validationNote = '';
 
-    // Run checkpoint hooks (new enhanced validation system)
     try {
       const { runCheckpointHooks, shouldRunCheckpoint } = await import('../src/lib/checkpoints/checkpoint-hooks.js');
 
@@ -432,7 +440,6 @@ class TaskManager {
         } else {
           validationNote = ` | ✗ ${checkpointResult.summary.errors} errors, ${checkpointResult.summary.warnings} warnings`;
 
-          // Check if we should block progress
           const config = await this.loadCheckpointConfig();
           if (config.checkpoints?.onFailure?.blockProgress && checkpointResult.summary.errors > 0) {
             console.log(chalk.red('\n❌ Checkpoint FAILED - Fix violations before proceeding'));
@@ -442,7 +449,7 @@ class TaskManager {
       }
     } catch (error) {
       if (error.message === 'Checkpoint validation failed') {
-        throw error; // Re-throw to block task completion
+        throw error;
       }
       // Fallback to old validation if checkpoint-hooks not available
       console.log(chalk.yellow('⚠️  Checkpoint hooks not available, using legacy validation'));
@@ -457,7 +464,6 @@ class TaskManager {
       }
     }
 
-    // Create checkpoint record
     const checkpoint = {
       id: `CHECKPOINT_AUTO_${Date.now()}`,
       timestamp: new Date().toISOString(),
@@ -483,18 +489,16 @@ class TaskManager {
    */
   async loadCheckpointConfig() {
     try {
-      const configPath = path.join(process.cwd(), '.morph/config/llm-interaction.json');
-      const content = await fs.readFile(configPath, 'utf-8');
+      const { readFile } = await import('fs/promises');
+      const configPath = join(process.cwd(), '.morph/config/llm-interaction.json');
+      const content = await readFile(configPath, 'utf-8');
       return JSON.parse(content);
     } catch {
-      // Return defaults if config doesn't exist
       return {
         checkpoints: {
           frequency: 3,
           autoValidate: true,
-          onFailure: {
-            blockProgress: false
-          }
+          onFailure: { blockProgress: false }
         }
       };
     }
@@ -507,7 +511,6 @@ class TaskManager {
     try {
       const config = await this.loadCheckpointConfig();
 
-      // Check if auto-generation is enabled
       if (!config.metadata?.autoGenerate) {
         return;
       }
@@ -515,21 +518,14 @@ class TaskManager {
       const { extractFeatureMetadata } = await import('../src/lib/generators/metadata-extractor.js');
       const metadata = extractFeatureMetadata(feature);
 
-      const outputPath = path.join(
-        process.cwd(),
-        `.morph/features/${featureName}/metadata.json`
-      );
-
-      // Ensure directory exists
-      const outputDir = path.dirname(outputPath);
-      await fs.mkdir(outputDir, { recursive: true });
+      const outputPath = join(process.cwd(), `.morph/features/${featureName}/metadata.json`);
 
-      // Write metadata
-      await fs.writeFile(outputPath, JSON.stringify(metadata, null, 2), 'utf-8');
+      const { mkdir, writeFile } = await import('fs/promises');
+      await mkdir(dirname(outputPath), { recursive: true });
+      await writeFile(outputPath, JSON.stringify(metadata, null, 2), 'utf-8');
 
-      console.log(chalk.gray(`   📊 Metadata updated: ${path.relative(process.cwd(), outputPath)}`));
+      console.log(chalk.gray(`   📊 Metadata updated: .morph/features/${featureName}/metadata.json`));
     } catch (error) {
-      // Don't block task completion if metadata generation fails
       console.log(chalk.yellow(`   ⚠️  Metadata generation failed: ${error.message}`));
     }
   }
@@ -551,7 +547,6 @@ class TaskManager {
   getNextTask(tasks) {
     const pending = tasks.filter(t => t.status === 'pending');
 
-    // Find first task with all dependencies completed
     for (const task of pending) {
       const missingDeps = this.checkDependencies(task, tasks);
       if (missingDeps.length === 0) {
@@ -571,7 +566,6 @@ class TaskManager {
     console.log(chalk.bold(`\n📊 Progress: ${percentage}% (${completed}/${total})`));
     console.log(chalk.gray(`   Completed: ${completed} | In Progress: ${inProgress} | Pending: ${pending}`));
 
-    // Progress bar
     const barLength = 30;
     const filledLength = Math.round((percentage / 100) * barLength);
     const bar = '█'.repeat(filledLength) + '░'.repeat(barLength - filledLength);
@@ -582,7 +576,7 @@ class TaskManager {
    * Start a task (mark as in_progress)
    */
   async startTask(featureName, taskId) {
-    const state = await this.loadState();
+    const state = loadState();
     const feature = state.features[featureName];
 
     if (!feature) {
@@ -592,12 +586,12 @@ class TaskManager {
     const taskList = await ensureTaskList(feature, featureName);
 
     if (taskList.length === 0) {
-      const tasksPath = path.join(process.cwd(), `.morph/features/${featureName}/3-tasks/tasks.md`);
-      const tasksExist = await fs.access(tasksPath).then(() => true).catch(() => false);
+      const tasksPath = join(process.cwd(), `.morph/features/${featureName}/3-tasks/tasks.md`);
+      const tasksExist = await access(tasksPath).then(() => true).catch(() => false);
       if (!tasksExist) {
         throw new Error(`No tasks found for '${featureName}' — tasks.md not generated yet.\n  Complete the tasks phase first: run /phase-tasks`);
       }
-      throw new Error(`tasks.md found but no tasks could be parsed for '${featureName}'.\n  Ensure tasks use the format: ### T001 — Title`);
+      throw new Error(`tasks.md found but no tasks could be parsed for '${featureName}'.\n  Ensure tasks use the format: ### T001 — Title  or  ### T001: Title`);
     }
 
     const task = taskList.find(t => t.id === taskId);
@@ -611,7 +605,6 @@ class TaskManager {
       return;
     }
 
-    // Validate dependencies
     const missingDeps = this.checkDependencies(task, taskList);
     if (missingDeps.length > 0) {
       throw new Error(`Cannot start ${taskId}: missing dependencies: ${missingDeps.join(', ')}`);
@@ -621,16 +614,68 @@ class TaskManager {
     task.startedAt = new Date().toISOString();
     syncCounters(feature);
 
-    await this.saveState(state);
+    saveState(state);
 
     console.log(chalk.blue(`▶️  Task ${taskId} started: ${task.title}`));
   }
 
+  /**
+   * Bulk-complete tasks with a single validation pass.
+   * @param {string} featureName
+   * @param {Object} opts
+   * @param {boolean} [opts.all] - Complete all pending tasks
+   * @param {string}  [opts.from] - Start of range (e.g. T001)
+   * @param {string}  [opts.to]   - End of range (e.g. T053)
+   * @param {string}  [opts.range] - Compact range string (e.g. T001..T082)
+   * @param {boolean} [opts.skipValidation]
+   * @param {boolean} [opts.dryRun]
+   */
+  async bulkCompleteTasks(featureName, opts = {}) {
+    const state = loadState();
+    const feature = state.features[featureName];
+    if (!feature) throw new Error(`Feature '${featureName}' not found in state.json`);
+
+    const taskList = await ensureTaskList(feature, featureName);
+    if (taskList.length === 0) throw new Error(`No tasks found for '${featureName}'`);
+
+    // Resolve task IDs from range options
+    let targetIds;
+    if (opts.all) {
+      targetIds = taskList.filter(t => t.status !== 'completed').map(t => t.id);
+    } else if (opts.from && opts.to) {
+      targetIds = this.expandRange(taskList, opts.from, opts.to);
+    } else if (opts.range && opts.range.includes('..')) {
+      const [from, to] = opts.range.split('..');
+      targetIds = this.expandRange(taskList, from.trim(), to.trim());
+    } else {
+      throw new Error('bulk-done requires --all, --from/--to, or a T001..T082 range argument');
+    }
+
+    console.log(chalk.cyan(`\n📦 Bulk-done: ${targetIds.length} task(s) targeted`));
+    await this.completeTasks(featureName, targetIds, { skipValidation: opts.skipValidation, dryRun: opts.dryRun });
+  }
+
+  /**
+   * Expand a task range like T001..T053 using zero-padded numeric IDs.
+   */
+  expandRange(taskList, from, to) {
+    const numOf = id => parseInt(id.replace(/\D/g, ''), 10);
+    const prefix = from.replace(/\d+$/, '');
+    const padLen = from.replace(prefix, '').length;
+    const fromNum = numOf(from);
+    const toNum   = numOf(to);
+    const ids = [];
+    for (let n = fromNum; n <= toNum; n++) {
+      ids.push(prefix + String(n).padStart(padLen, '0'));
+    }
+    return ids.filter(id => taskList.some(t => t.id === id));
+  }
+
   /**
    * Get next task suggestion
    */
   async getNext(featureName) {
-    const state = await this.loadState();
+    const state = loadState();
     const feature = state.features[featureName];
 
     if (!feature) {
@@ -655,7 +700,10 @@ class TaskManager {
   }
 }
 
-// CLI
+// ============================================================================
+// CLI entry point
+// ============================================================================
+
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0];
@@ -667,16 +715,40 @@ async function main() {
       case 'done':
       case 'complete': {
         const skipValidation = args.includes('--skip-validation');
-        const filteredArgs = args.filter(a => a !== '--skip-validation');
+        const dryRun = args.includes('--dry-run');
+        const filteredArgs = args.filter(a => !['--skip-validation', '--dry-run'].includes(a));
         const featureName = filteredArgs[1];
         const taskIds = filteredArgs.slice(2);
 
         if (!featureName || taskIds.length === 0) {
-          console.error(chalk.red('Usage: npx morph-spec task done <feature> <task-id> [task-id...] [--skip-validation]'));
+          console.error(chalk.red('Usage: npx morph-spec task done <feature> <task-id> [task-id...] [--skip-validation] [--dry-run]'));
           process.exit(1);
         }
 
-        await manager.completeTasks(featureName, taskIds, { skipValidation });
+        await manager.completeTasks(featureName, taskIds, { skipValidation, dryRun });
+        break;
+      }
+
+      case 'bulk-done': {
+        const skipValidation = args.includes('--skip-validation');
+        const dryRun = args.includes('--dry-run');
+        const allFlag = args.includes('--all');
+        const fromIdx = args.indexOf('--from');
+        const toIdx = args.indexOf('--to');
+        const filteredArgs = args.filter(a => !['--skip-validation', '--dry-run', '--all'].includes(a)
+          && !a.startsWith('--from') && !a.startsWith('--to'));
+        const featureName = filteredArgs[1];
+        const rangeArg = filteredArgs[2]; // e.g. T001..T082
+
+        if (!featureName) {
+          console.error(chalk.red('Usage: npx morph-spec task bulk-done <feature> [--all | --from T001 --to T053 | T001..T082] [--skip-validation] [--dry-run]'));
+          process.exit(1);
+        }
+
+        const fromId = fromIdx !== -1 ? args[fromIdx + 1] : null;
+        const toId   = toIdx   !== -1 ? args[toIdx   + 1] : null;
+
+        await manager.bulkCompleteTasks(featureName, { all: allFlag, from: fromId, to: toId, range: rangeArg, skipValidation, dryRun });
         break;
       }
 
@@ -708,9 +780,13 @@ async function main() {
       default:
         console.error(chalk.red(`Unknown command: ${command}`));
         console.log(chalk.gray('\nAvailable commands:'));
-        console.log(chalk.gray('  done <feature> <task-id...>  - Mark tasks as completed'));
-        console.log(chalk.gray('  start <feature> <task-id>    - Start a task (mark as in_progress)'));
-        console.log(chalk.gray('  next <feature>               - Show next suggested task'));
+        console.log(chalk.gray('  done      <feature> <task-id...>              - Mark tasks as completed'));
+        console.log(chalk.gray('  bulk-done <feature> --all                     - Mark all pending tasks as completed'));
+        console.log(chalk.gray('  bulk-done <feature> --from T001 --to T053     - Mark range as completed'));
+        console.log(chalk.gray('  bulk-done <feature> T001..T082                - Mark range as completed'));
+        console.log(chalk.gray('  start     <feature> <task-id>                 - Start a task (mark as in_progress)'));
+        console.log(chalk.gray('  next      <feature>                           - Show next suggested task'));
+        console.log(chalk.gray('\nFlags: --skip-validation, --dry-run'));
         process.exit(1);
     }
   } catch (error) {
@@ -719,8 +795,9 @@ async function main() {
   }
 }
 
-if (require.main === module) {
+// ESM equivalent of `if (require.main === module)`
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
   main();
 }
 
-module.exports = TaskManager;
+export default TaskManager;

package/claude-plugin.json

@@ -1,14 +1,14 @@
-{
-  "name": "morph-spec",
-  "version": "4.8.12",
-  "displayName": "MORPH-SPEC Framework",
-  "description": "Spec-driven development with 38 agents and 8-phase workflow for .NET/Blazor/Next.js/Azure",
-  "publisher": "polymorphism-tech",
-  "skills": {
-    "directory": "framework/skills",
-    "namespace": "morph-spec"
-  },
-  "hooks": {
-    "directory": "framework/hooks/claude-code"
-  }
-}
+{
+  "name": "morph-spec",
+  "version": "4.8.15",
+  "displayName": "MORPH-SPEC Framework",
+  "description": "Spec-driven development with 38 agents and 8-phase workflow for .NET/Blazor/Next.js/Azure",
+  "publisher": "polymorphism-tech",
+  "skills": {
+    "directory": "framework/skills",
+    "namespace": "morph-spec"
+  },
+  "hooks": {
+    "directory": "framework/hooks/claude-code"
+  }
+}