@polymorphism-tech/morph-spec 4.8.14 → 4.8.16

package/README.md

@@ -3,7 +3,7 @@
 > Spec-driven development framework for multi-stack projects. Turns feature requests into implementation-ready code through structured, AI-orchestrated phases.
 
 **Package:** `@polymorphism-tech/morph-spec`
-**Version:** 4.8.14  
+**Version:** 4.8.16  
 **Requires:** Node.js 18+, Claude Code
 
 ---
@@ -376,4 +376,4 @@ Code generated by morph-spec (contracts, templates, implementation output) belon
 
 ---
 
-*morph-spec v4.8.14 by [Polymorphism Tech](https://polymorphism.tech)*
+*morph-spec v4.8.16 by [Polymorphism Tech](https://polymorphism.tech)*

package/bin/morph-spec.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { program } from 'commander';
 import chalk from 'chalk';
@@ -22,12 +22,13 @@ import { stateCommand } from '../src/commands/state/state.js';
 import { validatePhaseCommand } from '../src/commands/state/validate-phase.js';
 import { advancePhaseCommand } from '../src/commands/state/advance-phase.js';
 import { approveCommand, approvalStatusCommand, unapproveCommand } from '../src/commands/state/approve.js';
+import { phaseRunCommand } from '../src/commands/state/phase-runner.js';
 
 // Agent commands
 import { dispatchAgentsCommand } from '../src/commands/agents/dispatch-agents.js';
 
 // Task commands
-import { taskDoneCommand, taskStartCommand, taskNextCommand } from '../src/commands/tasks/task.js';
+import { taskDoneCommand, taskStartCommand, taskNextCommand, taskBulkDoneCommand } from '../src/commands/tasks/task.js';
 
 // Validation commands
 import { validateCommand } from './validate.js';
@@ -129,8 +130,19 @@ taskCommand
   .command('done <feature> <task-ids...>')
   .description('Mark tasks as completed (runs validation first)')
   .option('--skip-validation', 'Skip code validation (not recommended)')
+  .option('--dry-run', 'Show validation results without marking tasks as complete')
   .action((feature, taskIds, options) => taskDoneCommand(feature, taskIds, options));
 
+taskCommand
+  .command('bulk-done <feature> [range]')
+  .description('Bulk-complete tasks (--all | --from T001 --to T053 | T001..T082)')
+  .option('--all', 'Complete all pending tasks')
+  .option('--from <id>', 'Start task ID for range')
+  .option('--to <id>', 'End task ID for range')
+  .option('--skip-validation', 'Skip code validation (not recommended)')
+  .option('--dry-run', 'Show validation results without marking tasks as complete')
+  .action((feature, range, options) => taskBulkDoneCommand(feature, range, options));
+
 taskCommand
   .command('start <feature> <task-id>')
   .description('Start a task (mark as in_progress)')
@@ -191,6 +203,14 @@ phaseCommand
   .option('--skip-optional', 'Skip optional phases (uiux, sync)')
   .action((feature, options) => advancePhaseCommand(feature, options));
 
+phaseCommand
+  .command('run <feature>')
+  .description('Automated phase chain runner — advances phases until blocker or max reached')
+  .option('--dry-run', 'Show decision tree without executing')
+  .option('--max-phases <n>', 'Max phases to auto-advance (default: 6)', parseInt)
+  .option('--skip-approval', 'Skip approval gate checks')
+  .action((feature, options) => phaseRunCommand(feature, options));
+
 // Phase validation command (also available as standalone)
 program
   .command('validate-phase <feature> <phase>')
@@ -294,6 +314,7 @@ program
   .command('dispatch-agents <feature> <phase>')
   .description('Build dispatch config for parallel agent orchestration (design | tasks | implement)')
   .option('--table', 'Human-readable table output instead of JSON')
+  .option('--mode <mode>', 'Dispatch mode: validate (includes Tier-4 validators as read-only)')
   .option('-v, --verbose', 'Show stack trace on error')
   .action((feature, phase, options) => dispatchAgentsCommand(feature, phase, options));
 

package/bin/task-manager.js

@@ -144,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)
@@ -242,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 {
@@ -254,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: 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(),
+    };
   }
 
   /**
@@ -511,6 +619,58 @@ class TaskManager {
     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
    */
@@ -555,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, 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);
         }
 
-        await manager.completeTasks(featureName, taskIds, { skipValidation });
+        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;
       }
 
@@ -596,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) {

package/claude-plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "morph-spec",
-  "version": "4.8.14",
+  "version": "4.8.16",
   "displayName": "MORPH-SPEC Framework",
   "description": "Spec-driven development with 38 agents and 8-phase workflow for .NET/Blazor/Next.js/Azure",
   "publisher": "polymorphism-tech",

package/docs/CHEATSHEET.md

@@ -200,4 +200,4 @@ These files are never edited directly. Use CLI commands or `morph-spec update` i
 
 ---
 
-*morph-spec v4.8.14 by Polymorphism Tech*
+*morph-spec v4.8.16 by Polymorphism Tech*

package/docs/QUICKSTART.md

@@ -203,4 +203,4 @@ morph-spec doctor
 
 ---
 
-*morph-spec v4.8.14 by Polymorphism Tech*
+*morph-spec v4.8.16 by Polymorphism Tech*