@polymorphism-tech/morph-spec 4.3.7 → 4.5.0

package/src/commands/project/standards.js

@@ -0,0 +1,80 @@
+/**
+ * Standards CLI Commands
+ *
+ * Provides browsable access to the framework standards registry.
+ * Usage:
+ *   morph-spec standards --list
+ *   morph-spec standards --search <query>
+ *   morph-spec standards --show <id>
+ *   morph-spec standards --category <cat>
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { logger } from '../../utils/logger.js';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const REGISTRY_PATH = join(__dirname, '..', '..', '..', 'framework', 'standards', 'STANDARDS.json');
+
+function loadRegistry() {
+  return JSON.parse(readFileSync(REGISTRY_PATH, 'utf8')).standards;
+}
+
+/**
+ * List all standards, optionally filtered by category.
+ * @param {{ json?: boolean, category?: string }} opts
+ * @returns {Promise<Array>}
+ */
+export async function listStandards({ json, category } = {}) {
+  let standards = loadRegistry();
+  if (category) {
+    standards = standards.filter(s => s.category === category);
+  }
+  if (json) return standards;
+  standards.forEach(s =>
+    logger.info(`${s.id.padEnd(55)} ${s.category}`)
+  );
+  return standards;
+}
+
+/**
+ * Search standards by query string (matches id, name, or tags).
+ * @param {string} query
+ * @param {{ json?: boolean }} opts
+ * @returns {Promise<Array>}
+ */
+export async function searchStandards(query, { json } = {}) {
+  const q = query.toLowerCase();
+  const results = loadRegistry().filter(s =>
+    s.name.toLowerCase().includes(q) ||
+    s.id.toLowerCase().includes(q) ||
+    s.tags.some(t => t.toLowerCase().includes(q))
+  );
+  if (json) return results;
+  if (results.length === 0) {
+    logger.warn(`No standards found matching "${query}"`);
+  } else {
+    results.forEach(s => logger.info(`${s.id}: ${s.name}  [${s.category}]`));
+  }
+  return results;
+}
+
+/**
+ * Show the full content of a standard by its id.
+ * @param {string} id
+ * @returns {Promise<string|null>}
+ */
+export async function showStandard(id) {
+  const standard = loadRegistry().find(s => s.id === id);
+  if (!standard) {
+    logger.error(`Standard '${id}' not found. Use --list to see available standards.`);
+    return null;
+  }
+  const content = readFileSync(
+    join(__dirname, '..', '..', '..', 'framework', 'standards', standard.path),
+    'utf8'
+  );
+  logger.info(content);
+  return content;
+}

package/src/commands/project/status.js

@@ -0,0 +1,376 @@
+/**
+ * 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 '../state/validate-phase.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: 'setup', name: 'FASE 1: SETUP', order: 1 },
+  { key: 'uiux', name: 'FASE 1.5: UI/UX', order: 2, optional: true },
+  { key: 'design', name: 'FASE 2: DESIGN', order: 3 },
+  { key: 'clarify', name: 'FASE 3: CLARIFY', order: 4 },
+  { key: 'tasks', name: 'FASE 4: TASKS', order: 5 },
+  { key: 'implement', name: 'FASE 5: IMPLEMENT', order: 6 },
+  { key: 'sync', name: 'FASE 6: SYNC', order: 7, optional: true }
+];
+
+/**
+ * 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'],
+    uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
+    design: ['spec', 'contracts', 'schemaAnalysis', 'decisions'],
+    clarify: ['clarifications'],
+    tasks: ['tasks']
+  };
+
+  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'],
+      uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
+      design: ['spec', 'contracts', 'schemaAnalysis', 'decisions'],
+      clarify: ['clarifications'],
+      tasks: ['tasks'],
+      implement: ['recap']
+    };
+
+    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',
+    setup: 'proposal',
+    uiux: 'uiux',
+    design: 'design',
+    clarify: 'design',
+    tasks: 'tasks',
+    implement: 'tasks'
+  };
+
+  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'],
+    design: ['spec', 'contracts'],
+    clarify: ['clarifications'],
+    tasks: ['tasks'],
+    implement: ['recap']
+  };
+
+  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);
+  }
+
+  const feature = getFeature(featureName);
+  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`));
+    process.exit(1);
+  }
+
+  // Derive phase and outputs from filesystem if not stored in state (v5.0.0+)
+  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;

package/src/commands/project/update-agents.js

@@ -0,0 +1,23 @@
+/**
+ * update-agents command
+ *
+ * Refreshes .claude/agents/ with the latest tier-1 and tier-2 MORPH agents
+ * from the framework. Useful after upgrading morph-spec to pick up new or
+ * updated agent definitions without re-running full init.
+ */
+
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { installAgents } from '../../utils/agents-installer.js';
+import { logger } from '../../utils/logger.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FRAMEWORK_DIR = join(__dirname, '..', '..', '..', 'framework');
+
+export async function updateAgentsCommand(args, options) {
+  const projectDir = process.cwd();
+
+  logger.info('Updating native subagents in .claude/agents/...');
+  await installAgents(projectDir, FRAMEWORK_DIR);
+  logger.success('Native subagents updated. Claude Code will discover them on next session start.');
+}

package/src/commands/project/update.js

@@ -1,5 +1,7 @@
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 import fs from 'fs-extra';
@@ -24,7 +26,9 @@ import {
   getUpdateInstructions,
   detectInstallMethod
 } from '../../utils/version-checker.js';
-import { installClaudeHooks } from '../../utils/hooks-installer.js';
+import { installClaudeHooks } from '../../utils/claude-settings-manager.js';
+import { installSkills } from '../../utils/skills-installer.js';
+import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
 import { AutoContextOrchestrator } from '../../core/orchestrator.js';
 import { detectClaudeCode } from '../../llm/environment-detector.js';
 
@@ -53,8 +57,8 @@ async function backupUserConfig(morphPath) {
  */
 async function cleanFrameworkDirs(morphPath, targetPath) {
   const dirsToClean = [
-    join(morphPath, 'templates'),
-    join(morphPath, 'standards'),
+    join(morphPath, 'framework', 'templates'),
+    join(morphPath, 'framework', 'standards'),
     join(morphPath, 'config'),
     join(targetPath, '.claude')
   ];
@@ -115,9 +119,9 @@ export async function updateCommand(options) {
     needsInitialization = true;
 
     // Create basic .morph structure
-    await ensureDir(join(morphPath, 'project', 'context'));
-    await ensureDir(join(morphPath, 'project', 'standards'));
-    await ensureDir(join(morphPath, 'project', 'outputs'));
+    await ensureDir(join(morphPath, 'context'));
+    await ensureDir(join(morphPath, 'features'));
+    await ensureDir(join(morphPath, 'framework'));
     await ensureDir(join(morphPath, 'config'));
     logger.dim('  ✓ Created .morph directory structure');
   }
@@ -194,7 +198,7 @@ export async function updateCommand(options) {
     if (updateTemplates) {
       updateSpinner.text = 'Updating templates...';
       const templatesSrc = join(contentDir, 'framework', 'templates');
-      const templatesDest = join(morphPath, 'templates');
+      const templatesDest = join(morphPath, 'framework', 'templates');
       await copyDirectory(templatesSrc, templatesDest);
     }
 
@@ -202,30 +206,31 @@ export async function updateCommand(options) {
     if (updateStandards) {
       updateSpinner.text = 'Updating standards...';
       const standardsSrc = join(contentDir, 'framework', 'standards');
-      const standardsDest = join(morphPath, 'standards');
+      const standardsDest = join(morphPath, 'framework', 'standards');
       await copyDirectory(standardsSrc, standardsDest);
     }
 
     // Update agents.json (sourced from framework/ — canonical single source of truth)
     updateSpinner.text = 'Updating agents configuration...';
     const agentsSrc = join(__dirname, '..', '..', '..', 'framework', 'agents.json');
-    const agentsDest = join(morphPath, 'config', 'agents.json');
+    const agentsDest = join(morphPath, 'framework', 'agents.json');
     if (await pathExists(agentsSrc)) {
       await copyFile(agentsSrc, agentsDest);
     }
 
-    // Update azure-pricing files
-    updateSpinner.text = 'Updating Azure pricing data...';
-    const configDir = join(morphPath, 'config');
-    const pricingSrc = join(contentDir, '.morph', 'config', 'azure-pricing.json');
-    const pricingDest = join(configDir, 'azure-pricing.json');
-    if (await pathExists(pricingSrc)) {
-      await copyFile(pricingSrc, pricingDest);
-    }
-    const pricingSchemaSrc = join(contentDir, '.morph', 'config', 'azure-pricing.schema.json');
-    const pricingSchemaDest = join(configDir, 'azure-pricing.schema.json');
-    if (await pathExists(pricingSchemaSrc)) {
-      await copyFile(pricingSchemaSrc, pricingSchemaDest);
+    // Regenerate derived files (phase-utils.js, skill output tables) from output-schema.js
+    // Only runs when the generator script is present (framework dev installs via npm link)
+    updateSpinner.text = 'Syncing generated refs...';
+    try {
+      const generateScript = join(__dirname, '..', '..', '..', 'scripts', 'generate-refs.js');
+      if (existsSync(generateScript)) {
+        const result = spawnSync(process.execPath, [generateScript], { encoding: 'utf8' });
+        if (result.status === 0) {
+          logger.dim('  ✓ Generated refs synced (phase-utils.js, skill outputs)');
+        }
+      }
+    } catch {
+      // Non-fatal: generator unavailable or files already in sync
     }
 
     // Update .claude commands and skills
@@ -297,15 +302,40 @@ export async function updateCommand(options) {
       }
     }
 
-    // Update agent-teams hooks in .claude/settings.local.json
+    // Sync morph skills to .claude/skills/ for native Claude Code discovery
+    updateSpinner.text = 'Syncing morph skills to .claude/skills/...';
+    await installSkills(targetPath);
+
+    // Sync native subagents to .claude/agents/
+    updateSpinner.text = 'Syncing agents to .claude/agents/...';
+    await installAgents(targetPath, frameworkDir);
+    await installDomainAgents(targetPath, frameworkDir);
+
+    // Sync path-scoped rules to .claude/rules/
+    updateSpinner.text = 'Syncing rules to .claude/rules/...';
+    const rulesSrc = join(frameworkDir, 'rules');
+    const rulesDest = join(claudeDest, 'rules');
+    if (await pathExists(rulesSrc)) {
+      await copyDirectory(rulesSrc, rulesDest);
+    }
+
+    // Sync runtime CLAUDE.md to .claude/CLAUDE.md
+    updateSpinner.text = 'Syncing .claude/CLAUDE.md...';
+    const runtimeSrc = join(frameworkDir, 'CLAUDE.md');
+    const runtimeDest = join(claudeDest, 'CLAUDE.md');
+    if (await pathExists(runtimeSrc)) {
+      await copyFile(runtimeSrc, runtimeDest);
+    }
+
+    // Update Claude Code hooks in .claude/settings.local.json
     updateSpinner.text = 'Updating Claude Code hooks...';
-    await installClaudeHooks(targetPath);
+    const hooksResult = await installClaudeHooks(targetPath);
 
     // Update CLAUDE.md
     updateSpinner.text = 'Updating CLAUDE.md...';
-    const claudeMdSrc = join(contentDir, 'CLAUDE.md');
+    const claudeMdSrc = join(frameworkDir, 'CLAUDE.md');
     const claudeMdDest = join(targetPath, 'CLAUDE.md');
-    await copyDirectory(claudeMdSrc, claudeMdDest);
+    await copyFile(claudeMdSrc, claudeMdDest);
 
     // Restore user config after framework reinstallation
     updateSpinner.text = 'Restoring user configuration...';
@@ -330,10 +360,9 @@ export async function updateCommand(options) {
 
     logger.blank();
     logger.info('Updated files:');
-    if (updateTemplates) logger.dim('  ✓ .morph/templates/');
-    if (updateStandards) logger.dim('  ✓ .morph/standards/');
-    logger.dim('  ✓ .morph/config/agents.json');
-    logger.dim('  ✓ .morph/config/azure-pricing.json');
+    if (updateTemplates) logger.dim('  ✓ .morph/framework/templates/');
+    if (updateStandards) logger.dim('  ✓ .morph/framework/standards/');
+    logger.dim('  ✓ .morph/framework/agents.json');
     if (commandsCopied) logger.dim('  ✓ .claude/commands/');
 
     if (symlinkCount > 0) {
@@ -344,7 +373,11 @@ export async function updateCommand(options) {
       logger.warn(`  ⚠ Directory links not supported (copied instead). Skills won't auto-update.`);
     }
 
-    logger.dim('  ✓ .claude/settings.local.json (agent-teams hooks)');
+    logger.dim(`  ✓ .claude/settings.local.json (${hooksResult.installed} hooks installed)`);
+    logger.dim('  ✓ .claude/skills/ (flat .md for /skill-name discovery)');
+    logger.dim('  ✓ .claude/agents/ (native subagents refreshed)');
+    logger.dim('  ✓ .claude/rules/ (path-scoped rules synced)');
+    logger.dim('  ✓ .claude/CLAUDE.md (runtime quick reference)');
     logger.dim('  ✓ CLAUDE.md');
     logger.blank();
     logger.info('Your config.json was preserved.');

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

@@ -13,6 +13,7 @@ import chalk from 'chalk';
 import { loadState, saveState, getFeature, getApprovalGate } 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';
 import { shouldAutoApprove, autoCalculateTrust } from '../../lib/trust/trust-manager.js';
 import { validateSpec } from '../../lib/validators/spec-validator.js';
 import { validateTransition, getPhaseDisplayName } from '../../core/state/phase-state-machine.js';
@@ -401,7 +402,7 @@ function getPhaseGuidance(phase, feature) {
     ],
     'sync': [
       'Review decisions.md for standards to promote',
-      `Sync: morph-spec sync --path .morph/project/outputs/${feature}/decisions.md`
+      `Sync: morph-spec sync --path ${getOutputPath(feature, 'decisions')}`
     ]
   };
 
@@ -437,8 +438,8 @@ function designSystemGate(feature, projectPath = '.') {
       'Design system is required when UI agents (blazor-builder, ui-designer, css-specialist) are active',
       '',
       'Create a design system with one of these options:',
-      '  1. Project-level: .morph/project/design-system.md (shared across features)',
-      `  2. Feature-level: .morph/project/outputs/${feature}/ui-design-system.md (feature-specific)`,
+      '  1. Project-level: .morph/context/design-system.md (shared across features)',
+      `  2. Feature-level: ${getOutputPath(feature, 'uiDesignSystem')} (feature-specific)`,
       '  3. Auto-generate: morph-spec generate design-system (scans existing CSS)',
       '',
       'Or remove UI agents if they are not needed:',