@polymorphism-tech/morph-spec 4.10.0 → 4.10.2

package/src/commands/project/update.js

@@ -28,6 +28,7 @@ import {
 import { installClaudeHooks, installGlobalStatusline, installVSCodeTerminalSettings, installShellIntegration } from '../../utils/claude-settings-manager.js';
 import { installSkills } from '../../utils/skills-installer.js';
 import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
+import { injectMorphImport } from '../../utils/claude-md-injector.js';
 
 /**
  * Backup user's config.json before cleaning
@@ -321,11 +322,10 @@ export async function updateCommand(options) {
       logger.dim('  ⚠ Could not configure VS Code terminal settings (non-critical)');
     }
 
-    // Update CLAUDE.md
-    updateSpinner.text = 'Updating CLAUDE.md...';
-    const claudeMdSrc = join(frameworkDir, 'CLAUDE.md');
+    // Ensure root CLAUDE.md has morph-spec @import (preserves user content)
+    updateSpinner.text = 'Checking CLAUDE.md import...';
     const claudeMdDest = join(targetPath, 'CLAUDE.md');
-    await copyFile(claudeMdSrc, claudeMdDest);
+    await injectMorphImport(claudeMdDest);
 
     // Restore user config after framework reinstallation
     updateSpinner.text = 'Restoring user configuration...';

package/src/lib/stack-filter.js

@@ -0,0 +1,58 @@
+/**
+ * Parse `stacks:` from YAML frontmatter content.
+ * Returns ['*'] if no stacks field found (backwards compatible — always install).
+ *
+ * Supports:
+ *   stacks:\n  - dotnet\n  - blazor   (YAML list)
+ *   stacks: [dotnet, blazor]           (inline array)
+ *
+ * @param {string} content - Raw file content with YAML frontmatter
+ * @returns {string[]}
+ */
+export function parseStacks(content) {
+  const normalized = content.replace(/\r\n/g, '\n');
+  const fmMatch = normalized.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return ['*'];
+
+  const fm = fmMatch[1];
+
+  // Try inline format: stacks: [dotnet, blazor]
+  const inlineMatch = fm.match(/^stacks:\s*\[([^\]]*)\]/m);
+  if (inlineMatch) {
+    const items = inlineMatch[1].split(',').map(s => s.trim()).filter(Boolean);
+    return items.length > 0 ? items : ['*'];
+  }
+
+  // Try YAML list format: stacks:\n  - dotnet\n  - blazor
+  const listMatch = fm.match(/^stacks:\s*\n((?:\s+-\s+.+\n?)*)/m);
+  if (listMatch) {
+    const items = listMatch[1]
+      .split('\n')
+      .map(line => line.replace(/^\s+-\s+/, '').replace(/["']/g, '').trim())
+      .filter(Boolean);
+    return items.length > 0 ? items : ['*'];
+  }
+
+  return ['*'];
+}
+
+/**
+ * Extract project stack tags from config object.
+ * Splits `project.stack` by '-' or '+' to produce tag array.
+ */
+export function getProjectTags(config) {
+  const stack = config?.project?.stack;
+  if (!stack || typeof stack !== 'string') return [];
+  return stack.split(/[-+]/).filter(Boolean);
+}
+
+/**
+ * Determine if an asset should be installed for the given project tags.
+ * - stacks includes '*' → always install
+ * - stacks is empty → treat as '*' (backwards compatible)
+ * - Otherwise → install if intersection with projectTags is non-empty
+ */
+export function shouldInstall(assetStacks, projectTags) {
+  if (assetStacks.length === 0 || assetStacks.includes('*')) return true;
+  return assetStacks.some(s => projectTags.includes(s));
+}

package/src/scripts/setup-infra.js

@@ -14,6 +14,7 @@
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
+import { readFileSync, readdirSync, copyFileSync, unlinkSync } from 'fs';
 import {
   copyDirectory,
   copyFile,
@@ -23,6 +24,8 @@ import {
   writeFile,
   updateGitignore
 } from '../utils/file-copier.js';
+import { parseStacks, getProjectTags, shouldInstall } from '../lib/stack-filter.js';
+import { injectMorphImport } from '../utils/claude-md-injector.js';
 import { saveProjectMorphVersion, getInstalledCLIVersion } from '../utils/version-checker.js';
 import { installClaudeHooks, installGlobalStatusline, installVSCodeTerminalSettings, installShellIntegration } from '../utils/claude-settings-manager.js';
 import { installSkills } from '../utils/skills-installer.js';
@@ -47,6 +50,35 @@ async function installRequiredPlugins(log, exec) {
   }
 }
 
+/**
+ * Install only stack-matching rules from rulesSrc to rulesDest.
+ * Also removes orphan rules in rulesDest that are no longer in the install set.
+ *
+ * @param {string} rulesSrc - Source rules directory (framework/rules/)
+ * @param {string} rulesDest - Destination rules directory (.claude/rules/)
+ * @param {string[]} projectTags - Stack tags from config (e.g., ['dotnet', 'blazor'])
+ */
+export function installRulesForStack(rulesSrc, rulesDest, projectTags) {
+  const sourceFiles = readdirSync(rulesSrc).filter(f => f.endsWith('.md'));
+  const installed = new Set();
+
+  for (const file of sourceFiles) {
+    const content = readFileSync(join(rulesSrc, file), 'utf-8');
+    const stacks = parseStacks(content);
+    if (shouldInstall(stacks, projectTags)) {
+      copyFileSync(join(rulesSrc, file), join(rulesDest, file));
+      installed.add(file);
+    }
+  }
+
+  // Cleanup orphans
+  for (const file of readdirSync(rulesDest).filter(f => f.endsWith('.md'))) {
+    if (!installed.has(file)) {
+      unlinkSync(join(rulesDest, file));
+    }
+  }
+}
+
 /**
  * Installs MORPH-SPEC infrastructure into the target project directory.
  * Headless — no prompts, no spinner (suppressed when MORPH_QUIET=1), no stack detection.
@@ -63,19 +95,12 @@ export async function setupInfra(targetPath, { _exec = execSync } = {}) {
   // --- 0. Install required Claude Code plugins ---
   await installRequiredPlugins(log, _exec);
 
-  // --- 1. Copy CLAUDE.md (backup existing non-MORPH CLAUDE.md) ---
-  log('Step 1: Copying CLAUDE.md...');
+  // --- 1. Inject @import into root CLAUDE.md (preserves user content) ---
+  log('Step 1: Setting up CLAUDE.md...');
   const claudeMdSrc = join(FRAMEWORK_DIR, 'CLAUDE.md');
   const claudeMdDest = join(targetPath, 'CLAUDE.md');
-
-  if (await pathExists(claudeMdDest)) {
-    const { readFile } = await import('../utils/file-copier.js');
-    const existingContent = await readFile(claudeMdDest);
-    if (!existingContent.includes('MORPH-SPEC')) {
-      await copyFile(claudeMdDest, `${claudeMdDest}.backup`);
-    }
-  }
-  await copyFile(claudeMdSrc, claudeMdDest);
+  const importResult = await injectMorphImport(claudeMdDest);
+  log(`  ✓ Root CLAUDE.md: ${importResult}`);
 
   // --- 2. Create .morph directory structure ---
   log('Step 2: Creating .morph structure...');
@@ -163,27 +188,37 @@ export async function setupInfra(targetPath, { _exec = execSync } = {}) {
     await copyDirectory(commandsSrc, commandsDest);
   }
 
-  // --- 10. Copy framework/rules → .claude/rules ---
+  // --- Compute project tags for stack-aware installation ---
+  let projectTags = [];
+  if (await pathExists(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      projectTags = getProjectTags(config);
+    } catch { /* ignore malformed config */ }
+  }
+
+  // --- 10. Copy framework/rules → .claude/rules (filtered by stack) ---
   log('Step 10: Installing path-scoped rules...');
   const rulesSrc = join(FRAMEWORK_DIR, 'rules');
   const rulesDest = join(claudeDest, 'rules');
   if (await pathExists(rulesSrc)) {
-    await copyDirectory(rulesSrc, rulesDest);
+    await ensureDir(rulesDest);
+    installRulesForStack(rulesSrc, rulesDest, projectTags);
   }
 
-  // --- 11. installSkills ---
+  // --- 11. installSkills (filtered by stack) ---
   log('Step 11: Installing skills...');
-  await installSkills(targetPath);
+  await installSkills(targetPath, { projectTags });
 
   // --- 12. installAgents ---
   log('Step 12: Installing agents...');
   const agentCounts = await installAgents(targetPath, FRAMEWORK_DIR, { projectStack: null });
 
-  // --- 13. installDomainAgents ---
+  // --- 13. installDomainAgents (filtered by stack) ---
   log('Step 13: Installing domain agents...');
-  const domainCounts = await installDomainAgents(targetPath, FRAMEWORK_DIR);
+  const domainCounts = await installDomainAgents(targetPath, FRAMEWORK_DIR, { projectTags });
 
-  // --- 14. Copy framework/CLAUDE.md → .claude/CLAUDE.md ---
+  // --- 14. Copy framework/CLAUDE.md → .claude/CLAUDE.md (morph-owned, gitignored) ---
   log('Step 14: Installing .claude/CLAUDE.md...');
   const runtimeClaudeMdDest = join(claudeDest, 'CLAUDE.md');
   if (await pathExists(claudeMdSrc)) {

package/src/utils/agents-installer.js

@@ -8,8 +8,9 @@
  * maxTurns, skills, memory) followed by the agent's spawn prompt as the body.
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync, unlinkSync } from 'node:fs';
 import { join } from 'path';
+import { parseStacks, shouldInstall } from '../lib/stack-filter.js';
 
 /**
  * Installs tier-1 and tier-2 morph agents as native Claude Code subagents
@@ -186,7 +187,8 @@ export function parseSkillFile(rawContent) {
     if (inlineMatch) description = inlineMatch[1].trim();
   }
 
-  return { name, description, allowedTools, body };
+  const stacks = parseStacks(rawContent);
+  return { name, description, allowedTools, stacks, body };
 }
 
 /**
@@ -215,7 +217,7 @@ export function collectSkillFiles(dir) {
  * @param {string} projectDir - Target project directory
  * @param {string} frameworkDir - Path to morph-spec framework/ directory
  */
-export async function installDomainAgents(projectDir, frameworkDir = 'framework') {
+export async function installDomainAgents(projectDir, frameworkDir = 'framework', { projectTags = [] } = {}) {
   const domainsDir = join(frameworkDir, 'agents');
   if (!existsSync(domainsDir)) return { specialists: 0 };
 
@@ -223,10 +225,12 @@ export async function installDomainAgents(projectDir, frameworkDir = 'framework'
   mkdirSync(targetDir, { recursive: true });
 
   let specialists = 0;
+  const installed = new Set();
   for (const filePath of collectSkillFiles(domainsDir)) {
     const raw = readFileSync(filePath, 'utf-8');
-    const { name, description, allowedTools, body } = parseSkillFile(raw);
+    const { name, description, allowedTools, stacks, body } = parseSkillFile(raw);
     if (!name) continue;
+    if (!shouldInstall(stacks, projectTags)) continue;
 
     const desc = description ?? `MORPH-SPEC domain agent: ${name}`;
     const frontmatter = [
@@ -239,9 +243,19 @@ export async function installDomainAgents(projectDir, frameworkDir = 'framework'
       '',
     ].join('\n');
 
-    const targetPath = join(targetDir, `morph-domain-${name}.md`);
+    const filename = `morph-domain-${name}.md`;
+    const targetPath = join(targetDir, filename);
     writeFileSync(targetPath, `---\n${frontmatter}---\n\n${body.trimStart()}`, 'utf-8');
+    installed.add(filename);
     specialists++;
   }
+
+  // Cleanup orphan morph-domain-* files
+  for (const file of readdirSync(targetDir)) {
+    if (file.startsWith('morph-domain-') && !installed.has(file)) {
+      unlinkSync(join(targetDir, file));
+    }
+  }
+
   return { specialists };
 }

package/src/utils/claude-md-injector.js

@@ -0,0 +1,90 @@
+/**
+ * claude-md-injector.js
+ *
+ * Manages the root CLAUDE.md file in client projects.
+ * Instead of overwriting the user's CLAUDE.md, injects an @import line
+ * that references the morph-spec managed .claude/CLAUDE.md.
+ *
+ * The root CLAUDE.md belongs to the USER — morph-spec only adds its import.
+ */
+
+import { pathExists, readFile, writeFile } from './file-copier.js';
+
+const MORPH_IMPORT = '@.claude/CLAUDE.md';
+const MORPH_MARKER = 'MORPH-SPEC';
+
+/**
+ * Injects the morph-spec @import into the root CLAUDE.md.
+ *
+ * Three scenarios:
+ * 1. No CLAUDE.md exists → create minimal file with the import
+ * 2. Existing morph-only CLAUDE.md (old overwrite) → replace with minimal + import
+ * 3. Existing user CLAUDE.md → append import section at the end
+ *
+ * Idempotent — does nothing if the import already exists.
+ *
+ * @param {string} claudeMdPath - Absolute path to root CLAUDE.md
+ * @returns {Promise<'created'|'migrated'|'injected'|'already-present'>}
+ */
+export async function injectMorphImport(claudeMdPath) {
+  if (!await pathExists(claudeMdPath)) {
+    await writeFile(claudeMdPath, `# Project\n\n${MORPH_IMPORT}\n`);
+    return 'created';
+  }
+
+  const content = await readFile(claudeMdPath);
+
+  if (content.includes(MORPH_IMPORT)) {
+    return 'already-present';
+  }
+
+  if (isMorphOnly(content)) {
+    await writeFile(claudeMdPath, `# Project\n\n${MORPH_IMPORT}\n`);
+    return 'migrated';
+  }
+
+  // User has their own content — append the import section
+  const separator = content.endsWith('\n') ? '\n' : '\n\n';
+  await writeFile(claudeMdPath, `${content}${separator}## MORPH-SPEC\n\n${MORPH_IMPORT}\n`);
+  return 'injected';
+}
+
+/**
+ * Checks if CLAUDE.md contains ONLY morph-spec content (old overwrite pattern).
+ * Heuristic: contains MORPH-SPEC marker AND no substantial user content.
+ */
+function isMorphOnly(content) {
+  if (!content.includes(MORPH_MARKER)) return false;
+
+  // Strip morph-spec boilerplate markers and check if anything meaningful remains
+  const stripped = content
+    .replace(/# MORPH-SPEC Runtime Instructions/g, '')
+    .replace(/by Polymorphism Tech[^\n]*/g, '')
+    .replace(/\*MORPH-SPEC by Polymorphism Tech\*/g, '')
+    .replace(/@\.morph\/context\/README\.md/g, '')
+    .replace(/@\.claude\/CLAUDE\.md/g, '')
+    .replace(/## Critical Rules[\s\S]*?(?=##|$)/g, '')
+    .replace(/## Quick Reference[\s\S]*?(?=##|$)/g, '')
+    .replace(/## State & Outputs[\s\S]*?(?=##|$)/g, '')
+    .replace(/## Phase Sequence[\s\S]*?(?=##|$)/g, '')
+    .replace(/## Agents[\s\S]*?(?=##|$)/g, '')
+    .replace(/## Context Window Tip[\s\S]*?(?=##|$)/g, '')
+    .replace(/## Project Context[\s\S]*?(?=##|$)/g, '')
+    .replace(/[#\-|>*`\s]/g, '');
+
+  return stripped.length < 50;
+}
+
+/**
+ * Checks if the root CLAUDE.md has the morph-spec import.
+ * Used by doctor.js for health checks.
+ *
+ * @param {string} claudeMdPath - Absolute path to root CLAUDE.md
+ * @returns {Promise<'ok'|'missing'|'missing-import'>}
+ */
+export async function checkClaudeMdImport(claudeMdPath) {
+  if (!await pathExists(claudeMdPath)) return 'missing';
+  const content = await readFile(claudeMdPath);
+  if (content.includes(MORPH_IMPORT)) return 'ok';
+  return 'missing-import';
+}

package/src/utils/hooks-installer.js

@@ -31,10 +31,7 @@ const MORPH_PERMISSIONS = [
   'Edit(.morph/state.json)',
   'Write(.morph/framework/**)',
   'Edit(.morph/framework/**)',
-  // Root CLAUDE.md (managed copy — source is framework/CLAUDE.md)
-  'Write(CLAUDE.md)',
-  'Edit(CLAUDE.md)',
-  // .claude/CLAUDE.md (managed copy — source is framework/CLAUDE_runtime.md)
+  // .claude/CLAUDE.md (managed copy — source is framework/CLAUDE.md)
   'Write(.claude/CLAUDE.md)',
   'Edit(.claude/CLAUDE.md)',
   // .claude/rules/ (copied from framework/rules/)

package/src/utils/skills-installer.js

@@ -16,9 +16,10 @@
  * assets/) so Claude Code can execute scripts and load references on demand.
  */
 
-import { mkdirSync, copyFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { mkdirSync, copyFileSync, existsSync, readdirSync, statSync, readFileSync, rmSync } from 'fs';
 import { join } from 'path';
 import { fileURLToPath } from 'url';
+import { parseStacks, shouldInstall } from '../lib/stack-filter.js';
 
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 const FRAMEWORK_SKILLS_DIR = join(__dirname, '..', '..', 'framework', 'skills');
@@ -32,6 +33,16 @@ const FRAMEWORK_SKILLS_DIR = join(__dirname, '..', '..', 'framework', 'skills');
  */
 const SKILL_LEVELS_TO_INSTALL = ['level-0-meta', 'level-1-workflows'];
 
+/**
+ * Check if a skill should be installed based on its stacks: frontmatter.
+ * @param {string} skillContent - Raw SKILL.md content
+ * @param {string[]} projectTags - Stack tags from config
+ * @returns {boolean}
+ */
+export function shouldInstallSkill(skillContent, projectTags) {
+  return shouldInstall(parseStacks(skillContent), projectTags);
+}
+
 /**
  * Recursively copy a directory tree from src to dest.
  * Creates dest if it doesn't exist. Skips README.md files.
@@ -71,7 +82,7 @@ function copyDirectory(src, dest) {
  * @param {string} srcDir - Source directory to walk
  * @param {string} destDir - Destination base directory (.claude/skills/)
  */
-function installSkillsFromDir(srcDir, destDir) {
+function installSkillsFromDir(srcDir, destDir, projectTags) {
   const entries = readdirSync(srcDir);
   for (const entry of entries) {
     const srcPath = join(srcDir, entry);
@@ -80,15 +91,19 @@ function installSkillsFromDir(srcDir, destDir) {
     if (stat.isDirectory()) {
       const skillMdPath = join(srcPath, 'SKILL.md');
       if (existsSync(skillMdPath)) {
-        // Directory-based skill — copy entire directory including scripts/, references/, assets/
+        // Directory-based skill — check stack filter before copying
+        const content = readFileSync(skillMdPath, 'utf-8');
+        if (!shouldInstallSkill(content, projectTags)) continue;
         const skillDestDir = join(destDir, entry);
         copyDirectory(srcPath, skillDestDir);
       } else {
         // Level/category directory — recurse
-        installSkillsFromDir(srcPath, destDir);
+        installSkillsFromDir(srcPath, destDir, projectTags);
       }
     } else if (entry.endsWith('.md') && entry !== 'README.md') {
-      // Legacy flat .md skill — wrap in subdirectory as SKILL.md
+      // Legacy flat .md skill — check stack filter before copying
+      const content = readFileSync(srcPath, 'utf-8');
+      if (!shouldInstallSkill(content, projectTags)) continue;
       const skillName = entry.slice(0, -3);
       const skillDir = join(destDir, skillName);
       mkdirSync(skillDir, { recursive: true });
@@ -97,6 +112,28 @@ function installSkillsFromDir(srcDir, destDir) {
   }
 }
 
+function collectSourceSkillNames() {
+  const names = new Set();
+  for (const level of SKILL_LEVELS_TO_INSTALL) {
+    const levelDir = join(FRAMEWORK_SKILLS_DIR, level);
+    if (!existsSync(levelDir)) continue;
+    collectNamesFromDir(levelDir, names);
+  }
+  return names;
+}
+
+function collectNamesFromDir(dir, names) {
+  for (const entry of readdirSync(dir)) {
+    const fullPath = join(dir, entry);
+    if (!statSync(fullPath).isDirectory()) continue;
+    if (existsSync(join(fullPath, 'SKILL.md'))) {
+      names.add(entry);
+    } else {
+      collectNamesFromDir(fullPath, names);
+    }
+  }
+}
+
 /**
  * Install morph framework skills to .claude/skills/ in the target project.
  * Skills are copied into subdirectories as SKILL.md files so Claude Code can
@@ -104,15 +141,38 @@ function installSkillsFromDir(srcDir, destDir) {
  * /blazor-builder). Directory-based skills also get their scripts/,
  * references/, and assets/ subdirectories copied for on-demand loading.
  *
+ * Stack filtering: if projectTags is provided, only skills whose `stacks:`
+ * frontmatter matches the project tags are installed. Skills without a
+ * `stacks:` field are always installed (universal).
+ *
  * @param {string} projectDir - Target project root directory
+ * @param {Object} [options]
+ * @param {string[]} [options.projectTags=[]] - Stack tags from config
  */
-export async function installSkills(projectDir) {
+export async function installSkills(projectDir, { projectTags = [] } = {}) {
   const claudeSkillsDir = join(projectDir, '.claude', 'skills');
   mkdirSync(claudeSkillsDir, { recursive: true });
 
   for (const level of SKILL_LEVELS_TO_INSTALL) {
     const levelDir = join(FRAMEWORK_SKILLS_DIR, level);
     if (!existsSync(levelDir)) continue;
-    installSkillsFromDir(levelDir, claudeSkillsDir);
+    installSkillsFromDir(levelDir, claudeSkillsDir, projectTags);
+  }
+
+  // Collect installed morph-* skill names
+  const installed = new Set();
+  for (const entry of readdirSync(claudeSkillsDir)) {
+    if (existsSync(join(claudeSkillsDir, entry, 'SKILL.md'))) {
+      installed.add(entry);
+    }
+  }
+
+  // Cleanup orphan morph-* skill dirs that exist in source but were filtered out
+  const allSourceSkills = collectSourceSkillNames();
+  for (const entry of readdirSync(claudeSkillsDir)) {
+    if (!entry.startsWith('morph-')) continue;
+    if (!installed.has(entry) && allSourceSkills.has(entry)) {
+      rmSync(join(claudeSkillsDir, entry), { recursive: true, force: true });
+    }
   }
 }

package/CLAUDE.md

@@ -1,98 +0,0 @@
-# MORPH-SPEC Runtime Instructions
-
-> by Polymorphism Tech — Spec-driven development for .NET/Blazor/Next.js/Azure
-
----
-
-## Project Context
-
-@.morph/context/README.md
-
----
-
-## Critical Rules
-
-**NEVER:**
-- Skip to code without a specification
-- Implement without design approval
-- Ignore standards in `.morph/framework/standards/`
-- Create infrastructure manually
-- Generate code without defined contracts
-- List questions as plain text — always use the `AskUserQuestion` tool
-
-**ALWAYS:**
-- Follow the mandatory phases
-- Generate outputs in `.morph/features/{feature}/`
-- Document decisions in `decisions.md`
-- Checkpoint every 3 implemented tasks
-- Use Infrastructure as Code
-- Use `AskUserQuestion` tool whenever asking the user anything (1–4 questions per call; split into sequential calls if more)
-
----
-
-## Quick Reference
-
-| Command | Purpose |
-|---------|---------|
-| `/morph-proposal {feature}` | Full spec pipeline (phases 1–4, pauses for approval) |
-| `/morph-apply {feature}` | Implement feature (phase 5) |
-| `/morph-status` | Feature status dashboard |
-| `/morph-preflight` | Pre-implementation validation |
-
----
-
-## State & Outputs
-
-| Path | Notes |
-|------|-------|
-| `.morph/state.json` | **READ-ONLY** — use `morph-spec` CLI to update |
-| `.morph/features/{feature}/{phase}/` | Feature outputs organized by phase |
-| `.morph/framework/` | **READ-ONLY** — framework files managed by morph-spec |
-| `.morph/config/config.json` | Project configuration (editable) |
-
-### mark-output types
-
-Use `morph-spec state mark-output <feature> <type>` with one of these exact type names:
-
-| Type | Phase | kebab alias |
-|------|-------|-------------|
-| `proposal` | proposal | — |
-| `schemaAnalysis` | design | `schema-analysis` |
-| `spec` | design | — |
-| `contracts` | design | — |
-| `contractsVsa` | design | `contracts-vsa` |
-| `decisions` | design | — |
-| `clarifications` | clarify | — |
-| `tasks` | tasks | — |
-| `uiDesignSystem` | uiux | `ui-design-system` |
-| `uiMockups` | uiux | `ui-mockups` |
-| `uiComponents` | uiux | `ui-components` |
-| `uiFlows` | uiux | `ui-flows` |
-| `recap` | implement | — |
----
-
-## Phase Sequence
-
-```
-proposal → setup → [uiux] → design → clarify → tasks → implement → [sync]
-```
-
-Use `morph-spec status {feature}` to see current phase and pending approval gates.
-
----
-
-## Agents
-
-Tier-1 and tier-2 MORPH agents are available as native subagents in `.claude/agents/`.
-They can be invoked directly by Claude Code during multi-agent workflows.
-
----
-
-## Context Window Tip
-
-When using 3+ MCPs, add `"experimental": { "mcpCliMode": true }` to `.claude/settings.json`.
-MCP tools load on-demand instead of all at startup — keeps context clean for actual work.
-
----
-
-*MORPH-SPEC by Polymorphism Tech*