@polymorphism-tech/morph-spec 4.3.7 → 4.5.0

package/docs/plans/2026-02-22-native-alignment-impl.md

@@ -0,0 +1,925 @@
+# Native Alignment Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Align MORPH-SPEC with Claude Code's native platform patterns across 6 areas: skills format, rules as @-imports, CLAUDE.md consolidation, test file policy, standards additions, and state.json simplification.
+
+**Architecture:** Non-breaking changes first (Tasks 1-5), state.json simplification last (Tasks 6-8). All 614 existing tests must pass at each commit. Each task is independently testable.
+
+**Tech Stack:** Node.js ESM, `node:test`, `node:fs`, `node:path`. Run tests with `npm test`. Single test file: `node --test test/path/to/file.test.js`.
+
+---
+
+## Task 1: Fix Skills File Format (flat → subdirectory/SKILL.md)
+
+**Files:**
+- Modify: `src/utils/skills-installer.js`
+- Modify: `test/utils/skills-installer.test.js`
+
+**Context:** Claude Code's native skill format is `.claude/skills/<name>/SKILL.md`, not `.claude/skills/<name>.md`. Flat files prevent frontmatter features (allowed-tools, argument-hint) from working. Current code in `installSkillsFromDir()` does `copyFileSync(srcPath, join(destDir, entry))` — we change it to `mkdir(join(destDir, skillName))` + `copyFile(srcPath, join(destDir, skillName, 'SKILL.md'))`.
+
+**Step 1: Update skills-installer.js**
+
+Replace the body of `installSkillsFromDir` in `src/utils/skills-installer.js`:
+
+```javascript
+function installSkillsFromDir(srcDir, destDir) {
+  const entries = readdirSync(srcDir);
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry);
+    const stat = statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      installSkillsFromDir(srcPath, destDir);
+    } else if (entry.endsWith('.md') && entry !== 'README.md') {
+      const skillName = entry.slice(0, -3); // strip .md
+      const skillDir = join(destDir, skillName);
+      mkdirSync(skillDir, { recursive: true });
+      copyFileSync(srcPath, join(skillDir, 'SKILL.md'));
+    }
+  }
+}
+```
+
+Also add `mkdirSync` to the imports at line 11:
+```javascript
+import { mkdirSync, copyFileSync, existsSync, readdirSync, statSync } from 'fs';
+```
+(mkdirSync is already imported — verify it's there, add if missing)
+
+**Step 2: Run single test file to verify it fails**
+
+```bash
+node --test test/utils/skills-installer.test.js
+```
+
+Expected: FAIL — assertions check for `.md` filenames like `morph-checklist.md` which no longer exist.
+
+**Step 3: Update skills-installer.test.js**
+
+Replace the entire test file content:
+
+```javascript
+/**
+ * Tests for src/utils/skills-installer.js
+ */
+
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, readdir, stat } from 'node:fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { installSkills } from '../../src/utils/skills-installer.js';
+
+describe('installSkills', () => {
+  let tmpDir;
+
+  before(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'morph-skills-'));
+  });
+
+  after(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  test('creates .claude/skills/ directory', async () => {
+    await installSkills(tmpDir);
+    const entries = await readdir(join(tmpDir, '.claude', 'skills'));
+    assert.ok(entries.length > 0, 'should have skill directories installed');
+  });
+
+  test('installs skills as subdirectories (not flat .md files)', async () => {
+    await installSkills(tmpDir);
+    const entries = await readdir(join(tmpDir, '.claude', 'skills'));
+    // All entries should be directories, not .md files
+    for (const entry of entries) {
+      assert.ok(!entry.endsWith('.md'), `${entry} should be a directory, not a flat .md file`);
+    }
+  });
+
+  test('each skill directory contains SKILL.md', async () => {
+    await installSkills(tmpDir);
+    const entries = await readdir(join(tmpDir, '.claude', 'skills'));
+    for (const entry of entries) {
+      const skillMd = join(tmpDir, '.claude', 'skills', entry, 'SKILL.md');
+      const s = await stat(skillMd).catch(() => null);
+      assert.ok(s?.isFile(), `${entry}/SKILL.md should exist and be a file`);
+    }
+  });
+
+  test('installs level-0-meta skills (morph-checklist, code-review)', async () => {
+    await installSkills(tmpDir);
+    const entries = await readdir(join(tmpDir, '.claude', 'skills'));
+    assert.ok(entries.includes('morph-checklist'), 'morph-checklist/ directory should be installed');
+    assert.ok(entries.includes('code-review'), 'code-review/ directory should be installed');
+  });
+
+  test('installs level-1-workflows skills (phase-design, phase-implement)', async () => {
+    await installSkills(tmpDir);
+    const entries = await readdir(join(tmpDir, '.claude', 'skills'));
+    assert.ok(entries.includes('phase-design'), 'phase-design/ directory should be installed');
+    assert.ok(entries.includes('phase-implement'), 'phase-implement/ directory should be installed');
+  });
+
+  test('does not install README.md files as skills', async () => {
+    await installSkills(tmpDir);
+    const entries = await readdir(join(tmpDir, '.claude', 'skills'));
+    assert.ok(!entries.includes('README'), 'README should not be installed as a skill');
+    assert.ok(!entries.includes('README.md'), 'README.md should not appear in skills dir');
+  });
+
+  test('installs at least 10 skills total', async () => {
+    await installSkills(tmpDir);
+    const entries = await readdir(join(tmpDir, '.claude', 'skills'));
+    assert.ok(entries.length >= 10, `should install at least 10 skills, got ${entries.length}`);
+  });
+
+  test('is idempotent — running twice produces same directory count', async () => {
+    await installSkills(tmpDir);
+    const firstCount = (await readdir(join(tmpDir, '.claude', 'skills'))).length;
+    await installSkills(tmpDir);
+    const secondCount = (await readdir(join(tmpDir, '.claude', 'skills'))).length;
+    assert.strictEqual(firstCount, secondCount, 'directory count should not change on second run');
+  });
+});
+```
+
+**Step 4: Run test to verify it passes**
+
+```bash
+node --test test/utils/skills-installer.test.js
+```
+
+Expected: all 8 tests PASS.
+
+**Step 5: Run full suite**
+
+```bash
+npm test
+```
+
+Expected: 614+ tests pass, 0 fail.
+
+**Step 6: Commit**
+
+```bash
+git add src/utils/skills-installer.js test/utils/skills-installer.test.js
+git commit -m "feat(skills): install as subdirectory/SKILL.md — native Claude Code format"
+```
+
+---
+
+## Task 2: Rules as Dynamic @-imports
+
+**Files:**
+- Modify: `framework/rules/csharp-standards.md`
+- Modify: `framework/rules/frontend-standards.md`
+- Modify: `framework/rules/testing-standards.md`
+- Modify: `framework/rules/infrastructure-standards.md`
+
+**Context:** Rules currently contain static copies of standards content. Replacing with @-imports makes them always current. The @-import paths use `.morph/framework/standards/` because rules are installed into user projects where that path is valid after `morph-spec init`. `morph-workflow.md` is NOT changed here — it has its own content (not a standards file).
+
+No code changes — only markdown content changes. No tests needed (framework content files have no unit tests).
+
+**Step 1: Replace csharp-standards.md body**
+
+Replace everything after the frontmatter (after line 5 `---`) in `framework/rules/csharp-standards.md` with:
+
+```markdown
+---
+paths:
+  - "**/*.cs"
+  - "**/*.csproj"
+---
+
+# C# and .NET Standards
+
+@.morph/framework/standards/core/coding.md
+@.morph/framework/standards/backend/dotnet.md
+```
+
+> **Note:** Verify the exact filenames exist in `framework/standards/core/` and `framework/standards/backend/`. Run `ls framework/standards/core/` and `ls framework/standards/backend/` first. Use the actual filenames found.
+
+**Step 2: Replace frontend-standards.md body**
+
+```markdown
+---
+paths:
+  - "**/*.razor"
+  - "**/*.tsx"
+  - "**/*.ts"
+  - "**/*.css"
+  - "**/*.scss"
+---
+
+# Frontend Standards
+
+@.morph/framework/standards/frontend/blazor.md
+@.morph/framework/standards/frontend/nextjs.md
+@.morph/framework/standards/frontend/css.md
+```
+
+> Same note: verify filenames first with `ls framework/standards/frontend/`.
+
+**Step 3: Replace testing-standards.md body**
+
+```markdown
+---
+paths:
+  - "tests/**"
+  - "**/*.test.*"
+  - "**/*.spec.*"
+  - "**/*Tests.cs"
+---
+
+# Testing Standards
+
+@.morph/framework/standards/core/testing.md
+```
+
+**Step 4: Replace infrastructure-standards.md body**
+
+```markdown
+---
+paths:
+  - "**/*.bicep"
+  - "**/Dockerfile"
+  - "**/docker-compose*.yml"
+  - "**/pipelines/**"
+  - "**/.github/workflows/**"
+---
+
+# Infrastructure Standards
+
+@.morph/framework/standards/infrastructure/azure.md
+@.morph/framework/standards/infrastructure/docker.md
+```
+
+**Step 5: Verify actual standard filenames before writing**
+
+```bash
+ls framework/standards/core/
+ls framework/standards/backend/
+ls framework/standards/frontend/
+ls framework/standards/infrastructure/
+```
+
+Adjust @-import paths above to match actual filenames.
+
+**Step 6: Run full suite (no tests for framework content, but verify nothing broke)**
+
+```bash
+npm test
+```
+
+Expected: same pass count as before.
+
+**Step 7: Commit**
+
+```bash
+git add framework/rules/csharp-standards.md framework/rules/frontend-standards.md framework/rules/testing-standards.md framework/rules/infrastructure-standards.md
+git commit -m "feat(rules): replace static content with @-imports from framework/standards"
+```
+
+---
+
+## Task 3: CLAUDE.md Consolidation
+
+**Files:**
+- Modify: `framework/CLAUDE.md` — merge both files into one
+- Delete: `framework/CLAUDE_runtime.md`
+- Modify: `src/commands/project/init.js` — change CLAUDE_runtime.md → CLAUDE.md as source
+- Modify: `src/commands/project/update.js` — same
+- Modify: `test/commands/init.test.js` — update source file reference
+- Modify: `test/commands/update.test.js` — update source file reference
+
+**Context:** `init.js` copies `framework/CLAUDE_runtime.md` → `.claude/CLAUDE.md` in user projects. After this task, it copies `framework/CLAUDE.md` instead. The merged file has all content from both plus MCP deferred mode note.
+
+**Step 1: Find the CLAUDE_runtime.md copy line in init.js**
+
+```bash
+grep -n "CLAUDE_runtime" src/commands/project/init.js
+grep -n "CLAUDE_runtime" src/commands/project/update.js
+```
+
+Note the exact line numbers.
+
+**Step 2: Write new merged framework/CLAUDE.md**
+
+Replace the entire content of `framework/CLAUDE.md`:
+
+```markdown
+# 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
+
+**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
+
+---
+
+## 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) |
+
+---
+
+## Phase Sequence
+
+```
+proposal → setup → [uiux] → design → clarify → tasks → implement → [sync]
+```
+
+Use `morph-spec state show {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 v4.5.0 by Polymorphism Tech*
+```
+
+**Step 3: Update init.js source reference**
+
+Find the line that copies CLAUDE_runtime.md and change it to CLAUDE.md. It will look something like:
+
+```javascript
+// BEFORE (find exact line with grep result from Step 1):
+await copyFile(join(frameworkDir, 'CLAUDE_runtime.md'), join(projectDir, '.claude', 'CLAUDE.md'));
+
+// AFTER:
+await copyFile(join(frameworkDir, 'CLAUDE.md'), join(projectDir, '.claude', 'CLAUDE.md'));
+```
+
+**Step 4: Update update.js source reference**
+
+Same change in `src/commands/project/update.js`.
+
+**Step 5: Run test files to find failing assertions**
+
+```bash
+node --test test/commands/init.test.js
+node --test test/commands/update.test.js
+```
+
+Find any assertions referencing `CLAUDE_runtime.md` and change them to `CLAUDE.md`.
+
+**Step 6: Delete framework/CLAUDE_runtime.md**
+
+```bash
+git rm framework/CLAUDE_runtime.md
+```
+
+**Step 7: Run full suite**
+
+```bash
+npm test
+```
+
+Expected: same pass count, 0 fail.
+
+**Step 8: Commit**
+
+```bash
+git add framework/CLAUDE.md src/commands/project/init.js src/commands/project/update.js test/commands/init.test.js test/commands/update.test.js
+git commit -m "feat(claude-md): merge CLAUDE.md + CLAUDE_runtime.md into single unified file"
+```
+
+---
+
+## Task 4: Test File Policy in morph-workflow.md
+
+**Files:**
+- Modify: `framework/rules/morph-workflow.md`
+
+**Context:** No hook — behavioral guidance only. Add "Test File Policy" section at the end of the file (before the final `*MORPH-SPEC by Polymorphism Tech*` footer). No tests needed.
+
+**Step 1: Add section to framework/rules/morph-workflow.md**
+
+Append before the final footer line:
+
+```markdown
+---
+
+## Test File Policy
+
+When a test fails, always follow this order:
+
+1. **Analyze first** — determine if the IMPLEMENTATION is wrong or the TEST SPEC is wrong
+2. **Fix implementation first** — the test is the spec; trust it by default
+3. **Only modify a test file if the test expectation itself is incorrect** — wrong expected value, wrong behavior modeled
+4. **Before modifying any test file, explain WHY the test spec is wrong** — what the correct behavior is and why the test doesn't model it
+
+Do not modify test files to make a failing test pass when the implementation is the actual problem.
+
+---
+```
+
+**Step 2: Run full suite**
+
+```bash
+npm test
+```
+
+Expected: same pass count.
+
+**Step 3: Commit**
+
+```bash
+git add framework/rules/morph-workflow.md
+git commit -m "feat(rules): add Test File Policy to morph-workflow rule"
+```
+
+---
+
+## Task 5: Standards and Templates Additions
+
+**Files:**
+- Modify: `framework/rules/frontend-standards.md` — note: already updated in Task 2 with @-imports, so also update the source standard file
+- Create: `framework/templates/docs/user-stories.md`
+
+**Context:** TypeScript strict mode guidance goes into the actual standards file (which the rule now @-imports). User stories template is a new Handlebars template.
+
+**Step 1: Check if TypeScript strict is already in frontend standards**
+
+```bash
+grep -r "strict" framework/standards/frontend/
+```
+
+If not present, add to the appropriate standards file (e.g., `framework/standards/frontend/typescript.md` or whatever file exists):
+
+```markdown
+## TypeScript Strict Mode (Required)
+
+Always enable `"strict": true` in `tsconfig.json`. This is non-negotiable for
+agent-assisted development because agents rely on compiler errors to self-correct.
+Without strict mode, type/null errors only surface at runtime where agents cannot observe them.
+
+```json
+{
+  "compilerOptions": {
+    "strict": true,
+    "noUncheckedIndexedAccess": true
+  }
+}
+```
+
+Strict mode enables: `strictNullChecks`, `noImplicitAny`, `strictFunctionTypes`, `strictPropertyInitialization`.
+```
+
+**Step 2: Create framework/templates/docs/user-stories.md**
+
+```markdown
+# User Stories: {{featureName}}
+
+> Generated: {{date}} | Feature: {{featureName}} | Status: Draft
+
+---
+
+## Story 1: [Actor] [Action]
+
+**Feature:** {{featureName}}
+**Priority:** High / Medium / Low
+
+### Optimal Path
+1. [Step 1]
+2. [Step 2]
+3. [Step 3 — success state]
+
+### Edge Cases
+- [Edge case] → [Expected behavior]
+- [Error condition] → [Expected error handling]
+
+### Acceptance Criteria
+- [ ] [Measurable criterion 1]
+- [ ] [Measurable criterion 2]
+- [ ] Edge: [edge case criterion]
+
+---
+
+## Story 2: [Actor] [Action]
+
+[Repeat structure above]
+
+---
+
+*Generated by MORPH-SPEC — complete before implementation begins*
+```
+
+**Step 3: Run full suite**
+
+```bash
+npm test
+```
+
+Expected: same pass count.
+
+**Step 4: Commit**
+
+```bash
+git add framework/standards/ framework/templates/docs/user-stories.md
+git commit -m "feat(standards): add TypeScript strict mode requirement; add user-stories template"
+```
+
+---
+
+## Task 6: Remove `outputs` and `phase` from state-manager.js
+
+**Files:**
+- Modify: `src/core/state/state-manager.js`
+- Modify: `test/lib/state-manager.test.js`
+
+**Context:** `ensureFeature()` at line 191 sets `outputs: getAllOutputPaths(featureName)` and `phase: "proposal"`. Remove both fields. Add two new exported helper functions: `derivePhase(featurePath)` and `deriveOutputs(featureName)`. Add v4→v5 migration in `loadState()`.
+
+**Step 1: Add helper functions to state-manager.js**
+
+Add these two new exported functions after the existing `getStatePath()` function (around line 25):
+
+```javascript
+/**
+ * Derive current phase from filesystem — checks for phase folders in descending order.
+ * Returns the phase corresponding to the highest-numbered folder present.
+ *
+ * @param {string} featurePath - Absolute path to .morph/features/{feature}/
+ * @returns {string} Phase name: 'implement' | 'tasks' | 'uiux' | 'design' | 'proposal' | 'setup'
+ */
+export function derivePhase(featurePath) {
+  const phaseMap = [
+    ['4-implement', 'implement'],
+    ['3-tasks', 'tasks'],
+    ['2-ui', 'uiux'],
+    ['1-design', 'design'],
+    ['0-proposal', 'proposal'],
+  ];
+  for (const [folder, phase] of phaseMap) {
+    if (existsSync(join(featurePath, folder))) return phase;
+  }
+  return 'setup';
+}
+
+/**
+ * Derive output existence from filesystem — checks if each output file exists at its expected path.
+ * Returns an object matching the old outputs shape for backwards-compatible display.
+ *
+ * @param {string} featureName - Feature name
+ * @param {string} [baseDir] - Project base dir (defaults to cwd)
+ * @returns {Object} Map of outputType → { created: boolean, path: string }
+ */
+export function deriveOutputs(featureName, baseDir = process.cwd()) {
+  const outputPaths = getAllOutputPaths(featureName);
+  const result = {};
+  for (const [type, { path: relPath }] of Object.entries(outputPaths)) {
+    const absPath = join(baseDir, relPath);
+    result[type] = { created: existsSync(absPath), path: relPath };
+  }
+  return result;
+}
+```
+
+**Step 2: Remove `outputs` and `phase` from ensureFeature()**
+
+In `ensureFeature()` (around line 191), change:
+
+```javascript
+// REMOVE these two lines:
+phase: "proposal",
+outputs: getAllOutputPaths(featureName),
+```
+
+The feature object after the change should NOT have `phase` or `outputs` keys.
+
+**Step 3: Add v4→v5 migration in loadState()**
+
+In `loadState()`, after the existing v3→v4 migration block (around line 65), add:
+
+```javascript
+// Migrate v4.x → v5.0.0: remove outputs and phase (now derived from filesystem)
+if (state.version && state.version.startsWith('4.')) {
+  state.version = '5.0.0';
+  for (const feature of Object.values(state.features || {})) {
+    delete feature.outputs;
+    delete feature.phase;
+  }
+  writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
+}
+```
+
+**Step 4: Update initState() version string**
+
+Change `version: "4.0.0"` to `version: "5.0.0"` in `initState()`.
+
+**Step 5: Run state-manager tests to find failures**
+
+```bash
+node --test test/lib/state-manager.test.js
+```
+
+Find tests that assert on `feature.phase` or `feature.outputs` and update them:
+- Tests asserting `feature.phase === 'design'` → remove or replace with `derivePhase()` call
+- Tests asserting `feature.outputs.spec.created` → remove or replace with `deriveOutputs()` call
+- Tests asserting `state.version === '4.0.0'` → change to `'5.0.0'`
+
+**Step 6: Add new tests for derivePhase and deriveOutputs**
+
+In `test/lib/state-manager.test.js`, add:
+
+```javascript
+import { derivePhase, deriveOutputs } from '../../src/core/state/state-manager.js';
+import { mkdirSync } from 'fs';
+
+describe('derivePhase', () => {
+  test('returns setup when no phase folders exist', () => {
+    const dir = createTempDir();
+    assert.strictEqual(derivePhase(join(dir, '.morph', 'features', 'f')), 'setup');
+    cleanupTempDir(dir);
+  });
+
+  test('returns proposal when 0-proposal/ exists', () => {
+    const dir = createTempDir();
+    const featurePath = join(dir, '.morph', 'features', 'f');
+    mkdirSync(join(featurePath, '0-proposal'), { recursive: true });
+    assert.strictEqual(derivePhase(featurePath), 'proposal');
+    cleanupTempDir(dir);
+  });
+
+  test('returns tasks when 3-tasks/ is highest folder', () => {
+    const dir = createTempDir();
+    const featurePath = join(dir, '.morph', 'features', 'f');
+    mkdirSync(join(featurePath, '0-proposal'), { recursive: true });
+    mkdirSync(join(featurePath, '1-design'), { recursive: true });
+    mkdirSync(join(featurePath, '3-tasks'), { recursive: true });
+    assert.strictEqual(derivePhase(featurePath), 'tasks');
+    cleanupTempDir(dir);
+  });
+
+  test('returns implement when 4-implement/ exists', () => {
+    const dir = createTempDir();
+    const featurePath = join(dir, '.morph', 'features', 'f');
+    mkdirSync(join(featurePath, '4-implement'), { recursive: true });
+    assert.strictEqual(derivePhase(featurePath), 'implement');
+    cleanupTempDir(dir);
+  });
+});
+
+describe('state migration v4 → v5', () => {
+  test('removes outputs and phase from v4 state on load', () => {
+    const dir = createTempDir();
+    process.chdir(dir);
+    // Write a v4.0.0 state with outputs and phase
+    const v4State = {
+      version: '4.0.0',
+      project: { name: 'Test' },
+      features: {
+        'my-feature': {
+          phase: 'design',
+          outputs: { spec: { created: true, path: 'some/path' } },
+          workflow: 'standard'
+        }
+      }
+    };
+    mkdirSync(join(dir, '.morph'), { recursive: true });
+    writeFileSync(join(dir, '.morph', 'state.json'), JSON.stringify(v4State), 'utf8');
+
+    const state = loadState();
+    assert.strictEqual(state.version, '5.0.0');
+    assert.strictEqual(state.features['my-feature'].phase, undefined);
+    assert.strictEqual(state.features['my-feature'].outputs, undefined);
+    assert.strictEqual(state.features['my-feature'].workflow, 'standard'); // kept
+
+    process.chdir(originalCwd);
+    cleanupTempDir(dir);
+  });
+});
+```
+
+**Step 7: Run full suite**
+
+```bash
+npm test
+```
+
+Expected: 614+ tests pass, 0 fail.
+
+**Step 8: Commit**
+
+```bash
+git add src/core/state/state-manager.js test/lib/state-manager.test.js
+git commit -m "feat(state): remove outputs+phase fields; derive from filesystem at runtime"
+```
+
+---
+
+## Task 7: Delete track-output-creation hook + unregister it
+
+**Files:**
+- Delete: `framework/hooks/claude-code/post-tool-use/track-output-creation.js`
+- Modify: `src/utils/hooks-installer.js` — remove PostToolUse/Write entry for track-output-creation
+- Delete: `test/hooks/track-output-creation.test.js`
+- Modify: `test/hooks/hooks-installer.test.js` — verify hook no longer registered
+
+**Context:** `track-output-creation.js` existed solely to mark `outputs.{type}.created = true` in state.json. With `outputs` removed from state.json (Task 6), this hook has no purpose.
+
+**Step 1: Remove the PostToolUse/Write hook entry from hooks-installer.js**
+
+In `src/utils/hooks-installer.js`, find and delete the entire block (around lines 92-100):
+
+```javascript
+// DELETE this entire block:
+// === PostToolUse: Write ===
+{
+  event: 'PostToolUse',
+  matcher: 'Write',
+  hooks: [{
+    type: 'command',
+    command: 'node framework/hooks/claude-code/post-tool-use/track-output-creation.js'
+  }]
+},
+```
+
+**Step 2: Delete the hook file**
+
+```bash
+git rm framework/hooks/claude-code/post-tool-use/track-output-creation.js
+git rm test/hooks/track-output-creation.test.js
+```
+
+**Step 3: Update hooks-installer.test.js**
+
+Find any test that asserts `PostToolUse` is installed with `track-output-creation` and either remove it or change it to assert the hook is NOT registered. Add:
+
+```javascript
+test('does NOT register track-output-creation hook (removed in v5)', async () => {
+  await installClaudeHooks(tempDir);
+  const settings = readSettings();
+  const postToolUseHooks = settings.hooks?.PostToolUse ?? [];
+  const commands = postToolUseHooks.flatMap(h => h.hooks ?? []).map(h => h.command ?? '');
+  assert.ok(
+    !commands.some(c => c.includes('track-output-creation')),
+    'track-output-creation should not be registered'
+  );
+});
+```
+
+**Step 4: Run hooks tests**
+
+```bash
+node --test test/hooks/hooks-installer.test.js
+```
+
+Expected: all pass.
+
+**Step 5: Run full suite**
+
+```bash
+npm test
+```
+
+Expected: test count slightly lower (track-output-creation.test.js removed), 0 fail.
+
+**Step 6: Commit**
+
+```bash
+git add src/utils/hooks-installer.js test/hooks/hooks-installer.test.js
+git commit -m "feat(hooks): remove track-output-creation — outputs now derived from filesystem"
+```
+
+---
+
+## Task 8: Update status command + version bump
+
+**Files:**
+- Modify: `src/commands/project/status.js` — use derivePhase/deriveOutputs
+- Modify: `test/commands/status.test.js` — update assertions
+- Modify: `package.json` — version 4.4.0 → 4.5.0
+
+**Context:** `morph-spec status <feature>` currently reads `feature.phase` and `feature.outputs` from state.json. After Task 6 these fields don't exist. Update status to call `derivePhase()` and `deriveOutputs()` instead.
+
+**Step 1: Find where status.js reads phase and outputs**
+
+```bash
+grep -n "\.phase\|\.outputs" src/commands/project/status.js
+```
+
+**Step 2: Update status.js to use derive helpers**
+
+Import and use the new helpers:
+
+```javascript
+import { loadState, derivePhase, deriveOutputs } from '../../core/state/state-manager.js';
+import { join } from 'path';
+
+// Where phase was read:
+// BEFORE: const phase = feature.phase;
+// AFTER:
+const featurePath = join(process.cwd(), '.morph', 'features', featureName);
+const phase = derivePhase(featurePath);
+
+// Where outputs were read:
+// BEFORE: const outputs = feature.outputs;
+// AFTER:
+const outputs = deriveOutputs(featureName);
+```
+
+**Step 3: Run status tests**
+
+```bash
+node --test test/commands/status.test.js
+```
+
+Fix any failing assertions — they'll be about phase values or outputs shape. The shape of `deriveOutputs()` return value matches the old `feature.outputs` shape (`{ type: { created: boolean, path: string } }`), so display logic should need minimal changes.
+
+**Step 4: Bump version in package.json**
+
+Change `"version": "4.4.0"` to `"version": "4.5.0"`.
+
+**Step 5: Update version reference in framework/CLAUDE.md footer**
+
+Change `*MORPH-SPEC v4.4.0 by Polymorphism Tech*` to `*MORPH-SPEC v4.5.0 by Polymorphism Tech*`.
+(This file was already rewritten in Task 3 with v4.5.0, so just verify it's correct.)
+
+**Step 6: Run full suite — final verification**
+
+```bash
+npm test
+```
+
+Expected: all tests pass, 0 fail. Count may differ from original (some tests removed, some added).
+
+**Step 7: Final commit**
+
+```bash
+git add src/commands/project/status.js test/commands/status.test.js package.json framework/CLAUDE.md
+git commit -m "feat(status): derive phase+outputs from filesystem; bump version to 4.5.0"
+```
+
+---
+
+## Final Verification
+
+After all 8 tasks:
+
+```bash
+npm test
+git log --oneline -8
+```
+
+Expected log:
+```
+feat(status): derive phase+outputs from filesystem; bump version to 4.5.0
+feat(hooks): remove track-output-creation — outputs now derived from filesystem
+feat(state): remove outputs+phase fields; derive from filesystem at runtime
+feat(standards): add TypeScript strict mode requirement; add user-stories template
+feat(rules): add Test File Policy to morph-workflow rule
+feat(claude-md): merge CLAUDE.md + CLAUDE_runtime.md into single unified file
+feat(rules): replace static content with @-imports from framework/standards
+feat(skills): install as subdirectory/SKILL.md — native Claude Code format
+```