@polymorphism-tech/morph-spec 4.8.12 → 4.8.15

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

@@ -10,7 +10,7 @@
  */
 
 import chalk from 'chalk';
-import { loadState, saveState, getFeature, getApprovalGate } from '../../core/state/state-manager.js';
+import { loadState, saveState, getFeature, getApprovalGate, derivePhase } from '../../core/state/state-manager.js';
 import { PHASES, validatePhase } from './validate-phase.js';
 import { detectDesignSystem, hasUIAgentsActive } from '../../lib/detectors/design-system-detector.js';
 import { getOutputPath } from '../../core/paths/output-schema.js';
@@ -29,7 +29,8 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const PHASE_ORDER = ['proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
 
 /**
- * Get the next phase after the current one
+ * Get the next phase after the current one.
+ * Returns { nextPhase, skippedPhases } so callers can persist skipped phases in state.
  */
 function getNextPhase(currentPhase, feature, skipOptional, featureName) {
   // Load workflow config if workflow is set
@@ -40,9 +41,16 @@ function getNextPhase(currentPhase, feature, skipOptional, featureName) {
 
   const currentIndex = PHASE_ORDER.indexOf(currentPhase);
   if (currentIndex === -1 || currentIndex >= PHASE_ORDER.length - 1) {
-    return null;
+    return { nextPhase: null, skippedPhases: [] };
   }
 
+  // Agents that justify the uiux phase (wireframes, design system).
+  // Implementation-only agents (blazor-builder, nextjs-expert) are NOT included —
+  // they build components from existing designs but don't create the design artifacts.
+  const uiDesignAgents = ['uiux-designer', 'ui-ux-designer', 'ui-designer'];
+
+  const skippedPhases = [];
+
   for (let i = currentIndex + 1; i < PHASE_ORDER.length; i++) {
     const candidate = PHASE_ORDER[i];
     const phaseDef = PHASES[candidate];
@@ -52,6 +60,7 @@ function getNextPhase(currentPhase, feature, skipOptional, featureName) {
       // Check if workflow explicitly skips this phase
       if (workflowConfig.phases.skip && workflowConfig.phases.skip.includes(candidate)) {
         console.log(chalk.gray(`  ⏩ Skipping ${candidate}: workflow ${feature.workflow} skips this phase`));
+        skippedPhases.push(candidate);
         continue;
       }
 
@@ -60,6 +69,7 @@ function getNextPhase(currentPhase, feature, skipOptional, featureName) {
         for (const [combinedName, phases] of Object.entries(workflowConfig.phases.combined)) {
           if (phases.includes(candidate) && candidate !== combinedName) {
             console.log(chalk.gray(`  ⏩ Skipping ${candidate}: combined into ${combinedName} phase`));
+            skippedPhases.push(candidate);
             continue;
           }
         }
@@ -72,6 +82,7 @@ function getNextPhase(currentPhase, feature, skipOptional, featureName) {
           Object.keys(workflowConfig.phases.combined).includes(candidate);
         if (!isCombinedPhase) {
           console.log(chalk.gray(`  ⏩ Skipping ${candidate}: not in workflow run list`));
+          skippedPhases.push(candidate);
           continue;
         }
       }
@@ -83,6 +94,7 @@ function getNextPhase(currentPhase, feature, skipOptional, featureName) {
           // Evaluate condition (simple conditions for now)
           if (condition === '!hasUIAgents' && !hasUIAgentsActive(process.cwd(), featureName)) {
             console.log(chalk.gray(`  ⏩ Skipping ${candidate}: no UI agents active`));
+            skippedPhases.push(candidate);
             continue;
           }
         }
@@ -93,15 +105,16 @@ function getNextPhase(currentPhase, feature, skipOptional, featureName) {
     if (!workflowConfig) {
       // Skip optional phases if flag set or no relevant agents/outputs
       if (phaseDef?.optional && skipOptional) {
+        skippedPhases.push(candidate);
         continue;
       }
 
-      // Skip uiux if no UI agents are active
+      // Skip uiux if no UI design agents are active
       if (candidate === 'uiux') {
-        const uiAgents = ['blazor-builder', 'uiux-designer', 'nextjs-expert', 'ui-ux-designer'];
-        const hasUiAgent = feature.activeAgents?.some(a => uiAgents.includes(a));
-        if (!hasUiAgent && skipOptional !== false) {
-          console.log(chalk.gray(`  ⏩ Skipping ${candidate}: no UI agents active`));
+        const hasUiDesignAgent = feature.activeAgents?.some(a => uiDesignAgents.includes(a));
+        if (!hasUiDesignAgent && skipOptional !== false) {
+          console.log(chalk.gray(`  ⏩ Skipping ${candidate}: no UI design agents active`));
+          skippedPhases.push(candidate);
           continue;
         }
       }
@@ -111,15 +124,16 @@ function getNextPhase(currentPhase, feature, skipOptional, featureName) {
         const isSimple = feature.workflow === 'fast-track';
         if (isSimple && skipOptional !== false) {
           console.log(chalk.gray(`  ⏩ Skipping ${candidate}: fast-track workflow`));
+          skippedPhases.push(candidate);
           continue;
         }
       }
     }
 
-    return candidate;
+    return { nextPhase: candidate, skippedPhases };
   }
 
-  return null;
+  return { nextPhase: null, skippedPhases };
 }
 
 /**
@@ -138,7 +152,8 @@ export async function advancePhaseCommand(feature, options = {}) {
     process.exit(1);
   }
 
-  const currentPhase = featureData.phase;
+  const featureFolderPath = join(process.cwd(), '.morph', 'features', feature);
+  const currentPhase = featureData.phase || derivePhase(featureFolderPath);
   const currentPhaseDef = PHASES[currentPhase];
 
   console.log(chalk.gray('Feature:'), feature);
@@ -146,7 +161,7 @@ export async function advancePhaseCommand(feature, options = {}) {
   console.log(chalk.gray('Workflow:'), featureData.workflow || 'auto');
 
   // Determine next phase
-  const nextPhase = getNextPhase(currentPhase, featureData, options.skipOptional, feature);
+  const { nextPhase, skippedPhases } = getNextPhase(currentPhase, featureData, options.skipOptional, feature);
 
   if (!nextPhase) {
     console.log(chalk.green('\n✓ Feature is at the final phase!'));
@@ -277,7 +292,7 @@ export async function advancePhaseCommand(feature, options = {}) {
   }
 
   // === GATE 5: Tasks Content Validation ===
-  // Validate tasks.json structure when advancing to implement
+  // Validate tasks.md structure when advancing to implement
   if (currentPhase === 'tasks' && nextPhase === 'implement') {
     if (featureData.outputs?.tasks?.created) {
       const tasksContentValidation = validateTasksContent(featureData.outputs.tasks.path);
@@ -326,6 +341,10 @@ export async function advancePhaseCommand(feature, options = {}) {
   const state = loadState();
   state.features[feature].phase = nextPhase;
   state.features[feature].updatedAt = new Date().toISOString();
+  if (skippedPhases.length > 0) {
+    const existingSkipped = state.features[feature].skippedPhases || [];
+    state.features[feature].skippedPhases = [...new Set([...existingSkipped, ...skippedPhases])];
+  }
   saveState(state);
 
   // Run PhaseAdvanced agent-teams hook (non-blocking)
@@ -343,6 +362,13 @@ export async function advancePhaseCommand(feature, options = {}) {
     // Hook executor unavailable — non-blocking
   }
 
+  // Emit Tier-4 validator dispatch when advancing into implement or sync phase
+  const phasesNeedingValidation = ['implement', 'sync'];
+  if (phasesNeedingValidation.includes(nextPhase) || phasesNeedingValidation.includes(currentPhase)) {
+    const validationPhase = phasesNeedingValidation.includes(nextPhase) ? nextPhase : currentPhase;
+    await emitValidatorDispatch(feature, validationPhase, process.cwd());
+  }
+
   console.log(chalk.green(`\n✓ Advanced to ${nextPhaseDef.name}`));
 
   // Show what's needed in the new phase
@@ -447,3 +473,52 @@ function designSystemGate(feature, projectPath = '.') {
     ]
   };
 }
+
+/**
+ * Emit Tier-4 validation dispatch block after phase advance.
+ * Outputs a JSON block listing active Tier-4 validators for the LLM to dispatch
+ * as read-only subagents before proceeding to implementation.
+ * Non-blocking — fails silently.
+ *
+ * @param {string} featureName
+ * @param {string} phase
+ * @param {string} cwd
+ */
+async function emitValidatorDispatch(featureName, phase, cwd) {
+  try {
+    const { buildDispatchConfig } = await import('../agents/dispatch-agents.js');
+    const config = await buildDispatchConfig(cwd, featureName, phase, { mode: 'validate' });
+    const validators = config.agents?.filter(a => a.tier === 4);
+    if (!validators || validators.length === 0) return;
+
+    const agentsPath = join(__dirname, '../../../framework/agents.json');
+    const agentsData = JSON.parse(readFileSync(agentsPath, 'utf8'));
+    const allAgents = agentsData.agents || {};
+
+    const validatorEntries = validators.map(v => {
+      const agentData = allAgents[v.id];
+      return {
+        id: v.id,
+        title: v.title,
+        severity: agentData?.hook_behavior?.severity || 'error',
+        blocksOnFail: agentData?.hook_behavior?.blocks_on_fail ?? true,
+        checks: agentData?.hook_behavior?.validates || [],
+        taskPrompt: v.taskPrompt
+      };
+    });
+
+    const dispatch = {
+      validationRequired: true,
+      phase,
+      feature: featureName,
+      validators: validatorEntries,
+      instruction: 'Dispatch these validators as READ-ONLY subagents before continuing. Each must output { "passed": boolean, "issues": [] }. Blocking validators (blocksOnFail: true) must pass before marking phase complete.'
+    };
+
+    console.log(chalk.cyan('\n--- VALIDATION DISPATCH ---'));
+    console.log(JSON.stringify(dispatch, null, 2));
+    console.log(chalk.cyan('--- END VALIDATION DISPATCH ---\n'));
+  } catch {
+    // Non-blocking — fail silently
+  }
+}

package/src/commands/state/index.js

@@ -3,5 +3,6 @@
  */
 export { stateCommand } from './state.js';
 export { advancePhaseCommand } from './advance-phase.js';
-export { approveCommand, rejectCommand, approvalStatusCommand } from './approve.js';
+export { approveCommand, unapproveCommand, approvalStatusCommand } from './approve.js';
 export { validatePhaseCommand } from './validate-phase.js';
+export { phaseRunCommand } from './phase-runner.js';

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

@@ -1,6 +1,6 @@
 /**
  * Task management commands
- * Wrapper for bin/task-manager.js (CommonJS) to ESM
+ * Spawns bin/task-manager.js (ESM) as a subprocess.
  */
 
 import { spawn } from 'child_process';
@@ -9,7 +9,7 @@ import { dirname, join } from 'path';
 import chalk from 'chalk';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const taskManagerPath = join(__dirname, '..', '..', '..', 'bin', 'task-manager.cjs');
+const taskManagerPath = join(__dirname, '..', '..', '..', 'bin', 'task-manager.js');
 
 /**
  * Execute task-manager.js with given arguments
@@ -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,8 +26,9 @@ 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' },
   uiDesignSystem:{ filename: 'design-system.md',   phaseDir: '2-ui',        phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
   uiMockups:     { filename: 'mockups.md',          phaseDir: '2-ui',        phase: 'uiux',      protected: true,  approvalGate: 'uiux' },

package/src/lib/detectors/design-system-detector.js

@@ -136,12 +136,13 @@ export function hasUIAgentsActive(projectPath, featureName) {
       return false;
     }
 
-    // UI agents that require design system
+    // UI design agents that require a design system before implement phase.
+    // Implementation-only agents (blazor-builder, nextjs-expert, css-specialist)
+    // build from existing designs and do NOT trigger this gate.
     const uiAgents = [
-      'blazor-builder',
       'ui-designer',
-      'css-specialist',
-      'nextjs-expert'
+      'uiux-designer',
+      'ui-ux-designer',
     ];
 
     return feature.activeAgents.some(agentId => uiAgents.includes(agentId));

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