@polymorphism-tech/morph-spec 7.8.1 → 7.9.0

package/src/commands/project/checkpoint.js

@@ -1,209 +1,209 @@
-/**
- * MORPH-SPEC Checkpoint Save/Restore Command
- *
- * Save and restore full context at phase boundaries.
- *
- * Usage:
- *   morph-spec checkpoint save <feature-name>
- *   morph-spec checkpoint restore <feature-name>
- *   morph-spec checkpoint list <feature-name>
- */
-
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { loadState, saveState, getFeature } from '../../core/state/state-manager.js';
-
-/**
- * Get checkpoints directory for a feature
- */
-function getCheckpointsDir(featureName) {
-  return path.join(process.cwd(), '.morph/checkpoints', featureName);
-}
-
-/**
- * Save checkpoint command
- */
-export async function checkpointSaveCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    process.exit(1);
-  }
-
-  const feature = getFeature(featureName);
-  if (!feature) {
-    console.error(chalk.red(`Error: Feature '${featureName}' not found`));
-    process.exit(1);
-  }
-
-  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
-  if (!fs.existsSync(outputDir)) {
-    console.error(chalk.red(`Error: No outputs found for '${featureName}'`));
-    process.exit(1);
-  }
-
-  // Create checkpoint directory with timestamp
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const label = options.label || feature.phase;
-  const checkpointName = `${label}_${timestamp}`;
-  const checkpointDir = path.join(getCheckpointsDir(featureName), checkpointName);
-  fs.mkdirSync(checkpointDir, { recursive: true });
-
-  // Copy all output files
-  const files = fs.readdirSync(outputDir);
-  let fileCount = 0;
-  for (const file of files) {
-    const src = path.join(outputDir, file);
-    const stat = fs.statSync(src);
-    if (stat.isFile()) {
-      fs.copyFileSync(src, path.join(checkpointDir, file));
-      fileCount++;
-    }
-  }
-
-  // Save state snapshot
-  const stateSnapshot = {
-    feature: { ...feature },
-    timestamp: new Date().toISOString(),
-    phase: feature.phase,
-    label,
-    files: files.filter(f => fs.statSync(path.join(outputDir, f)).isFile())
-  };
-  fs.writeFileSync(
-    path.join(checkpointDir, '_checkpoint.json'),
-    JSON.stringify(stateSnapshot, null, 2)
-  );
-
-  console.log(chalk.green(`\n✓ Checkpoint saved: ${checkpointName}`));
-  console.log(chalk.gray(`  Phase: ${feature.phase}`));
-  console.log(chalk.gray(`  Files: ${fileCount}`));
-  console.log(chalk.gray(`  Path: ${checkpointDir}\n`));
-}
-
-/**
- * Restore checkpoint command
- */
-export async function checkpointRestoreCommand(featureName, checkpointName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    process.exit(1);
-  }
-
-  const checkpointsDir = getCheckpointsDir(featureName);
-  if (!fs.existsSync(checkpointsDir)) {
-    console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
-    process.exit(1);
-  }
-
-  // Find checkpoint to restore
-  let targetDir;
-  if (checkpointName) {
-    targetDir = path.join(checkpointsDir, checkpointName);
-    if (!fs.existsSync(targetDir)) {
-      console.error(chalk.red(`Error: Checkpoint '${checkpointName}' not found`));
-      process.exit(1);
-    }
-  } else {
-    // Restore latest
-    const checkpoints = fs.readdirSync(checkpointsDir)
-      .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
-      .sort()
-      .reverse();
-
-    if (checkpoints.length === 0) {
-      console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
-      process.exit(1);
-    }
-
-    targetDir = path.join(checkpointsDir, checkpoints[0]);
-    checkpointName = checkpoints[0];
-  }
-
-  // Read checkpoint metadata
-  const metaPath = path.join(targetDir, '_checkpoint.json');
-  if (!fs.existsSync(metaPath)) {
-    console.error(chalk.red('Error: Checkpoint metadata not found'));
-    process.exit(1);
-  }
-
-  const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-
-  // Restore output files
-  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
-  fs.mkdirSync(outputDir, { recursive: true });
-
-  const files = fs.readdirSync(targetDir).filter(f => f !== '_checkpoint.json');
-  for (const file of files) {
-    fs.copyFileSync(path.join(targetDir, file), path.join(outputDir, file));
-  }
-
-  // Restore state
-  const state = loadState();
-  if (state.features[featureName] && meta.feature) {
-    // Preserve some current fields, restore phase and outputs
-    state.features[featureName].phase = meta.feature.phase;
-    state.features[featureName].outputs = meta.feature.outputs;
-    state.features[featureName].tasks = meta.feature.tasks;
-    state.features[featureName].approvalGates = meta.feature.approvalGates;
-    state.features[featureName].updatedAt = new Date().toISOString();
-    saveState(state);
-  }
-
-  console.log(chalk.green(`\n✓ Checkpoint restored: ${checkpointName}`));
-  console.log(chalk.gray(`  Phase: ${meta.phase}`));
-  console.log(chalk.gray(`  Files restored: ${files.length}`));
-  console.log(chalk.gray(`  Original date: ${meta.timestamp}\n`));
-}
-
-/**
- * List checkpoints command
- */
-export async function checkpointListCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    process.exit(1);
-  }
-
-  const checkpointsDir = getCheckpointsDir(featureName);
-  if (!fs.existsSync(checkpointsDir)) {
-    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
-    return;
-  }
-
-  const checkpoints = fs.readdirSync(checkpointsDir)
-    .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
-    .sort()
-    .reverse();
-
-  if (checkpoints.length === 0) {
-    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
-    return;
-  }
-
-  // JSON output
-  if (options.json) {
-    const list = checkpoints.map(cp => {
-      const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
-      const meta = fs.existsSync(metaPath) ? JSON.parse(fs.readFileSync(metaPath, 'utf8')) : {};
-      return { name: cp, phase: meta.phase, timestamp: meta.timestamp, files: meta.files?.length || 0 };
-    });
-    console.log(JSON.stringify({ feature: featureName, checkpoints: list }, null, 2));
-    return;
-  }
-
-  // Visual output
-  console.log(chalk.cyan(`\nCheckpoints for '${featureName}':\n`));
-
-  for (const cp of checkpoints) {
-    const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
-    let meta = {};
-    if (fs.existsSync(metaPath)) {
-      meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-    }
-
-    const date = meta.timestamp ? new Date(meta.timestamp).toLocaleString() : 'unknown';
-    console.log(chalk.white(`  ${cp}`));
-    console.log(chalk.gray(`    Phase: ${meta.phase || 'unknown'} | Files: ${meta.files?.length || '?'} | ${date}`));
-  }
-  console.log('');
-}
+/**
+ * MORPH-SPEC Checkpoint Save/Restore Command
+ *
+ * Save and restore full context at phase boundaries.
+ *
+ * Usage:
+ *   morph-spec checkpoint save <feature-name>
+ *   morph-spec checkpoint restore <feature-name>
+ *   morph-spec checkpoint list <feature-name>
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { loadState, saveState, getFeature } from '../../core/state/state-manager.js';
+
+/**
+ * Get checkpoints directory for a feature
+ */
+function getCheckpointsDir(featureName) {
+  return path.join(process.cwd(), '.morph/checkpoints', featureName);
+}
+
+/**
+ * Save checkpoint command
+ */
+export async function checkpointSaveCommand(featureName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    process.exit(1);
+  }
+
+  const feature = getFeature(featureName);
+  if (!feature) {
+    console.error(chalk.red(`Error: Feature '${featureName}' not found`));
+    process.exit(1);
+  }
+
+  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
+  if (!fs.existsSync(outputDir)) {
+    console.error(chalk.red(`Error: No outputs found for '${featureName}'`));
+    process.exit(1);
+  }
+
+  // Create checkpoint directory with timestamp
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const label = options.label || feature.phase;
+  const checkpointName = `${label}_${timestamp}`;
+  const checkpointDir = path.join(getCheckpointsDir(featureName), checkpointName);
+  fs.mkdirSync(checkpointDir, { recursive: true });
+
+  // Copy all output files
+  const files = fs.readdirSync(outputDir);
+  let fileCount = 0;
+  for (const file of files) {
+    const src = path.join(outputDir, file);
+    const stat = fs.statSync(src);
+    if (stat.isFile()) {
+      fs.copyFileSync(src, path.join(checkpointDir, file));
+      fileCount++;
+    }
+  }
+
+  // Save state snapshot
+  const stateSnapshot = {
+    feature: { ...feature },
+    timestamp: new Date().toISOString(),
+    phase: feature.phase,
+    label,
+    files: files.filter(f => fs.statSync(path.join(outputDir, f)).isFile())
+  };
+  fs.writeFileSync(
+    path.join(checkpointDir, '_checkpoint.json'),
+    JSON.stringify(stateSnapshot, null, 2)
+  );
+
+  console.log(chalk.green(`\n✓ Checkpoint saved: ${checkpointName}`));
+  console.log(chalk.gray(`  Phase: ${feature.phase}`));
+  console.log(chalk.gray(`  Files: ${fileCount}`));
+  console.log(chalk.gray(`  Path: ${checkpointDir}\n`));
+}
+
+/**
+ * Restore checkpoint command
+ */
+export async function checkpointRestoreCommand(featureName, checkpointName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    process.exit(1);
+  }
+
+  const checkpointsDir = getCheckpointsDir(featureName);
+  if (!fs.existsSync(checkpointsDir)) {
+    console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
+    process.exit(1);
+  }
+
+  // Find checkpoint to restore
+  let targetDir;
+  if (checkpointName) {
+    targetDir = path.join(checkpointsDir, checkpointName);
+    if (!fs.existsSync(targetDir)) {
+      console.error(chalk.red(`Error: Checkpoint '${checkpointName}' not found`));
+      process.exit(1);
+    }
+  } else {
+    // Restore latest
+    const checkpoints = fs.readdirSync(checkpointsDir)
+      .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
+      .sort()
+      .reverse();
+
+    if (checkpoints.length === 0) {
+      console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
+      process.exit(1);
+    }
+
+    targetDir = path.join(checkpointsDir, checkpoints[0]);
+    checkpointName = checkpoints[0];
+  }
+
+  // Read checkpoint metadata
+  const metaPath = path.join(targetDir, '_checkpoint.json');
+  if (!fs.existsSync(metaPath)) {
+    console.error(chalk.red('Error: Checkpoint metadata not found'));
+    process.exit(1);
+  }
+
+  const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+
+  // Restore output files
+  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const files = fs.readdirSync(targetDir).filter(f => f !== '_checkpoint.json');
+  for (const file of files) {
+    fs.copyFileSync(path.join(targetDir, file), path.join(outputDir, file));
+  }
+
+  // Restore state
+  const state = loadState();
+  if (state.features[featureName] && meta.feature) {
+    // Preserve some current fields, restore phase and outputs
+    state.features[featureName].phase = meta.feature.phase;
+    state.features[featureName].outputs = meta.feature.outputs;
+    state.features[featureName].tasks = meta.feature.tasks;
+    state.features[featureName].approvalGates = meta.feature.approvalGates;
+    state.features[featureName].updatedAt = new Date().toISOString();
+    saveState(state);
+  }
+
+  console.log(chalk.green(`\n✓ Checkpoint restored: ${checkpointName}`));
+  console.log(chalk.gray(`  Phase: ${meta.phase}`));
+  console.log(chalk.gray(`  Files restored: ${files.length}`));
+  console.log(chalk.gray(`  Original date: ${meta.timestamp}\n`));
+}
+
+/**
+ * List checkpoints command
+ */
+export async function checkpointListCommand(featureName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    process.exit(1);
+  }
+
+  const checkpointsDir = getCheckpointsDir(featureName);
+  if (!fs.existsSync(checkpointsDir)) {
+    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
+    return;
+  }
+
+  const checkpoints = fs.readdirSync(checkpointsDir)
+    .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
+    .sort()
+    .reverse();
+
+  if (checkpoints.length === 0) {
+    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
+    return;
+  }
+
+  // JSON output
+  if (options.json) {
+    const list = checkpoints.map(cp => {
+      const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
+      const meta = fs.existsSync(metaPath) ? JSON.parse(fs.readFileSync(metaPath, 'utf8')) : {};
+      return { name: cp, phase: meta.phase, timestamp: meta.timestamp, files: meta.files?.length || 0 };
+    });
+    console.log(JSON.stringify({ feature: featureName, checkpoints: list }, null, 2));
+    return;
+  }
+
+  // Visual output
+  console.log(chalk.cyan(`\nCheckpoints for '${featureName}':\n`));
+
+  for (const cp of checkpoints) {
+    const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
+    let meta = {};
+    if (fs.existsSync(metaPath)) {
+      meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+    }
+
+    const date = meta.timestamp ? new Date(meta.timestamp).toLocaleString() : 'unknown';
+    console.log(chalk.white(`  ${cp}`));
+    console.log(chalk.gray(`    Phase: ${meta.phase || 'unknown'} | Files: ${meta.files?.length || '?'} | ${date}`));
+  }
+  console.log('');
+}

package/src/commands/project/doctor.js

@@ -764,26 +764,31 @@ export async function doctorCommand(options = {}) {
         const morphAgents = agentFiles.filter(f => f.startsWith('morph-') && f.endsWith('.md'));
         checks.push({ name: '.claude/agents/', status: 'ok', msg: `${morphAgents.length} agents` });
 
-        // Check for missing agents based on stack tags
+        // Check for missing agents based on stack tags. Empty tags (no config
+        // yet) is NOT a skip: personas install-all by default, so with an
+        // unknown stack ALL personas are expected (agentEligible semantics) —
+        // the exact field failure where only morph-evaluator landed and every
+        // domain dispatch fell back to general-purpose.
         try {
-          const config = await readJson(configPath);
-          const projectTags = getProjectTags(config);
-          if (projectTags.length > 0) {
-            const frameworkDir = join(import.meta.dirname, '..', '..', '..', 'framework');
-            const { missing } = checkMissingAgents(targetPath, frameworkDir, projectTags);
-            if (missing.length > 0) {
-              const names = missing.map(m => m.name).join(', ');
-              checks.push({
-                name: 'agents completeness',
-                status: 'warn',
-                msg: `${missing.length} agent(s) missing for [${projectTags.join(', ')}]: ${names} — run morph-spec setup-infra`
-              });
-              hasWarnings = true;
-            } else {
-              checks.push({ name: 'agents completeness', status: 'ok', msg: `all agents for [${projectTags.join(', ')}]` });
-            }
+          let projectTags = [];
+          try {
+            projectTags = getProjectTags(await readJson(configPath));
+          } catch { /* no config → expected = all personas */ }
+          const tagsLabel = projectTags.length > 0 ? projectTags.join(', ') : 'all (stack unknown)';
+          const frameworkDir = join(import.meta.dirname, '..', '..', '..', 'framework');
+          const { missing } = checkMissingAgents(targetPath, frameworkDir, projectTags);
+          if (missing.length > 0) {
+            const names = missing.map(m => m.name).join(', ');
+            checks.push({
+              name: 'agents completeness',
+              status: 'warn',
+              msg: `${missing.length} agent(s) missing for [${tagsLabel}]: ${names} — run morph-spec setup-infra`
+            });
+            hasWarnings = true;
+          } else {
+            checks.push({ name: 'agents completeness', status: 'ok', msg: `all agents for [${tagsLabel}]` });
           }
-        } catch { /* config not readable — skip completeness check */ }
+        } catch { /* framework dir not resolvable — skip completeness check */ }
       } else {
         checks.push({ name: '.claude/agents/', status: 'warn', msg: 'missing — run morph-spec update' });
         hasWarnings = true;

package/src/commands/project/update.js

@@ -322,16 +322,19 @@ export async function updateCommand(options) {
       logger.warn('  ⚠ framework/commands/ source missing — commands not updated');
     }
 
-    // Compute project tags for stack-aware installation of skills, agents, and rules
+    // Compute project tags for stack-aware installation of skills, agents, and rules.
+    // MUST come from the pre-clean backup: cleanFrameworkDirs() deleted .morph/config/
+    // above and restoreUserConfig() only runs at the end — re-reading the file here
+    // yields [] and silently downgrades the whole install to universal-only assets
+    // (the ".claude/agents/ only has morph-evaluator.md after update" bug).
     let projectTags = [];
     try {
-      const cfg = await readJson(join(morphPath, 'config', 'config.json'));
-      projectTags = getProjectTags(cfg);
-    } catch { /* ignore — config may not exist yet */ }
+      if (configBackup) projectTags = getProjectTags(configBackup);
+    } catch { /* ignore — malformed config */ }
 
     // Sync morph skills to .claude/skills/ for native Claude Code discovery
     updateSpinner.text = 'Syncing morph skills to .claude/skills/...';
-    await installSkills(targetPath, { projectTags });
+    const skillsResult = await installSkills(targetPath, { projectTags });
 
     // Sync native subagents to .claude/agents/
     updateSpinner.text = 'Syncing agents to .claude/agents/...';
@@ -344,9 +347,10 @@ export async function updateCommand(options) {
     updateSpinner.text = 'Syncing rules to .claude/rules/...';
     const rulesSrc = join(frameworkDir, 'rules');
     const rulesDest = join(claudeDest, 'rules');
+    let rulesResult = null;
     if (await pathExists(rulesSrc)) {
       await ensureDir(rulesDest);
-      installRulesForStack(rulesSrc, rulesDest, projectTags);
+      rulesResult = installRulesForStack(rulesSrc, rulesDest, projectTags);
     }
 
     // Sync runtime CLAUDE.md to .claude/CLAUDE.md and derive the personas
@@ -417,10 +421,13 @@ export async function updateCommand(options) {
     logger.dim('  ✓ .morph/framework/schemas/ + rubrics/ + evals/ (bar 9 + LLM rubrics)');
     if (commandsCopied) logger.dim('  ✓ .claude/commands/');
 
+    // Counts make a silent stack-filter downgrade visible at a glance —
+    // a dotnet project reporting "1 persona" is a red flag, not a success.
+    const tagsLabel = projectTags.length > 0 ? projectTags.join('+') : 'universal only';
     logger.dim(`  ✓ .claude/settings.local.json (${hooksResult.installed} hooks installed)`);
-    logger.dim('  ✓ .claude/skills/ (skills installed as directories)');
-    logger.dim('  ✓ .claude/agents/ (native subagents refreshed)');
-    logger.dim('  ✓ .claude/rules/ (stack-filtered rules synced)');
+    logger.dim(`  ✓ .claude/skills/ (${skillsResult?.installed ?? '?'} skills — stack: ${tagsLabel})`);
+    logger.dim(`  ✓ .claude/agents/ (${agentsResult?.agents?.length ?? '?'} personas — stack: ${tagsLabel})`);
+    logger.dim(`  ✓ .claude/rules/ (${rulesResult?.installed ?? '?'} stack-filtered rules)`);
     logger.dim('  ✓ .claude/CLAUDE.md (runtime quick reference)');
     logger.dim('  ✓ ~/.claude/statusline.sh (global statusline synced)');
     logger.dim('  ✓ CLAUDE.md');

package/src/commands/state/create.js

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { mkdirSync } from 'fs';
+import { join } from 'path';
+import { createFeature } from '../../core/state/state-manager.js';
+
+/** Feature names are kebab-case: lowercase alphanumerics and hyphens. */
+const FEATURE_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+const VALID_STATUSES = ['draft', 'in_progress', 'completed'];
+
+/**
+ * `morph-spec create <feature>` — explicit feature birth: creates
+ * `.morph/features/{feature}/0-proposal/` and the canonical feature.json
+ * (shape documented in framework/schemas/feature.schema.json).
+ *
+ * Replaces the implicit birth via the state-sync hook on the first Write —
+ * the skills call this at proposal start so the authoritative state exists
+ * with the full canonical shape before any artifact lands. Idempotent: an
+ * existing feature is reported and left untouched.
+ */
+export async function createCommand(featureName, options = {}) {
+  try {
+    if (!FEATURE_NAME_RE.test(featureName)) {
+      console.error(chalk.red(`\n❌ Invalid feature name: "${featureName}"`));
+      console.error(chalk.gray('Use kebab-case: lowercase letters, digits and hyphens (e.g. "user-onboarding")\n'));
+      process.exit(1);
+    }
+
+    if (options.status !== undefined && !VALID_STATUSES.includes(options.status)) {
+      console.error(chalk.red(`\n❌ Invalid --status: "${options.status}"`));
+      console.error(chalk.gray(`Valid statuses: ${VALID_STATUSES.join(', ')}\n`));
+      process.exit(1);
+    }
+
+    const { feature, created } = await createFeature(featureName, { status: options.status });
+
+    // The proposal folder is the first working directory of every feature.
+    const featureDir = join(process.cwd(), '.morph', 'features', featureName);
+    mkdirSync(join(featureDir, '0-proposal'), { recursive: true });
+
+    if (options.json) {
+      console.log(JSON.stringify({ feature: featureName, created, ...feature }, null, 2));
+      return;
+    }
+
+    if (created) {
+      console.log(chalk.green(`\n✅ Feature created: ${featureName}`));
+      console.log(chalk.gray(`   .morph/features/${featureName}/feature.json (canonical shape) + 0-proposal/`));
+      console.log(chalk.gray(`   status: ${feature.status} | createdAt: ${feature.createdAt}\n`));
+    } else {
+      console.log(chalk.yellow(`\n⚠️  Feature "${featureName}" already exists — left untouched`));
+      console.log(chalk.gray(`   status: ${feature.status} | createdAt: ${feature.createdAt || 'unknown'}\n`));
+    }
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error creating feature: ${error.message}\n`));
+    process.exit(1);
+  }
+}