@polymorphism-tech/morph-spec 7.2.0 → 7.3.0

package/src/commands/project/status.js

@@ -1,376 +1,373 @@
-/**
- * MORPH-SPEC Feature Status Command
- *
- * Displays a comprehensive dashboard showing feature progress, phase status,
- * outputs, tasks, approvals, and next steps.
- *
- * Usage:
- *   morph-spec status <feature-name>
- *   morph-spec status <feature-name> --json
- *
- * Example:
- *   morph-spec status user-portal
- */
-
-import chalk from 'chalk';
-import { loadState, getFeature, derivePhase, deriveOutputs } from '../../core/state/state-manager.js';
-import { PHASES } from '../../lib/phase-chain/phase-validator.js';
-
-/**
- * Phase symbols for visual representation
- */
-const PHASE_SYMBOLS = {
-  completed: '✅',
-  current: '⏸️',
-  pending: '⬜',
-  skipped: '⊘'
-};
-
-/**
- * Phase definitions with order
- */
-const PHASE_ORDER = [
-  { key: 'proposal', name: 'FASE 0: PROPOSAL', order: 0 },
-  { key: 'uiux', name: 'FASE 1: UI/UX', order: 1, optional: true },
-  { key: 'plan', name: 'FASE 2: PLAN', order: 2 },
-  { key: 'implement', name: 'FASE 3: IMPLEMENT', order: 3 },
-  { key: 'review', name: 'FASE 4: REVIEW', order: 4 }
-];
-
-/**
- * Calculate phase status (completed, current, pending, skipped)
- */
-function getPhaseStatus(phaseKey, currentPhase, feature) {
-  const phase = PHASE_ORDER.find(p => p.key === phaseKey);
-  const current = PHASE_ORDER.find(p => p.key === currentPhase);
-
-  if (!phase || !current) return 'pending';
-
-  // Check if phase was skipped (optional phases)
-  if (phase.optional && phase.order < current.order) {
-    // Check if any outputs were created for this phase
-    const hasOutputs = checkPhaseOutputs(phaseKey, feature);
-    if (!hasOutputs) return 'skipped';
-  }
-
-  if (phase.order < current.order) return 'completed';
-  if (phase.order === current.order) return 'current';
-  return 'pending';
-}
-
-/**
- * Check if phase has any outputs created
- */
-function checkPhaseOutputs(phaseKey, feature) {
-  const phaseOutputMap = {
-    proposal: ['proposal', 'stackScan', 'migrationPlan'],
-    uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-    plan: ['spec', 'mandate', 'tasks', 'decisions'],
-    implement: ['recap'],
-    review: ['reviewReport']
-  };
-
-  const outputs = phaseOutputMap[phaseKey] || [];
-  return outputs.some(output => feature.outputs[output]?.created);
-}
-
-/**
- * Format phase display with symbol and status
- */
-function formatPhase(phaseKey, currentPhase, feature, options = {}) {
-  const phase = PHASE_ORDER.find(p => p.key === phaseKey);
-  const status = getPhaseStatus(phaseKey, currentPhase, feature);
-  const symbol = PHASE_SYMBOLS[status];
-
-  let display = `${symbol} ${phase.name}`;
-
-  if (phase.optional) {
-    display += ` ${chalk.gray('(optional)')}`;
-  }
-
-  if (status === 'current') {
-    display = chalk.cyan(display) + chalk.cyan(' ← CURRENT');
-  } else if (status === 'completed') {
-    display = chalk.green(display);
-  } else if (status === 'skipped') {
-    display = chalk.gray(display + ' (skipped)');
-  } else {
-    display = chalk.gray(display);
-  }
-
-  // Add output files if verbose
-  if (options.verbose && status !== 'pending' && status !== 'skipped') {
-    const phaseOutputMap = {
-      proposal: ['proposal', 'stackScan', 'migrationPlan'],
-      uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-      plan: ['spec', 'mandate', 'tasks', 'decisions'],
-      implement: ['recap'],
-      review: ['reviewReport']
-    };
-
-    const outputs = phaseOutputMap[phaseKey] || [];
-    const created = outputs.filter(o => feature.outputs[o]?.created);
-    if (created.length > 0) {
-      display += chalk.gray(`\n     Files: ${created.length}/${outputs.length}`);
-    }
-  }
-
-  return display;
-}
-
-/**
- * Calculate completion percentage
- */
-function calculateCompletionPercentage(feature) {
-  const totalPhases = PHASE_ORDER.filter(p => !p.optional).length; // 6 required phases
-  const completedPhases = PHASE_ORDER.filter(p => {
-    if (p.optional) return false;
-    const status = getPhaseStatus(p.key, feature.phase, feature);
-    return status === 'completed';
-  }).length;
-
-  return Math.round((completedPhases / totalPhases) * 100);
-}
-
-/**
- * Get next steps based on current phase
- */
-function getNextSteps(feature) {
-  const steps = [];
-
-  // Check for pending approvals relevant to current phase
-  const phaseApprovalMap = {
-    proposal: 'proposal',
-    uiux: 'uiux',
-    plan: 'plan',
-    implement: 'plan',
-    review: 'review'
-  };
-
-  const relevantGate = phaseApprovalMap[feature.phase];
-  const approvalGates = feature.approvalGates || {};
-
-  if (relevantGate && approvalGates[relevantGate] && !approvalGates[relevantGate].approved) {
-    steps.push({
-      type: 'approval',
-      message: `Approve ${relevantGate} to advance`,
-      command: `morph-spec approve ${feature.name || 'feature'} ${relevantGate}`
-    });
-  }
-
-  // Check for missing outputs in current phase
-  const phaseOutputMap = {
-    proposal: ['proposal'],
-    plan: ['spec', 'mandate', 'tasks'],
-    implement: ['recap'],
-    review: ['reviewReport']
-  };
-
-  const requiredOutputs = phaseOutputMap[feature.phase] || [];
-  const missingOutputs = requiredOutputs.filter(o => !feature.outputs[o]?.created);
-
-  if (missingOutputs.length > 0) {
-    steps.push({
-      type: 'output',
-      message: `Create missing outputs: ${missingOutputs.join(', ')}`,
-      command: null
-    });
-  }
-
-  // Suggest next phase if current is complete
-  const hasApprovalPending = relevantGate && approvalGates[relevantGate] && !approvalGates[relevantGate].approved;
-  if (missingOutputs.length === 0 && !hasApprovalPending) {
-    const currentPhaseIndex = PHASE_ORDER.findIndex(p => p.key === feature.phase);
-    if (currentPhaseIndex >= 0 && currentPhaseIndex < PHASE_ORDER.length - 1) {
-      const nextPhase = PHASE_ORDER[currentPhaseIndex + 1];
-      steps.push({
-        type: 'advance',
-        message: `Advance to ${nextPhase.name}`,
-        command: `morph-spec phase advance ${feature.name || 'feature'}`
-      });
-    } else if (currentPhaseIndex === PHASE_ORDER.length - 1) {
-      steps.push({
-        type: 'complete',
-        message: 'Feature complete! Consider archiving.',
-        command: null
-      });
-    }
-  }
-
-  return steps;
-}
-
-/**
- * Estimate remaining time based on tasks
- */
-function estimateRemainingTime(feature) {
-  if (!feature.tasks || feature.tasks.total === 0) {
-    return 'Not estimated';
-  }
-
-  const remaining = feature.tasks.total - feature.tasks.completed;
-  const avgHoursPerTask = 2; // Configurable estimate
-  const hours = remaining * avgHoursPerTask;
-
-  if (hours < 1) return '< 1 hour';
-  if (hours === 1) return '1 hour';
-  if (hours < 8) return `${hours} hours`;
-  const days = Math.ceil(hours / 8);
-  return `~${days} day${days > 1 ? 's' : ''} (${hours}h)`;
-}
-
-/**
- * Main status command
- */
-export async function statusCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('✗ Error: Feature name required'));
-    console.error(chalk.gray('Usage: morph-spec status <feature-name>'));
-    process.exit(1);
-  }
-
-  let feature;
-  try {
-    feature = getFeature(featureName);
-  } catch (err) {
-    console.error(chalk.red(`✗ Error: ${err.message}`));
-    console.error(chalk.gray('Run \'morph-spec doctor\' to diagnose or fix your state.json'));
-    process.exit(1);
-  }
-  if (!feature) {
-    console.error(chalk.red(`✗ Error: Feature '${featureName}' not found`));
-    console.error(chalk.gray(`Run 'morph-spec status' to list known features`));
-    process.exit(1);
-  }
-
-  // Derive phase and outputs from filesystem if not stored in state
-  const { join } = await import('path');
-  const featurePath = join(process.cwd(), '.morph', 'features', featureName);
-  if (!feature.phase) {
-    feature.phase = derivePhase(featurePath);
-  }
-  if (!feature.outputs) {
-    feature.outputs = deriveOutputs(featureName, process.cwd());
-  }
-
-  // JSON output mode
-  if (options.json) {
-    const status = {
-      feature: featureName,
-      phase: feature.phase,
-      status: feature.status,
-      workflow: feature.workflow,
-      completion: calculateCompletionPercentage(feature),
-      phases: PHASE_ORDER.map(p => ({
-        key: p.key,
-        name: p.name,
-        status: getPhaseStatus(p.key, feature.phase, feature),
-        optional: p.optional || false
-      })),
-      outputs: Object.entries(feature.outputs).map(([key, output]) => ({
-        type: key,
-        created: output.created,
-        path: output.path
-      })),
-      tasks: feature.tasks || { total: 0, completed: 0, inProgress: 0, pending: 0 },
-      approvals: feature.approvalGates || {},
-      nextSteps: getNextSteps(feature),
-      estimatedTimeRemaining: estimateRemainingTime(feature)
-    };
-
-    console.log(JSON.stringify(status, null, 2));
-    return;
-  }
-
-  // Visual dashboard output
-  console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
-  console.log(chalk.cyan('│                   MORPH-SPEC STATUS                       │'));
-  console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
-
-  // Feature info
-  console.log(chalk.white.bold(`Feature: ${featureName}`));
-  console.log(chalk.gray(`Status: ${feature.status || 'unknown'}`));
-  console.log(chalk.gray(`Workflow: ${feature.workflow || 'auto'}`));
-  console.log(chalk.gray(`Completion: ${calculateCompletionPercentage(feature)}%`));
-  console.log('');
-
-  // Phase progression
-  console.log(chalk.white.bold('Phases:'));
-  console.log(chalk.cyan('├─────────────────────────────────────────────────────────────┤'));
-  PHASE_ORDER.forEach(phase => {
-    console.log(`│ ${formatPhase(phase.key, feature.phase, feature, options)}`);
-  });
-  console.log(chalk.cyan('└─────────────────────────────────────────────────────────────┘'));
-  console.log('');
-
-  // Outputs summary
-  const totalOutputs = Object.keys(feature.outputs).length;
-  const createdOutputs = Object.values(feature.outputs).filter(o => o.created).length;
-  console.log(chalk.white.bold(`Outputs: ${createdOutputs}/${totalOutputs} complete`));
-
-  if (options.verbose) {
-    console.log(chalk.gray('Output files:'));
-    Object.entries(feature.outputs).forEach(([key, output]) => {
-      const symbol = output.created ? '✅' : '⬜';
-      const display = output.created ? chalk.green(key) : chalk.gray(key);
-      console.log(`  ${symbol} ${display}`);
-    });
-  }
-  console.log('');
-
-  // Tasks progress
-  if (feature.tasks && feature.tasks.total > 0) {
-    console.log(chalk.white.bold('Tasks Progress:'));
-    const { total, completed, inProgress, pending } = feature.tasks;
-    const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
-
-    console.log(`  Total: ${total}`);
-    console.log(chalk.green(`  ✓ Completed: ${completed} (${percentage}%)`));
-    if (inProgress > 0) console.log(chalk.cyan(`  ▶ In Progress: ${inProgress}`));
-    if (pending > 0) console.log(chalk.gray(`  ⬜ Pending: ${pending}`));
-    console.log(`  Estimated time remaining: ${estimateRemainingTime(feature)}`);
-    console.log('');
-  }
-
-  // Approval gates
-  if (feature.approvalGates) {
-    const gates = Object.entries(feature.approvalGates);
-    const approved = gates.filter(([_, g]) => g.approved).length;
-    console.log(chalk.white.bold(`Approval Gates: ${approved}/${gates.length} approved`));
-
-    if (options.verbose) {
-      gates.forEach(([gate, info]) => {
-        const symbol = info.approved ? '✅' : '⬜';
-        const display = info.approved ? chalk.green(gate) : chalk.gray(gate);
-        let extra = '';
-        if (info.approved && info.approvedBy) {
-          extra = chalk.gray(` (by ${info.approvedBy})`);
-        }
-        console.log(`  ${symbol} ${display}${extra}`);
-      });
-    }
-    console.log('');
-  }
-
-  // Next steps
-  const nextSteps = getNextSteps(feature);
-  if (nextSteps.length > 0) {
-    console.log(chalk.white.bold('Next Steps:'));
-    nextSteps.forEach((step, index) => {
-      console.log(chalk.yellow(`  ${index + 1}. ${step.message}`));
-      if (step.command) {
-        console.log(chalk.gray(`     → ${step.command}`));
-      }
-    });
-    console.log('');
-  } else {
-    console.log(chalk.green('✓ All tasks complete!\n'));
-  }
-
-  // Footer
-  console.log(chalk.gray('─'.repeat(60)));
-  console.log(chalk.gray('Run with --verbose for detailed output'));
-  console.log(chalk.gray('Run with --json for JSON output\n'));
-}
-
-export default statusCommand;
+/**
+ * MORPH-SPEC Feature Status Command
+ *
+ * Displays a comprehensive dashboard showing feature progress, phase status,
+ * outputs, tasks, approvals, and next steps.
+ *
+ * Usage:
+ *   morph-spec status <feature-name>
+ *   morph-spec status <feature-name> --json
+ *
+ * Example:
+ *   morph-spec status user-portal
+ */
+
+import chalk from 'chalk';
+import { loadState, getFeature, derivePhase, deriveOutputs } from '../../core/state/state-manager.js';
+
+/**
+ * Phase symbols for visual representation
+ */
+const PHASE_SYMBOLS = {
+  completed: '✅',
+  current: '⏸️',
+  pending: '⬜',
+  skipped: '⊘'
+};
+
+/**
+ * Phase definitions with order
+ */
+const PHASE_ORDER = [
+  { key: 'proposal', name: 'FASE 0: PROPOSAL', order: 0 },
+  { key: 'uiux', name: 'FASE 1: UI/UX', order: 1, optional: true },
+  { key: 'plan', name: 'FASE 2: PLAN', order: 2 },
+  { key: 'implement', name: 'FASE 3: IMPLEMENT', order: 3 },
+  { key: 'review', name: 'FASE 4: REVIEW', order: 4 }
+];
+
+/**
+ * Calculate phase status (completed, current, pending, skipped)
+ */
+function getPhaseStatus(phaseKey, currentPhase, feature) {
+  const phase = PHASE_ORDER.find(p => p.key === phaseKey);
+  const current = PHASE_ORDER.find(p => p.key === currentPhase);
+
+  if (!phase || !current) return 'pending';
+
+  // Check if phase was skipped (optional phases)
+  if (phase.optional && phase.order < current.order) {
+    // Check if any outputs were created for this phase
+    const hasOutputs = checkPhaseOutputs(phaseKey, feature);
+    if (!hasOutputs) return 'skipped';
+  }
+
+  if (phase.order < current.order) return 'completed';
+  if (phase.order === current.order) return 'current';
+  return 'pending';
+}
+
+/**
+ * Check if phase has any outputs created
+ */
+function checkPhaseOutputs(phaseKey, feature) {
+  const phaseOutputMap = {
+    proposal: ['proposal', 'stackScan', 'migrationPlan'],
+    uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
+    plan: ['spec', 'mandate', 'tasks', 'decisions'],
+    implement: ['recap'],
+    review: ['reviewReport']
+  };
+
+  const outputs = phaseOutputMap[phaseKey] || [];
+  return outputs.some(output => feature.outputs[output]?.created);
+}
+
+/**
+ * Format phase display with symbol and status
+ */
+function formatPhase(phaseKey, currentPhase, feature, options = {}) {
+  const phase = PHASE_ORDER.find(p => p.key === phaseKey);
+  const status = getPhaseStatus(phaseKey, currentPhase, feature);
+  const symbol = PHASE_SYMBOLS[status];
+
+  let display = `${symbol} ${phase.name}`;
+
+  if (phase.optional) {
+    display += ` ${chalk.gray('(optional)')}`;
+  }
+
+  if (status === 'current') {
+    display = chalk.cyan(display) + chalk.cyan(' ← CURRENT');
+  } else if (status === 'completed') {
+    display = chalk.green(display);
+  } else if (status === 'skipped') {
+    display = chalk.gray(display + ' (skipped)');
+  } else {
+    display = chalk.gray(display);
+  }
+
+  // Add output files if verbose
+  if (options.verbose && status !== 'pending' && status !== 'skipped') {
+    const phaseOutputMap = {
+      proposal: ['proposal', 'stackScan', 'migrationPlan'],
+      uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
+      plan: ['spec', 'mandate', 'tasks', 'decisions'],
+      implement: ['recap'],
+      review: ['reviewReport']
+    };
+
+    const outputs = phaseOutputMap[phaseKey] || [];
+    const created = outputs.filter(o => feature.outputs[o]?.created);
+    if (created.length > 0) {
+      display += chalk.gray(`\n     Files: ${created.length}/${outputs.length}`);
+    }
+  }
+
+  return display;
+}
+
+/**
+ * Calculate completion percentage
+ */
+function calculateCompletionPercentage(feature) {
+  const totalPhases = PHASE_ORDER.filter(p => !p.optional).length; // 6 required phases
+  const completedPhases = PHASE_ORDER.filter(p => {
+    if (p.optional) return false;
+    const status = getPhaseStatus(p.key, feature.phase, feature);
+    return status === 'completed';
+  }).length;
+
+  return Math.round((completedPhases / totalPhases) * 100);
+}
+
+/**
+ * Get next steps based on current phase
+ */
+function getNextSteps(feature) {
+  const steps = [];
+
+  // Check for pending approvals relevant to current phase
+  const phaseApprovalMap = {
+    proposal: 'proposal',
+    uiux: 'uiux',
+    plan: 'plan',
+    implement: 'plan',
+    review: 'review'
+  };
+
+  const relevantGate = phaseApprovalMap[feature.phase];
+  const approvalGates = feature.approvalGates || {};
+
+  if (relevantGate && approvalGates[relevantGate] && !approvalGates[relevantGate].approved) {
+    steps.push({
+      type: 'approval',
+      message: `Approve ${relevantGate} to advance`,
+      command: `morph-spec approve ${feature.name || 'feature'} ${relevantGate}`
+    });
+  }
+
+  // Check for missing outputs in current phase
+  const phaseOutputMap = {
+    proposal: ['proposal'],
+    plan: ['spec', 'mandate', 'tasks'],
+    implement: ['recap'],
+    review: ['reviewReport']
+  };
+
+  const requiredOutputs = phaseOutputMap[feature.phase] || [];
+  const missingOutputs = requiredOutputs.filter(o => !feature.outputs[o]?.created);
+
+  if (missingOutputs.length > 0) {
+    steps.push({
+      type: 'output',
+      message: `Create missing outputs: ${missingOutputs.join(', ')}`,
+      command: null
+    });
+  }
+
+  // Suggest next phase if current is complete
+  const hasApprovalPending = relevantGate && approvalGates[relevantGate] && !approvalGates[relevantGate].approved;
+  if (missingOutputs.length === 0 && !hasApprovalPending) {
+    const currentPhaseIndex = PHASE_ORDER.findIndex(p => p.key === feature.phase);
+    if (currentPhaseIndex >= 0 && currentPhaseIndex < PHASE_ORDER.length - 1) {
+      const nextPhase = PHASE_ORDER[currentPhaseIndex + 1];
+      steps.push({
+        type: 'advance',
+        message: `Advance to ${nextPhase.name}`,
+        command: `morph-spec phase advance ${feature.name || 'feature'}`
+      });
+    } else if (currentPhaseIndex === PHASE_ORDER.length - 1) {
+      steps.push({
+        type: 'complete',
+        message: 'Feature complete! Consider archiving.',
+        command: null
+      });
+    }
+  }
+
+  return steps;
+}
+
+/**
+ * Estimate remaining time based on tasks
+ */
+function estimateRemainingTime(feature) {
+  if (!feature.tasks || feature.tasks.total === 0) {
+    return 'Not estimated';
+  }
+
+  const remaining = feature.tasks.total - feature.tasks.completed;
+  const avgHoursPerTask = 2; // Configurable estimate
+  const hours = remaining * avgHoursPerTask;
+
+  if (hours < 1) return '< 1 hour';
+  if (hours === 1) return '1 hour';
+  if (hours < 8) return `${hours} hours`;
+  const days = Math.ceil(hours / 8);
+  return `~${days} day${days > 1 ? 's' : ''} (${hours}h)`;
+}
+
+/**
+ * Main status command
+ */
+export async function statusCommand(featureName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('✗ Error: Feature name required'));
+    console.error(chalk.gray('Usage: morph-spec status <feature-name>'));
+    process.exit(1);
+  }
+
+  let feature;
+  try {
+    feature = getFeature(featureName);
+  } catch (err) {
+    console.error(chalk.red(`✗ Error: ${err.message}`));
+    console.error(chalk.gray('Run \'morph-spec doctor\' to diagnose or fix your state.json'));
+    process.exit(1);
+  }
+  if (!feature) {
+    console.error(chalk.red(`✗ Error: Feature '${featureName}' not found`));
+    console.error(chalk.gray(`Run 'morph-spec status' to list known features`));
+    process.exit(1);
+  }
+
+  // Derive phase and outputs from filesystem if not stored in state
+  const { join } = await import('path');
+  const featurePath = join(process.cwd(), '.morph', 'features', featureName);
+  if (!feature.phase) {
+    feature.phase = derivePhase(featurePath);
+  }
+  if (!feature.outputs) {
+    feature.outputs = deriveOutputs(featureName, process.cwd());
+  }
+
+  // JSON output mode
+  if (options.json) {
+    const status = {
+      feature: featureName,
+      phase: feature.phase,
+      status: feature.status,
+      completion: calculateCompletionPercentage(feature),
+      phases: PHASE_ORDER.map(p => ({
+        key: p.key,
+        name: p.name,
+        status: getPhaseStatus(p.key, feature.phase, feature),
+        optional: p.optional || false
+      })),
+      outputs: Object.entries(feature.outputs).map(([key, output]) => ({
+        type: key,
+        created: output.created,
+        path: output.path
+      })),
+      tasks: feature.tasks || { total: 0, completed: 0, inProgress: 0, pending: 0 },
+      approvals: feature.approvalGates || {},
+      nextSteps: getNextSteps(feature),
+      estimatedTimeRemaining: estimateRemainingTime(feature)
+    };
+
+    console.log(JSON.stringify(status, null, 2));
+    return;
+  }
+
+  // Visual dashboard output
+  console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
+  console.log(chalk.cyan('│                   MORPH-SPEC STATUS                       │'));
+  console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
+
+  // Feature info
+  console.log(chalk.white.bold(`Feature: ${featureName}`));
+  console.log(chalk.gray(`Status: ${feature.status || 'unknown'}`));
+  console.log(chalk.gray(`Completion: ${calculateCompletionPercentage(feature)}%`));
+  console.log('');
+
+  // Phase progression
+  console.log(chalk.white.bold('Phases:'));
+  console.log(chalk.cyan('├─────────────────────────────────────────────────────────────┤'));
+  PHASE_ORDER.forEach(phase => {
+    console.log(`│ ${formatPhase(phase.key, feature.phase, feature, options)}`);
+  });
+  console.log(chalk.cyan('└─────────────────────────────────────────────────────────────┘'));
+  console.log('');
+
+  // Outputs summary
+  const totalOutputs = Object.keys(feature.outputs).length;
+  const createdOutputs = Object.values(feature.outputs).filter(o => o.created).length;
+  console.log(chalk.white.bold(`Outputs: ${createdOutputs}/${totalOutputs} complete`));
+
+  if (options.verbose) {
+    console.log(chalk.gray('Output files:'));
+    Object.entries(feature.outputs).forEach(([key, output]) => {
+      const symbol = output.created ? '✅' : '⬜';
+      const display = output.created ? chalk.green(key) : chalk.gray(key);
+      console.log(`  ${symbol} ${display}`);
+    });
+  }
+  console.log('');
+
+  // Tasks progress
+  if (feature.tasks && feature.tasks.total > 0) {
+    console.log(chalk.white.bold('Tasks Progress:'));
+    const { total, completed, inProgress, pending } = feature.tasks;
+    const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
+
+    console.log(`  Total: ${total}`);
+    console.log(chalk.green(`  ✓ Completed: ${completed} (${percentage}%)`));
+    if (inProgress > 0) console.log(chalk.cyan(`  ▶ In Progress: ${inProgress}`));
+    if (pending > 0) console.log(chalk.gray(`  ⬜ Pending: ${pending}`));
+    console.log(`  Estimated time remaining: ${estimateRemainingTime(feature)}`);
+    console.log('');
+  }
+
+  // Approval gates
+  if (feature.approvalGates) {
+    const gates = Object.entries(feature.approvalGates);
+    const approved = gates.filter(([_, g]) => g.approved).length;
+    console.log(chalk.white.bold(`Approval Gates: ${approved}/${gates.length} approved`));
+
+    if (options.verbose) {
+      gates.forEach(([gate, info]) => {
+        const symbol = info.approved ? '✅' : '⬜';
+        const display = info.approved ? chalk.green(gate) : chalk.gray(gate);
+        let extra = '';
+        if (info.approved && info.approvedBy) {
+          extra = chalk.gray(` (by ${info.approvedBy})`);
+        }
+        console.log(`  ${symbol} ${display}${extra}`);
+      });
+    }
+    console.log('');
+  }
+
+  // Next steps
+  const nextSteps = getNextSteps(feature);
+  if (nextSteps.length > 0) {
+    console.log(chalk.white.bold('Next Steps:'));
+    nextSteps.forEach((step, index) => {
+      console.log(chalk.yellow(`  ${index + 1}. ${step.message}`));
+      if (step.command) {
+        console.log(chalk.gray(`     → ${step.command}`));
+      }
+    });
+    console.log('');
+  } else {
+    console.log(chalk.green('✓ All tasks complete!\n'));
+  }
+
+  // Footer
+  console.log(chalk.gray('─'.repeat(60)));
+  console.log(chalk.gray('Run with --verbose for detailed output'));
+  console.log(chalk.gray('Run with --json for JSON output\n'));
+}
+
+export default statusCommand;