@polymorphism-tech/morph-spec 4.21.0 → 5.0.1

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

package/src/commands/validation/validate-feature.js

@@ -35,13 +35,9 @@ const OUTPUT_SECTIONS = {
       'Performance', 'Edge Cases', 'Clarifications'
     ]
   },
-  'contracts.cs': {
-    required: ['namespace', 'record', 'interface'],
-    isCode: true
-  },
-  'schema-analysis.md': {
-    required: ['Tables Analyzed', 'Columns', 'Relationships'],
-    optional: ['CRITICAL FINDINGS', 'Recommendations', 'Indexes']
+  'mandate.md': {
+    required: ['Stack', 'Standards', 'Done'],
+    optional: ['Patterns proibidos', 'Riscos']
   },
   'decisions.md': {
     required: ['ADR', 'Status', 'Context', 'Decision'],
@@ -51,29 +47,32 @@ const OUTPUT_SECTIONS = {
     required: ['T001', 'category', 'dependencies'],
     optional: ['CHECKPOINT', 'estimatedMinutes']
   },
+  'review-report.md': {
+    required: ['Scores', 'Recommendation'],
+    optional: ['Blockers', 'Improvements']
+  },
 };
 
 /**
- * Phase-to-output mapping
+ * Phase-to-output mapping (v5 NLH)
  */
 const PHASE_OUTPUTS = {
   proposal: ['proposal.md'],
   uiux: ['design-system.md', 'mockups.md', 'components.md', 'flows.md'],
-  design: ['spec.md', 'contracts.cs', 'schema-analysis.md', 'decisions.md'],
-  tasks: ['tasks.md'],
-  implement: ['spec.md', 'contracts.cs', 'tasks.md']
+  plan: ['spec.md', 'mandate.md', 'tasks.md'],
+  implement: ['recap.md'],
+  review: ['review-report.md'],
 };
 
 /**
- * Phase-to-folder mapping (filesystem convention)
+ * Phase-to-folder mapping (v5 filesystem convention)
  */
 const PHASE_FOLDERS = {
   proposal: '0-proposal',
   uiux: '1-ui',
-  design: '2-design',
-  plan: '3-plan',
-  tasks: '4-tasks',
-  implement: '5-implement',
+  plan: '2-plan',
+  implement: '3-implement',
+  review: '4-review',
 };
 
 /**
@@ -105,13 +104,8 @@ function validateOutput(featurePath, outputFile) {
     return result;
   }
 
-  if (sections.isCode) {
-    // C# code validation
-    validateCSharpContent(content, result);
-  } else {
-    // Markdown section validation
-    validateMarkdownSections(content, sections, result);
-  }
+  // v5: only markdown outputs — contracts moved into spec.md
+  validateMarkdownSections(content, sections, result);
 
   // Size warnings
   if (result.lineCount < 10) {
@@ -143,94 +137,6 @@ function validateMarkdownSections(content, sections, result) {
   }
 }
 
-/**
- * Validate C# contracts content
- */
-function validateCSharpContent(content, result) {
-  // Check for namespace
-  if (/namespace\s+\S+/.test(content)) {
-    result.sections.found.push('namespace');
-  } else {
-    result.sections.missing.push('namespace');
-    result.errors.push('Missing namespace declaration');
-  }
-
-  // Check for records (DTOs)
-  const records = content.match(/public\s+record\s+\w+/g) || [];
-  if (records.length > 0) {
-    result.sections.found.push(`${records.length} record(s)`);
-  } else {
-    result.warnings.push('No record types found — DTOs expected');
-  }
-
-  // Check for interfaces
-  const interfaces = content.match(/public\s+interface\s+I\w+/g) || [];
-  if (interfaces.length > 0) {
-    result.sections.found.push(`${interfaces.length} interface(s)`);
-  } else {
-    result.warnings.push('No interfaces found — service contracts expected');
-  }
-
-  // Check for CancellationToken in async methods
-  const asyncMethods = content.match(/Task<.*>\s+\w+\(/g) || [];
-  const methodsWithCt = content.match(/CancellationToken\s+ct/g) || [];
-  if (asyncMethods.length > 0 && methodsWithCt.length < asyncMethods.length) {
-    result.warnings.push(
-      `${asyncMethods.length - methodsWithCt.length} async method(s) may be missing CancellationToken`
-    );
-  }
-
-  // Check for schema-analysis reference
-  if (content.includes('schema-analysis')) {
-    result.sections.found.push('schema reference');
-  } else {
-    result.warnings.push('No reference to schema-analysis.md — fields may not match database');
-  }
-}
-
-/**
- * Cross-validate contracts against schema-analysis
- */
-function crossValidateSchema(featurePath) {
-  const schemaPath = path.join(featurePath, 'schema-analysis.md');
-  const contractsPath = path.join(featurePath, 'contracts.cs');
-  const warnings = [];
-
-  if (!fs.existsSync(schemaPath) || !fs.existsSync(contractsPath)) {
-    return warnings;
-  }
-
-  const schema = fs.readFileSync(schemaPath, 'utf8');
-  const contracts = fs.readFileSync(contractsPath, 'utf8');
-
-  // Extract field names from schema (look for column names in tables)
-  const schemaFields = new Set();
-  const columnRegex = /\|\s*(\w+)\s*\|/g;
-  let match;
-  while ((match = columnRegex.exec(schema)) !== null) {
-    const field = match[1].toLowerCase();
-    if (!['column', 'name', 'type', 'nullable', 'default', 'notes', 'table', '---'].includes(field)) {
-      schemaFields.add(field);
-    }
-  }
-
-  // Extract field names from contracts
-  const contractFields = new Set();
-  const fieldRegex = /(?:string|int|Guid|DateTime|bool|decimal|JsonObject)\???\s+(\w+)/g;
-  while ((match = fieldRegex.exec(contracts)) !== null) {
-    contractFields.add(match[1].toLowerCase());
-  }
-
-  // Check for contract fields not in schema
-  for (const field of contractFields) {
-    if (schemaFields.size > 0 && !schemaFields.has(field) && field !== 'ct') {
-      warnings.push(`Contract field "${field}" not found in schema-analysis.md — verify correctness`);
-    }
-  }
-
-  return warnings;
-}
-
 /**
  * Main validate command
  */
@@ -282,7 +188,7 @@ export async function validateFeatureCommand(featureName, options = {}) {
   const results = phase
     ? outputFiles.map(file => validateOutput(searchPath, file))
     : outputFiles.map(({ file, dir }) => validateOutput(dir, file));
-  const schemaWarnings = crossValidateSchema(featurePath);
+  const schemaWarnings = []; // v5: cross-validation removed (contracts in spec.md)
 
   // Aggregate results
   const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);