@polymorphism-tech/morph-spec 4.22.0 → 5.0.1

package/src/commands/mcp/mcp-setup.js

@@ -25,11 +25,11 @@ import {
   loadMcpRegistry,
   isRemoteMcp,
   generateStitchProxy,
-  patchConfigForPlatform
+  patchConfigForPlatform,
+  setupStitch
 } from '../../lib/installers/mcp-installer.js';
 import { detectClaudeConfig } from '../../lib/detectors/claude-config-detector.js';
 import { detectProject } from '../../lib/detectors/index.js';
-import { installMcpServers } from '../../utils/claude-settings-manager.js';
 
 /**
  * Detect the current project's stack.
@@ -207,35 +207,58 @@ async function setupSpecificMcp(targetPath, name, stack, existingMcps) {
 
   const credentials = mcpEntry.install.credentials || [];
 
-  // Stitch MCP — custom OAuth proxy setup
+  // Stitch MCP — automated setup via setupStitch()
   if (name === 'stitch' && !mcpEntry.install.autoInstall) {
-    console.log(chalk.cyan(`\n  Setting up Stitch MCP (OAuth proxy)\n`));
+    console.log(chalk.cyan(`\n  Setting up Stitch MCP (automated)\n`));
     console.log(chalk.gray(`  Usage: ${mcpEntry.usage}`));
     console.log('');
 
+    // Allow user to provide GCP project if auto-detection might fail
+    let gcpProject;
     const gcpCred = credentials.find(c => c.envVar === 'STITCH_GCP_PROJECT');
-    const { gcpProject } = await inquirer.prompt([{
+    const { gcpProjectInput } = await inquirer.prompt([{
       type: 'input',
-      name: 'gcpProject',
-      message: gcpCred ? `${gcpCred.name}:` : 'GCP Project ID:',
+      name: 'gcpProjectInput',
+      message: gcpCred ? `${gcpCred.name} (leave blank for auto-detect):` : 'GCP Project ID (blank for auto-detect):',
     }]);
-
-    if (!gcpProject || !gcpProject.trim()) {
-      console.log(chalk.red('  GCP Project ID is required.'));
-      console.log('');
-      return;
+    if (gcpProjectInput?.trim()) gcpProject = gcpProjectInput.trim();
+
+    const spinner = ora('Setting up Stitch MCP...').start();
+    const result = await setupStitch(targetPath, { gcpProject });
+
+    // Report step-by-step results
+    for (const step of result.steps) {
+      if (step.success) {
+        switch (step.step) {
+          case 'find-gcloud': spinner.text = `gcloud found (${step.source})`; break;
+          case 'verify-adc': spinner.text = 'ADC credentials verified'; break;
+          case 'detect-project': spinner.text = `GCP project: ${step.gcpProject}`; break;
+          case 'enable-api': spinner.text = 'Stitch API enabled'; break;
+          case 'generate-proxy': spinner.text = `Proxy generated: ${step.proxyPath}`; break;
+          case 'install-mcp': spinner.text = 'MCP config installed in .mcp.json'; break;
+          case 'health-check': spinner.text = `Health-check passed (protocol ${step.protocolVersion})`; break;
+        }
+      }
     }
 
-    const spinner = ora('Generating Stitch proxy...').start();
-    const { proxyPath } = generateStitchProxy(targetPath, gcpProject.trim());
-    spinner.succeed(`Proxy script generated: ${proxyPath}`);
-
-    const config = { ...mcpEntry.install.config };
-    const result = await installMcpServers(targetPath, { stitch: patchConfigForPlatform(config) });
-    if (result.added.length > 0) {
-      console.log(chalk.green(`  ✓ Stitch MCP configured (using OAuth proxy)`));
+    if (result.success) {
+      spinner.succeed('Stitch MCP setup complete');
+      for (const step of result.steps) {
+        if (step.step === 'health-check' && step.success) {
+          console.log(chalk.green(`  ✓ Health-check passed (protocol ${step.protocolVersion})`));
+        }
+      }
     } else {
-      console.log(chalk.yellow(`  ⚠ Stitch MCP already configured`));
+      const failedStep = result.steps.find(s => !s.success && s.step !== 'enable-api' && s.step !== 'health-check');
+      spinner.fail(`Stitch setup failed at: ${failedStep?.step || 'unknown'}`);
+      if (failedStep?.error) {
+        console.log(chalk.red(`  ${failedStep.error}`));
+      }
+      // Show health-check warning if it failed but setup otherwise succeeded
+      const healthStep = result.steps.find(s => s.step === 'health-check');
+      if (healthStep && !healthStep.success) {
+        console.log(chalk.yellow(`  ⚠ Health-check: ${healthStep.error}`));
+      }
     }
 
     if (mcpEntry.companionSkills?.installCommand) {
@@ -292,7 +315,7 @@ async function setupSpecificMcp(targetPath, name, stack, existingMcps) {
     const { installNow } = await inquirer.prompt([{
       type: 'confirm',
       name: 'installNow',
-      message: 'Add to .claude/settings.local.json now?',
+      message: 'Add to .mcp.json now?',
       default: true
     }]);
 
@@ -345,7 +368,7 @@ async function setupSpecificMcp(targetPath, name, stack, existingMcps) {
   } else {
     // Show config snippet
     const instructions = generateSetupInstructions(name, mcpEntry);
-    console.log(chalk.gray('\n  Add to .claude/settings.local.json → mcpServers:'));
+    console.log(chalk.gray('\n  Add to .mcp.json → mcpServers:'));
     console.log(chalk.gray('  ' + '─'.repeat(55)));
     for (const line of instructions.configSnippet.split('\n')) {
       console.log(chalk.gray(`  ${line}`));
@@ -424,20 +447,24 @@ async function interactiveWizard(targetPath, stack, existingMcps) {
       }]);
 
       if (setupNow) {
-        // Stitch — custom OAuth proxy flow
+        // Stitch — automated setup via setupStitch()
         if (name === 'stitch' && !entry.install.autoInstall) {
           const gcpCred = entry.install.credentials?.find(c => c.envVar === 'STITCH_GCP_PROJECT');
           const { gcpProject } = await inquirer.prompt([{
             type: 'input',
             name: 'gcpProject',
-            message: gcpCred ? `${gcpCred.name}:` : 'GCP Project ID:',
+            message: gcpCred ? `${gcpCred.name} (blank for auto-detect):` : 'GCP Project ID (blank for auto-detect):',
           }]);
-          if (gcpProject?.trim()) {
-            const { proxyPath } = generateStitchProxy(targetPath, gcpProject.trim());
-            console.log(chalk.green(`  ✓ Proxy generated: ${proxyPath}`));
-            const config = { ...entry.install.config };
-            await installMcpServers(targetPath, { stitch: patchConfigForPlatform(config) });
-            console.log(chalk.green(`  ✓ Stitch configured (OAuth proxy)`));
+
+          const stitchSpinner = ora('Setting up Stitch MCP...').start();
+          const stitchResult = await setupStitch(targetPath, { gcpProject: gcpProject?.trim() || undefined });
+          if (stitchResult.success) {
+            stitchSpinner.succeed('Stitch MCP setup complete');
+          } else {
+            const failedStep = stitchResult.steps.find(s => !s.success && s.step !== 'enable-api' && s.step !== 'health-check');
+            stitchSpinner.fail(`Stitch setup failed: ${failedStep?.error || 'unknown'}`);
+          }
+          if (entry.companionSkills?.installCommand) {
             const skillResults = installCompanionSkills({ stitch: entry });
             for (const r of skillResults) {
               if (r.success) console.log(chalk.green(`  ✓ Companion skills: ${r.repo}`));

package/src/commands/project/doctor.js

@@ -68,30 +68,23 @@ function getNpmGlobalPrefix() {
   }
 }
 
-// lib files
+// lib files (v5 — minimal surface)
 const REQUIRED_LIB_FILES = [
-  'src/lib/trust/trust-manager.js'
+  'src/lib/stack-filter.js'
 ];
 
-// command files (current CLI surface after radical simplification)
+// command files (v5 CLI surface — installer-only)
 const REQUIRED_COMMAND_FILES = [
   'src/commands/project/init.js',
   'src/commands/project/update.js',
   'src/commands/project/doctor.js',
   'src/commands/project/status.js',
-  'src/commands/state/state.js',
-  'src/commands/state/advance-phase.js',
+  'src/commands/project/worktree.js',
   'src/commands/state/approve.js',
-  'src/commands/tasks/task.js',
-  'src/commands/trust/trust.js',
   'src/commands/validation/validate-feature.js',
-  'src/commands/templates/template-render.js',
-  'src/commands/agents/dispatch-agents.js',
-  'src/commands/project/worktree.js',
-  'src/commands/phase/phase-reset.js',
-  'src/commands/scope/escalate.js',
-  'src/commands/task/expand.js',
-  'src/lib/scope/impact-analyzer.js'
+  'src/commands/scaffold/scaffold.js',
+  'src/commands/mcp/mcp-setup.js',
+  'src/commands/context/context-refresh.js',
 ];
 
 // framework standards (stack-relevant only)
@@ -105,9 +98,9 @@ const FRAMEWORK_STANDARDS = [
   'framework/standards/workflows/parallel-execution.md'
 ];
 
-// required agents expected in agents.json
+// required personas expected in agents.json (v5 — at least the universal evaluator)
 const REQUIRED_AGENTS = [
-  'vector-search-expert'
+  'evaluator'
 ];
 
 /**
@@ -211,7 +204,7 @@ async function doctorFullCommand(frameworkRoot) {
       check('state.json parse', false, false, 'invalid JSON');
     }
   } else {
-    check('state.json', false, true, 'not found (run: morph-spec state init)');
+    check('state.json', false, true, 'not found (run: morph-spec init)');
   }
 
   // ── Display ──────────────────────────────────────────────────────────────
@@ -242,8 +235,8 @@ async function doctorFullCommand(frameworkRoot) {
 }
 
 /**
- * MCP health check: reads settings.json / settings.local.json and validates
- * each configured MCP server's command binary and env var requirements.
+ * MCP health check: reads .mcp.json, settings.json, and settings.local.json
+ * and validates each configured MCP server's command binary and env var requirements.
  *
  * Strategy:
  *  - "ok"   : command binary exists (or is a known runtime like npx/node) AND
@@ -258,23 +251,43 @@ async function doctorMcpCommand(targetPath) {
   logger.header('MCP Server Health Check');
   logger.blank();
 
+  const allMcpServers = {};
+  const sourcesFound = [];
+
+  // Primary: .mcp.json (Claude Code reads MCPs from here)
+  const mcpJsonPath = join(targetPath, '.mcp.json');
+  if (await pathExists(mcpJsonPath)) {
+    try {
+      const mcpJson = JSON.parse(await fs.readFile(mcpJsonPath, 'utf8'));
+      const mcps = mcpJson.mcpServers || {};
+      const count = Object.keys(mcps).length;
+      if (count > 0) {
+        Object.assign(allMcpServers, mcps);
+        sourcesFound.push(`.mcp.json (${count})`);
+      }
+    } catch { /* invalid JSON — ignore */ }
+  }
+
+  // Legacy: settings files (for backward compat)
   const settingsPaths = [
     join(targetPath, '.claude', 'settings.json'),
     join(targetPath, '.claude', 'settings.local.json'),
   ];
 
-  const allMcpServers = {};
-  const sourcesFound = [];
-
   for (const sp of settingsPaths) {
     if (await pathExists(sp)) {
       try {
         const settings = JSON.parse(await fs.readFile(sp, 'utf8'));
         const mcps = settings.mcpServers || {};
-        const count = Object.keys(mcps).length;
-        if (count > 0) {
-          Object.assign(allMcpServers, mcps);
-          sourcesFound.push(`${relative(targetPath, sp)} (${count})`);
+        let addedCount = 0;
+        for (const [name, config] of Object.entries(mcps)) {
+          if (!allMcpServers[name]) {
+            allMcpServers[name] = config;
+            addedCount++;
+          }
+        }
+        if (addedCount > 0) {
+          sourcesFound.push(`${relative(targetPath, sp)} (${addedCount})`);
         }
       } catch { /* invalid JSON — ignore */ }
     }
@@ -283,7 +296,7 @@ async function doctorMcpCommand(targetPath) {
   if (Object.keys(allMcpServers).length === 0) {
     logger.warn('No MCP servers configured');
     logger.blank();
-    logger.dim('Configure MCPs in: .claude/settings.json → mcpServers: { ... }');
+    logger.dim('Configure MCPs in: .mcp.json → mcpServers: { ... }');
     logger.dim('Or use: morph-spec mcp setup');
     return;
   }
@@ -564,77 +577,63 @@ export async function doctorCommand(options = {}) {
         checks.push({ name: 'agents.json count', status: 'ok', msg: `${actualCount} agents` });
       }
 
-      // Check 2: required tier-2 agents present
-      const requiredTier2 = ['standards-architect', 'dotnet-senior', 'infra-architect'];
-      const missingTier2 = requiredTier2.filter(id => !agentsData.agents[id]);
-      if (missingTier2.length > 0) {
+      // Check 2: required v5 personas present
+      const requiredPersonas = REQUIRED_AGENTS;
+      const missingPersonas = requiredPersonas.filter(id => !agentsData.agents[id]);
+      if (missingPersonas.length > 0) {
         checks.push({
-          name: 'agents.json required agents',
+          name: 'agents.json required personas',
           status: 'error',
-          msg: `Missing required agents: ${missingTier2.join(', ')}`
+          msg: `Missing required personas: ${missingPersonas.join(', ')}`
         });
         hasErrors = true;
       } else {
-        checks.push({ name: 'agents.json required agents', status: 'ok' });
-      }
-
-      // Check 3: tier counts sum matches total
-      const tierCounts = [1, 2, 3, 4].map(t =>
-        agentEntries.filter(([, v]) => v.tier === t).length
-      );
-      const tierSum = tierCounts.reduce((a, b) => a + b, 0);
-      if (tierSum !== actualCount) {
-        checks.push({
-          name: 'agents.json tier counts',
-          status: 'warn',
-          msg: `Tier counts sum to ${tierSum} but total is ${actualCount}`
-        });
-        hasWarnings = true;
-      } else {
-        checks.push({ name: 'agents.json tier counts', status: 'ok' });
+        checks.push({ name: 'agents.json required personas', status: 'ok' });
       }
 
-      // Check 4: v4 schema validation
+      // Check 3: v5 schema validation (flat personas, no tiers)
       const version = agentsData.version || 'unknown';
-      const isV4 = version.startsWith('4.');
-      const v3Fields = [];
-      const missingV4Fields = [];
+      const isV5 = version.startsWith('5.');
+      const v4Fields = [];
+      const missingV5Fields = [];
 
       for (const [id, data] of agentEntries) {
-        if (data.role !== undefined) v3Fields.push(`${id}.role`);
-        if (data.always_active !== undefined) v3Fields.push(`${id}.always_active`);
-        if (data.relationships !== undefined) v3Fields.push(`${id}.relationships`);
-        if (!data.group) missingV4Fields.push(`${id}.group`);
-        if (!Array.isArray(data.active_phases)) missingV4Fields.push(`${id}.active_phases`);
+        if (data.tier !== undefined) v4Fields.push(`${id}.tier`);
+        if (data.active_phases !== undefined) v4Fields.push(`${id}.active_phases`);
+        if (data.reports_to !== undefined) v4Fields.push(`${id}.reports_to`);
+        if (data.teammate !== undefined) v4Fields.push(`${id}.teammate`);
+        if (!data.title) missingV5Fields.push(`${id}.title`);
+        if (!Array.isArray(data.domains)) missingV5Fields.push(`${id}.domains`);
+        if (typeof data.persona !== 'string' || !data.persona) missingV5Fields.push(`${id}.persona`);
       }
 
-      if (isV4) {
+      if (isV5) {
         checks.push({ name: `agents.json schema (v${version})`, status: 'ok' });
       } else {
         checks.push({
           name: `agents.json schema (v${version})`,
           status: 'warn',
-          msg: 'expected v4.x — run agents migration'
+          msg: 'expected v5.x — run agents migration'
         });
         hasWarnings = true;
       }
 
-      if (v3Fields.length > 0) {
-        const sample = v3Fields.slice(0, 3).join(', ');
+      if (v4Fields.length > 0) {
+        const sample = v4Fields.slice(0, 3).join(', ');
         checks.push({
-          name: 'agents.json deprecated fields',
+          name: 'agents.json deprecated v4 fields',
           status: 'warn',
-          msg: `${v3Fields.length} v3 field(s) found: ${sample}${v3Fields.length > 3 ? '...' : ''}`
+          msg: `${v4Fields.length} v4 field(s) found: ${sample}${v4Fields.length > 3 ? '...' : ''}`
         });
         hasWarnings = true;
       }
 
-      if (missingV4Fields.length > 0 && isV4) {
-        const sample = missingV4Fields.slice(0, 3).join(', ');
+      if (missingV5Fields.length > 0 && isV5) {
+        const sample = missingV5Fields.slice(0, 3).join(', ');
         checks.push({
-          name: 'agents.json v4 required fields',
+          name: 'agents.json v5 required fields',
           status: 'warn',
-          msg: `${missingV4Fields.length} missing: ${sample}${missingV4Fields.length > 3 ? '...' : ''}`
+          msg: `${missingV5Fields.length} missing: ${sample}${missingV5Fields.length > 3 ? '...' : ''}`
         });
         hasWarnings = true;
       }
@@ -853,7 +852,7 @@ export async function doctorCommand(options = {}) {
       hasErrors = true;
     }
   } else {
-    checks.push({ name: 'state.json', status: 'warn', msg: 'not initialized (run: morph-spec state init)' });
+    checks.push({ name: 'state.json', status: 'warn', msg: 'not initialized (run: morph-spec init)' });
     hasWarnings = true;
   }
 

package/src/commands/project/init.js

@@ -24,7 +24,8 @@ import {
   installMcpWithCredentials,
   generateSetupInstructions,
   formatMcpStatusTable,
-  isRemoteMcp
+  isRemoteMcp,
+  setupStitch
 } from '../../lib/installers/mcp-installer.js';
 import { setupInfra, installRulesForStack } from '../../scripts/setup-infra.js';
 import { installSkills } from '../../utils/skills-installer.js';
@@ -209,7 +210,7 @@ export async function initCommand(options) {
             // Skills
             await installSkills(targetPath, { projectTags: stackTags });
 
-            // Agents (tier 1/2/4 from agents.json + domain agents)
+            // Agents (domain personas from agents.json)
             await installAgents(targetPath, fwSrcDir, { projectTags: stackTags });
             await installDomainAgents(targetPath, fwSrcDir, { projectTags: stackTags });
 
@@ -290,6 +291,26 @@ export async function initCommand(options) {
               }]);
 
               if (setupNow) {
+                // Stitch — automated setup via setupStitch()
+                if (name === 'stitch' && !entry.install.autoInstall) {
+                  spinner.start('Setting up Stitch MCP...');
+                  const stitchResult = await setupStitch(targetPath);
+                  if (stitchResult.success) {
+                    spinner.succeed('Stitch MCP setup complete');
+                    manualInstalled[name] = entry;
+                  } else {
+                    const failedStep = stitchResult.steps.find(s => !s.success && s.step !== 'enable-api' && s.step !== 'health-check');
+                    spinner.fail(`Stitch setup failed: ${failedStep?.error || 'unknown'}`);
+                  }
+                  if (entry.companionSkills?.installCommand) {
+                    const skillResults = installCompanionSkills({ stitch: entry });
+                    for (const r of skillResults) {
+                      if (r.success) logger.success(`  Companion skills installed: ${r.repo}`);
+                    }
+                  }
+                  continue;
+                }
+
                 // Remote MCPs — launch OAuth via claude mcp add
                 if (isRemoteMcp(entry.install.config)) {
                   const url = entry.install.config.url;
@@ -327,7 +348,7 @@ export async function initCommand(options) {
                 // Show setup instructions
                 const instructions = generateSetupInstructions(name, entry);
                 logger.blank();
-                logger.dim('  Add to .claude/settings.local.json → mcpServers:');
+                logger.dim('  Add to .mcp.json → mcpServers:');
                 logger.dim('  ' + '─'.repeat(55));
                 for (const line of instructions.configSnippet.split('\n')) {
                   logger.dim(`  ${line}`);
@@ -434,8 +455,8 @@ export async function initCommand(options) {
     // Show agent team breakdown from setup-infra result
     const agents = infraResult?.agents;
     if (agents) {
-      const total = agents.tier1 + agents.tier2 + agents.specialists;
-      logger.dim(`  ✓ .claude/agents/ (${total} agents: ${agents.tier1} orchestrators, ${agents.tier2} domain leaders, ${agents.specialists} specialists)`);
+      const total = (agents.tier1 || 0) + (agents.tier2 || 0) + (agents.specialists || 0) + (agents.personas || 0);
+      logger.dim(`  ✓ .claude/agents/ (${total} domain personas installed)`);
     } else {
       logger.dim('  ✓ .claude/agents/ (native subagents installed)');
     }

package/src/commands/project/status.js

@@ -32,11 +32,9 @@ const PHASE_SYMBOLS = {
 const PHASE_ORDER = [
   { key: 'proposal', name: 'FASE 0: PROPOSAL', order: 0 },
   { key: 'uiux', name: 'FASE 1: UI/UX', order: 1, optional: true },
-  { key: 'design', name: 'FASE 2: DESIGN', order: 2 },
-  { key: 'plan', name: 'FASE 3: PLAN', order: 3 },
-  { key: 'tasks', name: 'FASE 4: TASKS', order: 4 },
-  { key: 'implement', name: 'FASE 5: IMPLEMENT', order: 5 },
-  { key: 'sync', name: 'FASE 6: SYNC', order: 6, 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 }
 ];
 
 /**
@@ -65,10 +63,11 @@ function getPhaseStatus(phaseKey, currentPhase, feature) {
  */
 function checkPhaseOutputs(phaseKey, feature) {
   const phaseOutputMap = {
-    proposal: ['proposal'],
+    proposal: ['proposal', 'stackScan', 'migrationPlan'],
     uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-    design: ['spec', 'contracts', 'schemaAnalysis', 'decisions'],
-    tasks: ['tasks']
+    plan: ['spec', 'mandate', 'tasks', 'decisions'],
+    implement: ['recap'],
+    review: ['reviewReport']
   };
 
   const outputs = phaseOutputMap[phaseKey] || [];
@@ -102,11 +101,11 @@ function formatPhase(phaseKey, currentPhase, feature, options = {}) {
   // Add output files if verbose
   if (options.verbose && status !== 'pending' && status !== 'skipped') {
     const phaseOutputMap = {
-      proposal: ['proposal'],
+      proposal: ['proposal', 'stackScan', 'migrationPlan'],
       uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-      design: ['spec', 'contracts', 'schemaAnalysis', 'decisions'],
-      tasks: ['tasks'],
-      implement: ['recap']
+      plan: ['spec', 'mandate', 'tasks', 'decisions'],
+      implement: ['recap'],
+      review: ['reviewReport']
     };
 
     const outputs = phaseOutputMap[phaseKey] || [];
@@ -143,9 +142,9 @@ function getNextSteps(feature) {
   const phaseApprovalMap = {
     proposal: 'proposal',
     uiux: 'uiux',
-    design: 'design',
-    tasks: 'tasks',
-    implement: 'tasks'
+    plan: 'plan',
+    implement: 'plan',
+    review: 'review'
   };
 
   const relevantGate = phaseApprovalMap[feature.phase];
@@ -162,9 +161,9 @@ function getNextSteps(feature) {
   // Check for missing outputs in current phase
   const phaseOutputMap = {
     proposal: ['proposal'],
-    design: ['spec', 'contracts'],
-    tasks: ['tasks'],
-    implement: ['recap']
+    plan: ['spec', 'mandate', 'tasks'],
+    implement: ['recap'],
+    review: ['reviewReport']
   };
 
   const requiredOutputs = phaseOutputMap[feature.phase] || [];
@@ -240,7 +239,7 @@ export async function statusCommand(featureName, options = {}) {
   }
   if (!feature) {
     console.error(chalk.red(`✗ Error: Feature '${featureName}' not found`));
-    console.error(chalk.gray(`Run 'morph-spec state get ${featureName}' to check if feature exists`));
+    console.error(chalk.gray(`Run 'morph-spec status' to list known features`));
     process.exit(1);
   }
 

package/src/commands/state/approve.js

@@ -54,7 +54,7 @@ const program = new Command();
 /**
  * Valid approval gate names
  */
-const VALID_GATES = ['proposal', 'uiux', 'design', 'plan', 'tasks'];
+const VALID_GATES = ['proposal', 'uiux', 'plan', 'review'];
 
 /**
  * Approve action function - Mark a gate as approved