@polymorphism-tech/morph-spec 4.8.14 → 4.8.15

package/src/commands/state/phase-runner.js

@@ -0,0 +1,215 @@
+/**
+ * MORPH-SPEC Phase Runner
+ *
+ * Executes an automated phase chain loop for a feature.
+ * Reads eligibility at each step, auto-advances when eligible, and
+ * pauses on blockers (blocked_tasks, low_pass_rate, trust_too_low).
+ *
+ * Usage:
+ *   morph-spec phase run <feature>
+ *   morph-spec phase run <feature> --dry-run
+ *   morph-spec phase run <feature> --max-phases 3
+ *
+ * Eligibility gates:
+ *   - Required outputs present on disk
+ *   - No blocked tasks in validationHistory
+ *   - Validation pass rate >= minPassRate (from workflow config)
+ *   - Trust level meets gate requirements (or gates already approved)
+ *
+ * Level 3 autonomy: when run with zero-touch workflow + trust=maximum,
+ * executes proposal → design → tasks → implement without human input,
+ * pausing only on escalation triggers.
+ */
+
+import chalk from 'chalk';
+import { join } from 'path';
+import { checkPhaseEligibility, computePassRate } from '../../lib/phase-chain/eligibility-checker.js';
+import { advancePhaseCommand } from './advance-phase.js';
+import { loadState } from '../../core/state/state-manager.js';
+import { derivePhase } from '../../core/state/state-manager.js';
+import { getWorkflowConfig } from '../../core/workflows/workflow-detector.js';
+
+// Phases that trigger a pause regardless of eligibility
+const PAUSE_TRIGGERS = ['blocked_tasks', 'trust_too_low'];
+
+// Maximum auto-phases before stopping (safety valve)
+const DEFAULT_MAX_PHASES = 6;
+
+/**
+ * Render a decision tree for --dry-run mode.
+ */
+function renderDecisionTree(featureName, eligibility, workflowConfig, dryRun) {
+  const { eligible, blockers, currentPhase, nextPhase, passRate } = eligibility;
+
+  console.log(chalk.cyan('\n╔════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('║       MORPH-SPEC PHASE CHAIN DECISION TREE     ║'));
+  if (dryRun) console.log(chalk.yellow('║               *** DRY RUN ***                  ║'));
+  console.log(chalk.cyan('╚════════════════════════════════════════════════╝\n'));
+
+  console.log(chalk.gray('Feature:'), featureName);
+  console.log(chalk.gray('Current Phase:'), chalk.cyan(currentPhase));
+  console.log(chalk.gray('Next Phase:'), nextPhase ? chalk.cyan(nextPhase) : chalk.gray('(final)'));
+  if (passRate !== null) {
+    const rateColor = passRate >= 0.95 ? chalk.green : passRate >= 0.80 ? chalk.yellow : chalk.red;
+    console.log(chalk.gray('Pass Rate:'), rateColor(`${(passRate * 100).toFixed(0)}%`));
+  }
+
+  if (workflowConfig?.phaseChain) {
+    console.log(chalk.gray('Phase Chain:'), chalk.green('enabled'));
+    console.log(chalk.gray('Max Auto Phases:'), workflowConfig.phaseChain.maxAutoPhases ?? DEFAULT_MAX_PHASES);
+  }
+
+  console.log();
+
+  if (eligible) {
+    console.log(chalk.green(`✓ ELIGIBLE — can advance from ${currentPhase} → ${nextPhase}`));
+  } else {
+    console.log(chalk.red(`✗ BLOCKED — cannot advance from ${currentPhase}`));
+    console.log(chalk.yellow('\n  Blockers:'));
+    for (const blocker of blockers) {
+      switch (blocker.type) {
+        case 'missing_outputs':
+          console.log(chalk.red(`    • missing_outputs: ${blocker.items.join(', ')}`));
+          break;
+        case 'blocked_tasks':
+          console.log(chalk.red(`    • blocked_tasks: ${blocker.items.join(', ')} (attempt ≥ 3, needs human review)`));
+          break;
+        case 'low_pass_rate':
+          console.log(chalk.red(`    • low_pass_rate: ${(blocker.current * 100).toFixed(0)}% (required: ${(blocker.required * 100).toFixed(0)}%)`));
+          break;
+        case 'trust_too_low':
+          console.log(chalk.yellow(`    • trust_too_low: ${blocker.items.join(', ')}`));
+          break;
+        default:
+          console.log(chalk.red(`    • ${blocker.type}: ${(blocker.items || []).join(', ')}`));
+      }
+    }
+  }
+
+  console.log();
+}
+
+/**
+ * Main command handler for `morph-spec phase run <feature>`.
+ *
+ * @param {string} featureName - Feature to run
+ * @param {Object} options
+ * @param {boolean} [options.dryRun] - Show decision tree without executing
+ * @param {number} [options.maxPhases] - Max phases to auto-advance (default: 6)
+ * @param {boolean} [options.skipApproval] - Skip approval gate checks
+ */
+export async function phaseRunCommand(featureName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Usage: morph-spec phase run <feature> [--dry-run] [--max-phases N]'));
+    process.exit(1);
+  }
+
+  const maxPhases = options.maxPhases ?? DEFAULT_MAX_PHASES;
+  const dryRun = options.dryRun ?? false;
+
+  // Load workflow config for phaseChain settings
+  const state = loadState(false);
+  const feature = state?.features?.[featureName];
+  let workflowConfig = null;
+  if (feature?.workflow && feature.workflow !== 'auto') {
+    try {
+      workflowConfig = getWorkflowConfig(feature.workflow);
+    } catch {
+      // Non-blocking
+    }
+  }
+
+  // Determine pause conditions from workflow
+  const pauseOnTypes = workflowConfig?.phaseChain?.pauseOn ?? PAUSE_TRIGGERS;
+  const autoChainMax = workflowConfig?.phaseChain?.maxAutoPhases ?? maxPhases;
+
+  if (!dryRun) {
+    console.log(chalk.cyan('\n╔════════════════════════════════════════════════╗'));
+    console.log(chalk.cyan('║         MORPH-SPEC PHASE CHAIN RUNNER          ║'));
+    console.log(chalk.cyan('╚════════════════════════════════════════════════╝\n'));
+    console.log(chalk.gray('Feature:'), featureName);
+    console.log(chalk.gray('Max auto-phases:'), autoChainMax);
+    console.log();
+  }
+
+  let phasesAdvanced = 0;
+
+  while (phasesAdvanced < autoChainMax) {
+    // ── Check eligibility ──────────────────────────────────────────────────
+    const eligibility = checkPhaseEligibility(featureName, { projectPath: process.cwd() });
+
+    // Dry-run: just show the decision tree and exit
+    if (dryRun) {
+      renderDecisionTree(featureName, eligibility, workflowConfig, true);
+      return;
+    }
+
+    // Display current state
+    console.log(chalk.gray(`[${phasesAdvanced + 1}/${autoChainMax}] Checking phase: ${eligibility.currentPhase} → ${eligibility.nextPhase || '(final)'}`));
+
+    if (!eligibility.nextPhase) {
+      console.log(chalk.green('\n✓ Feature has reached the final phase!'));
+      console.log(chalk.gray('  Consider running: morph-spec generate recap ' + featureName));
+      break;
+    }
+
+    if (!eligibility.eligible) {
+      // Check if any blocker type triggers a pause
+      const shouldPause = eligibility.blockers.some(b => pauseOnTypes.includes(b.type));
+
+      console.log(chalk.yellow(`\n⚠ Not eligible to advance (${eligibility.currentPhase} → ${eligibility.nextPhase})`));
+      for (const blocker of eligibility.blockers) {
+        switch (blocker.type) {
+          case 'missing_outputs':
+            console.log(chalk.gray(`  • Missing outputs: ${blocker.items.join(', ')}`));
+            break;
+          case 'blocked_tasks':
+            console.log(chalk.red(`  • Blocked tasks: ${blocker.items.join(', ')} — requires human review`));
+            break;
+          case 'low_pass_rate':
+            console.log(chalk.yellow(`  • Low pass rate: ${(blocker.current * 100).toFixed(0)}% < ${(blocker.required * 100).toFixed(0)}% required`));
+            break;
+          case 'trust_too_low':
+            console.log(chalk.yellow(`  • Trust too low: ${blocker.items.join(', ')}`));
+            break;
+          default:
+            console.log(chalk.gray(`  • ${blocker.type}: ${(blocker.items || []).join(', ')}`));
+        }
+      }
+
+      if (shouldPause) {
+        console.log(chalk.red('\n⛔ Pausing phase chain — human intervention required'));
+        console.log(chalk.gray('  Fix the blockers above, then re-run: morph-spec phase run ' + featureName));
+        process.exit(1);
+      }
+
+      // Non-pause blocker (e.g. missing_optional_outputs) — still stop
+      console.log(chalk.yellow('\n  Stopping chain — resolve blockers before continuing'));
+      break;
+    }
+
+    // ── Advance the phase ─────────────────────────────────────────────────
+    console.log(chalk.green(`\n✓ Eligible — advancing to ${eligibility.nextPhase}`));
+
+    try {
+      await advancePhaseCommand(featureName, {
+        skipOptional: false,
+        skipApproval: options.skipApproval,
+      });
+      phasesAdvanced++;
+    } catch (err) {
+      console.error(chalk.red(`\n✗ Phase advance failed: ${err.message}`));
+      console.log(chalk.gray('  Fix the issue and re-run: morph-spec phase run ' + featureName));
+      process.exit(1);
+    }
+  }
+
+  if (phasesAdvanced >= autoChainMax) {
+    console.log(chalk.yellow(`\n⚠ Reached max auto-phases limit (${autoChainMax})`));
+    console.log(chalk.gray('  Use --max-phases N to increase the limit'));
+  }
+
+  if (phasesAdvanced > 0 && !dryRun) {
+    console.log(chalk.cyan(`\n  ${phasesAdvanced} phase(s) advanced automatically`));
+  }
+}

package/src/commands/tasks/task.js

@@ -41,9 +41,30 @@ function executeTaskManager(args) {
 export async function taskDoneCommand(featureName, taskIds, options) {
   try {
     const args = ['done', featureName, ...taskIds];
-    if (options.skipValidation) {
-      args.push('--skip-validation');
+    if (options.skipValidation) args.push('--skip-validation');
+    if (options.dryRun) args.push('--dry-run');
+    await executeTaskManager(args);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Bulk-complete tasks command
+ */
+export async function taskBulkDoneCommand(featureName, rangeArg, options) {
+  try {
+    const args = ['bulk-done', featureName];
+    if (options.all) {
+      args.push('--all');
+    } else if (options.from && options.to) {
+      args.push('--from', options.from, '--to', options.to);
+    } else if (rangeArg) {
+      args.push(rangeArg);
     }
+    if (options.skipValidation) args.push('--skip-validation');
+    if (options.dryRun) args.push('--dry-run');
     await executeTaskManager(args);
   } catch (error) {
     console.error(chalk.red(`Error: ${error.message}`));

package/src/core/paths/output-schema.js

@@ -26,7 +26,7 @@ export const OUTPUT_SCHEMA = {
   proposal:      { filename: 'proposal.md',        phaseDir: '0-proposal',  phase: 'proposal',  protected: false },
   schemaAnalysis:{ filename: 'schema-analysis.md', phaseDir: '1-design',    phase: 'design',    protected: true,  approvalGate: 'design' },
   spec:          { filename: 'spec.md',             phaseDir: '1-design',    phase: 'design',    protected: true,  approvalGate: 'design' },
-  clarifications:{ filename: 'clarifications.md',  phaseDir: '1-design',    phase: 'clarify',   protected: false },
+  clarifications:{ filename: 'clarifications.md',  phaseDir: '2-clarify',   phase: 'clarify',   protected: false },
   contracts:     { filename: 'contracts.cs',        phaseDir: '1-design',    phase: 'design',    protected: true,  approvalGate: 'design' },
   contractsVsa:  { filename: 'contracts-vsa.cs',    phaseDir: '1-design',    phase: 'design',    protected: true,  approvalGate: 'design' },
   tasks:         { filename: 'tasks.md',            phaseDir: '3-tasks',     phase: 'tasks',     protected: true,  approvalGate: 'tasks' },

package/src/lib/generators/recap-generator.js

@@ -175,6 +175,22 @@ function buildRecapMarkdown(data) {
       }
       md += `\n`;
     }
+    md += `> **Note:** Errors above are from morph-spec static validators (may include false positives).\n`;
+    md += `> Verify actual build status with the commands in the section below.\n\n`;
+  }
+
+  // Suggested Quality Verification
+  const agents = agentsSummary;
+  const hasNextjs = agents.some(a => ['nextjs-expert', 'css-specialist', 'ui-designer'].includes(a));
+  const hasBlazor = agents.some(a => ['blazor-builder', 'blazor-specialist', 'dotnet-senior'].includes(a));
+  if (hasNextjs || hasBlazor) {
+    md += `## Suggested Quality Verification\n\n`;
+    if (hasNextjs) {
+      md += `**Next.js / TypeScript:**\n\`\`\`bash\nnpx tsc --noEmit\nnpx eslint . --max-warnings 0\n\`\`\`\n\n`;
+    }
+    if (hasBlazor) {
+      md += `**Blazor / .NET:**\n\`\`\`bash\ndotnet build\ndotnet test\n\`\`\`\n\n`;
+    }
   }
 
   // Contract Coverage