@sienklogic/plan-build-run 2.21.1 → 2.21.2

package/plugins/pbr/scripts/test/config.test.js

@@ -0,0 +1,126 @@
+/**
+ * Unit tests for lib/config.js — Config loading, validation, and depth profiles.
+ */
+
+const { describe, it, afterEach } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { configLoad, configClearCache, resolveDepthProfile, mergeUserDefaults, DEPTH_PROFILE_DEFAULTS } = require('../lib/config');
+
+afterEach(() => {
+  configClearCache();
+});
+
+describe('configLoad', () => {
+  it('returns null when config.json is missing', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'config-test-'));
+    const result = configLoad(tmpDir);
+    assert.strictEqual(result, null);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('returns parsed config when config.json exists', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'config-test-'));
+    const config = { mode: 'autonomous', depth: 'standard' };
+    fs.writeFileSync(path.join(tmpDir, 'config.json'), JSON.stringify(config), 'utf8');
+
+    const result = configLoad(tmpDir);
+    assert.strictEqual(result.mode, 'autonomous');
+    assert.strictEqual(result.depth, 'standard');
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('returns null for invalid JSON', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'config-test-'));
+    fs.writeFileSync(path.join(tmpDir, 'config.json'), '{ invalid json }', 'utf8');
+
+    const result = configLoad(tmpDir);
+    assert.strictEqual(result, null);
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('uses mtime-based caching', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'config-test-'));
+    fs.writeFileSync(path.join(tmpDir, 'config.json'), '{"mode":"interactive"}', 'utf8');
+
+    const result1 = configLoad(tmpDir);
+    const result2 = configLoad(tmpDir);
+    assert.strictEqual(result1, result2); // Same object reference (cached)
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+});
+
+describe('resolveDepthProfile', () => {
+  it('returns standard defaults when config is null', () => {
+    const { depth, profile } = resolveDepthProfile(null);
+    assert.strictEqual(depth, 'standard');
+    assert.strictEqual(profile['features.research_phase'], true);
+  });
+
+  it('returns quick profile when depth is quick', () => {
+    const { depth, profile } = resolveDepthProfile({ depth: 'quick' });
+    assert.strictEqual(depth, 'quick');
+    assert.strictEqual(profile['features.research_phase'], false);
+    assert.strictEqual(profile['features.plan_checking'], false);
+  });
+
+  it('returns comprehensive profile when depth is comprehensive', () => {
+    const { depth, profile } = resolveDepthProfile({ depth: 'comprehensive' });
+    assert.strictEqual(depth, 'comprehensive');
+    assert.strictEqual(profile['features.inline_verify'], true);
+  });
+
+  it('merges user overrides from depth_profiles', () => {
+    const config = {
+      depth: 'standard',
+      depth_profiles: {
+        standard: { 'scan.mapper_count': 6 }
+      }
+    };
+    const { profile } = resolveDepthProfile(config);
+    assert.strictEqual(profile['scan.mapper_count'], 6);
+    // Other defaults preserved
+    assert.strictEqual(profile['features.research_phase'], true);
+  });
+});
+
+describe('mergeUserDefaults', () => {
+  it('uses user defaults when base key is missing', () => {
+    const base = { mode: 'interactive' };
+    const defaults = { mode: 'autonomous', depth: 'comprehensive' };
+    const merged = mergeUserDefaults(base, defaults);
+    assert.strictEqual(merged.mode, 'interactive'); // base wins
+    assert.strictEqual(merged.depth, 'comprehensive'); // from defaults
+  });
+
+  it('deep-merges nested objects', () => {
+    const base = { features: { research_phase: true } };
+    const defaults = { features: { plan_checking: true, research_phase: false } };
+    const merged = mergeUserDefaults(base, defaults);
+    assert.strictEqual(merged.features.research_phase, true); // base wins
+    assert.strictEqual(merged.features.plan_checking, true); // from defaults
+  });
+
+  it('returns base unchanged when defaults is null', () => {
+    const base = { mode: 'interactive' };
+    const merged = mergeUserDefaults(base, null);
+    assert.deepStrictEqual(merged, base);
+  });
+});
+
+describe('config paths use path.join', () => {
+  it('USER_DEFAULTS_PATH uses platform path separator', () => {
+    const { USER_DEFAULTS_PATH } = require('../lib/config');
+    // Should contain the platform-appropriate separator
+    assert.ok(USER_DEFAULTS_PATH.includes('pbr-defaults.json'));
+    // Should NOT contain a mix of forward and back slashes (unless on platform that uses them)
+    if (process.platform === 'win32') {
+      assert.ok(USER_DEFAULTS_PATH.includes('\\'));
+    }
+  });
+});

package/plugins/pbr/scripts/test/cross-platform.test.js

@@ -0,0 +1,120 @@
+/**
+ * Cross-platform tests — CRLF normalization, path construction, MSYS path regex.
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const path = require('path');
+const { parseYamlFrontmatter } = require('../lib/core');
+const { parseStateMd } = require('../lib/state');
+const { parseRoadmapMd } = require('../lib/roadmap');
+const { normalizeMsysPath } = require('../lib/msys-path');
+
+// --- CRLF normalization ---
+
+describe('CRLF normalization', () => {
+  const FRONTMATTER_LF = '---\nversion: 2\ncurrent_phase: 5\nstatus: "built"\n---\n# Test';
+  const FRONTMATTER_CRLF = '---\r\nversion: 2\r\ncurrent_phase: 5\r\nstatus: "built"\r\n---\r\n# Test';
+
+  it('parseYamlFrontmatter: CRLF produces same result as LF', () => {
+    const lfResult = parseYamlFrontmatter(FRONTMATTER_LF);
+    const crlfResult = parseYamlFrontmatter(FRONTMATTER_CRLF);
+    assert.strictEqual(crlfResult.version, lfResult.version);
+    assert.strictEqual(crlfResult.current_phase, lfResult.current_phase);
+    assert.strictEqual(crlfResult.status, lfResult.status);
+  });
+
+  it('parseStateMd: CRLF produces same result as LF', () => {
+    const STATE = '---\nversion: 2\ncurrent_phase: 3\nstatus: "building"\nprogress_percent: 50\nplans_complete: 2\nplans_total: 4\n---\n# State\nPhase: 3 of 8\nStatus: Building\nPlan: 2 of 4';
+    const lfResult = parseStateMd(STATE);
+    const crlfResult = parseStateMd(STATE.replace(/\n/g, '\r\n'));
+    assert.strictEqual(crlfResult.current_phase, lfResult.current_phase);
+    assert.strictEqual(crlfResult.status, lfResult.status);
+    assert.strictEqual(crlfResult.plans_complete, lfResult.plans_complete);
+  });
+
+  it('parseRoadmapMd: CRLF produces same result as LF', () => {
+    const ROADMAP = '# Roadmap\n\n## Phase Overview\n\n| Phase | Name | Goal |\n|---|---|---|\n| 01 | Setup | Init |\n| 02 | Build | Core |\n';
+    const lfResult = parseRoadmapMd(ROADMAP);
+    const crlfResult = parseRoadmapMd(ROADMAP.replace(/\n/g, '\r\n'));
+    assert.strictEqual(crlfResult.phases.length, lfResult.phases.length);
+    assert.strictEqual(crlfResult.phases[0].number, lfResult.phases[0].number);
+    assert.strictEqual(crlfResult.phases[1].name, lfResult.phases[1].name);
+  });
+
+  it('mixed line endings (\\r\\n and \\n) still parse correctly', () => {
+    // Simulate a file with inconsistent line endings
+    const mixed = '---\r\nversion: 2\ncurrent_phase: 7\r\nstatus: "planned"\n---\n# Test';
+    const result = parseYamlFrontmatter(mixed);
+    assert.strictEqual(result.version, 2);
+    assert.strictEqual(result.current_phase, 7);
+    assert.strictEqual(result.status, 'planned');
+  });
+});
+
+// --- Path construction ---
+
+describe('path construction', () => {
+  it('path.join produces valid paths on current platform', () => {
+    const result = path.join('plugins', 'pbr', 'scripts', 'lib', 'state.js');
+    assert.ok(result.includes('state.js'));
+    // No double separators
+    assert.ok(!result.includes('//'));
+    assert.ok(!result.includes('\\\\'));
+  });
+
+  it('path.join handles mixed separators', () => {
+    const result = path.join('plugins/pbr', 'scripts\\lib', 'core.js');
+    assert.ok(result.includes('core.js'));
+    assert.ok(result.includes('plugins'));
+  });
+
+  it('path.resolve produces absolute path', () => {
+    const result = path.resolve('plugins', 'pbr', 'scripts');
+    assert.ok(path.isAbsolute(result));
+  });
+});
+
+// --- MSYS path regex ---
+
+describe('MSYS path regex', () => {
+  it('converts /d/Repos/foo to D:\\Repos\\foo', () => {
+    const result = normalizeMsysPath('/d/Repos/foo');
+    assert.strictEqual(result, 'D:\\Repos\\foo');
+  });
+
+  it('converts /D/Repos/foo to D:\\Repos\\foo (case insensitive drive)', () => {
+    const result = normalizeMsysPath('/D/Repos/foo');
+    assert.strictEqual(result, 'D:\\Repos\\foo');
+  });
+
+  it('converts /c/Users/test/project to C:\\Users\\test\\project', () => {
+    const result = normalizeMsysPath('/c/Users/test/project');
+    assert.strictEqual(result, 'C:\\Users\\test\\project');
+  });
+
+  it('leaves Windows-native paths unchanged', () => {
+    const result = normalizeMsysPath('D:\\Repos\\foo');
+    assert.strictEqual(result, 'D:\\Repos\\foo');
+  });
+
+  it('leaves relative paths unchanged', () => {
+    const result = normalizeMsysPath('plugins/pbr/scripts');
+    assert.strictEqual(result, 'plugins/pbr/scripts');
+  });
+
+  it('leaves Unix absolute paths with >1 char dir unchanged', () => {
+    const result = normalizeMsysPath('/usr/local/bin');
+    assert.strictEqual(result, '/usr/local/bin');
+  });
+
+  it('handles null/empty input', () => {
+    assert.strictEqual(normalizeMsysPath(null), null);
+    assert.strictEqual(normalizeMsysPath(''), '');
+  });
+
+  it('handles deep nested MSYS paths', () => {
+    const result = normalizeMsysPath('/e/Projects/my-app/plugins/pbr/scripts/lib');
+    assert.strictEqual(result, 'E:\\Projects\\my-app\\plugins\\pbr\\scripts\\lib');
+  });
+});

package/plugins/pbr/scripts/test/fixtures/config.json

@@ -0,0 +1,20 @@
+{
+  "mode": "interactive",
+  "depth": "standard",
+  "schema_version": 2,
+  "parallelization": {
+    "enabled": true,
+    "plan_level": false,
+    "max_concurrent_agents": 3
+  },
+  "git": {
+    "branching": "phase",
+    "auto_commit": true
+  },
+  "features": {
+    "research_phase": true,
+    "plan_checking": true,
+    "goal_verification": true,
+    "inline_verify": false
+  }
+}

package/plugins/pbr/scripts/test/fixtures/plan.md

@@ -0,0 +1,54 @@
+---
+phase: 01-foundation
+plan: 01
+type: execute
+wave: 1
+depends_on: []
+files_modified:
+  - src/core/setup.js
+  - src/core/config.js
+autonomous: true
+must_haves:
+  truths:
+    - "Core setup module exists and exports expected functions"
+  artifacts:
+    - path: "src/core/setup.js"
+      provides: "Project initialization logic"
+---
+
+<objective>
+Set up the core project structure with initialization and configuration modules.
+</objective>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+</context>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Create core setup module</name>
+  <files>src/core/setup.js</files>
+  <action>
+    Create src/core/setup.js with project initialization logic.
+  </action>
+  <verify>
+    <automated>node -e "require('./src/core/setup.js')"</automated>
+  </verify>
+  <done>
+    setup.js exists and can be required without errors.
+  </done>
+</task>
+
+</tasks>
+
+<verification>
+1. `node -e "require('./src/core/setup.js')"` -- module loads
+2. `node -e "require('./src/core/config.js')"` -- config loads
+</verification>
+
+<success_criteria>
+- Core setup module exists with initialization function
+- Config module exists with load/validate functions
+</success_criteria>

package/plugins/pbr/scripts/test/fixtures/project.md

@@ -0,0 +1,30 @@
+# Project: Fixture Test Project
+
+## What This Is
+
+A minimal PROJECT.md fixture for testing the PBR file format parsers. This file follows the Phase 5 consolidated format where CONTEXT.md is merged into the Context section.
+
+## Core Value
+
+Ensure PBR planning file formats remain stable across versions by providing canonical fixture examples that automated tests validate against production parsers.
+
+## Requirements Summary
+
+| Category | Count | Key Requirements |
+|----------|-------|-----------------|
+| Setup | 2 | SETUP-01, SETUP-02 |
+| Features | 2 | FEAT-01, FEAT-02 |
+| Testing | 1 | TEST-01 |
+
+## Context
+
+**Tech stack:** Node.js, CommonJS modules, node:test runner
+**Target users:** PBR plugin developers and contributors
+**Key constraint:** Zero external dependencies for core parsing
+
+## Key Decisions
+
+| Phase | Decision | Rationale |
+|-------|----------|-----------|
+| Phase 1 | Use built-in modules only | Zero-dependency operation |
+| Phase 2 | CommonJS over ESM | Plugin ecosystem compatibility |

package/plugins/pbr/scripts/test/fixtures/roadmap.md

@@ -0,0 +1,55 @@
+# Roadmap
+
+## Overview
+
+A minimal roadmap fixture with 2 phases for testing.
+
+## Phases
+
+- [x] Phase 1: Foundation
+- [ ] Phase 2: Features
+
+## Phase Details
+
+## Milestone: v1.0
+
+### Phase 1: Foundation
+
+**Goal:** Set up project structure and core utilities
+**Depends on:** None
+**Requirements:** SETUP-01, SETUP-02
+**Success Criteria:** All core modules exist and pass validation
+
+**Plans:**
+1. 01-01: Core setup
+2. 01-02: Config system
+
+### Phase 2: Features
+
+**Goal:** Implement primary feature set
+**Depends on:** Phase 1
+**Requirements:** FEAT-01, FEAT-02
+**Success Criteria:** Feature tests pass
+
+**Plans:**
+1. 02-01: Feature A
+2. 02-02: Feature B
+
+## Standing Disciplines
+
+- Review all changes before commit
+- Maintain test coverage
+
+## Phase Overview
+
+| Phase | Name | Goal | Plans | Wave | Status |
+|-------|------|------|-------|------|--------|
+| 01 | Foundation | Core setup | 2/2 | 1 | verified |
+| 02 | Features | Feature set | 0/2 | 2 | planned |
+
+## Progress
+
+| Phase | Plans Complete | Status | Completed |
+|-------|---------------|--------|-----------|
+| 1. Foundation | 2/2 | Complete | 2026-02-28 |
+| 2. Features | 0/2 | Pending | -- |

package/plugins/pbr/scripts/test/fixtures/state.md

@@ -0,0 +1,60 @@
+---
+gsd_state_version: 1.0
+version: 2
+milestone: v1.0
+milestone_name: milestone
+status: executing
+current_phase: 3
+phase_slug: 03-research-pipeline
+plans_total: 6
+plans_complete: 4
+progress_percent: 67
+stopped_at: Completed 03-01-PLAN.md
+last_updated: "2026-03-01"
+last_activity: 2026-03-01 -- Executed 03-01 research pipeline (2 tasks, 4 files)
+---
+
+# Project State
+
+## Project Reference
+
+See: .planning/PROJECT.md (updated 2026-03-01)
+
+**Core value:** Example project for fixture testing
+**Current focus:** Phase 3 - Research Pipeline
+
+## Current Position
+
+Phase: 3 of 6 (Research Pipeline)
+Plan: 4 of 6 executed (2 plans created)
+Status: Executing
+Last activity: 2026-03-01 -- Executed 03-01 research pipeline (2 tasks, 4 files)
+
+Progress: [█████████████░░░░░░░] 67%
+
+## Performance Metrics
+
+**Velocity:**
+- Total plans completed: 4
+- Average duration: 3 min
+
+## Accumulated Context
+
+### Decisions
+
+- [Roadmap]: 6-phase structure derived from requirements
+- [Phase 01]: Used built-in modules only for zero-dependency operation
+
+### Pending Todos
+
+None yet.
+
+### Blockers/Concerns
+
+None.
+
+## Session Continuity
+
+Last session: 2026-03-01T12:00:00.000Z
+Stopped at: Completed 03-01-PLAN.md
+Resume file: .planning/phases/03-research-pipeline/03-CONTEXT.md

package/plugins/pbr/scripts/test/fixtures/summary.md

@@ -0,0 +1,35 @@
+---
+phase: 01-foundation
+plan: 01
+status: complete
+duration: 4 min
+started: "2026-02-28T10:00:00Z"
+completed: "2026-02-28T10:04:00Z"
+tasks_completed: 2
+tasks_total: 2
+---
+
+# Phase 01 Plan 01: Core Setup Summary
+
+Core project initialization with setup and config modules using Node.js built-in libraries.
+
+## What Was Built
+
+- Project initialization module (src/core/setup.js)
+- Configuration loader with validation (src/core/config.js)
+
+## Features
+
+- **Setup module**: Creates .planning/ directory structure and initial files
+- **Config module**: Loads, validates, and caches config.json with mtime-based invalidation
+
+## Changes
+
+| File | Change |
+|------|--------|
+| src/core/setup.js | Created - initialization logic |
+| src/core/config.js | Created - config load/validate |
+
+## Deviations from Plan
+
+None - plan executed exactly as written.

package/plugins/pbr/scripts/test/fixtures.test.js

@@ -0,0 +1,184 @@
+/**
+ * fixtures.test.js -- Validates that test fixtures match current PBR file formats.
+ *
+ * Ensures fixture files parse correctly through the same lib modules
+ * that production code uses. Acts as a regression guard: if formats
+ * change in a future phase, these tests break.
+ */
+
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+
+const FIXTURES_DIR = path.join(__dirname, 'fixtures');
+
+// PBR lib modules used in production
+const { parseYamlFrontmatter } = require('../lib/core');
+const { parseStateMd } = require('../lib/state');
+const { parseRoadmapMd } = require('../lib/roadmap');
+
+// Dashboard frontmatter parser (shared parser from Phase 6)
+const { parseFrontmatter } = require('../../../../dashboard/server/lib/frontmatter');
+
+function readFixture(name) {
+  return fs.readFileSync(path.join(FIXTURES_DIR, name), 'utf-8');
+}
+
+describe('state.md fixture', () => {
+  it('has valid YAML frontmatter with required fields', () => {
+    const content = readFixture('state.md');
+    const fm = parseYamlFrontmatter(content);
+    assert.ok(fm.gsd_state_version, 'should have gsd_state_version');
+    assert.ok(fm.milestone, 'should have milestone');
+    assert.ok(fm.status, 'should have status');
+    assert.ok(fm.progress_percent !== undefined, 'should have progress_percent');
+  });
+
+  it('has required body sections', () => {
+    const content = readFixture('state.md');
+    assert.ok(content.includes('## Current Position'), 'should have Current Position section');
+    assert.ok(content.includes('## Accumulated Context'), 'should have Accumulated Context section');
+    assert.ok(content.includes('## Session Continuity'), 'should have Session Continuity section');
+  });
+
+  it('parses through parseStateMd without error', () => {
+    const content = readFixture('state.md');
+    const result = parseStateMd(content);
+    assert.ok(result, 'parseStateMd should return a result');
+    assert.equal(result.format, 'frontmatter', 'should be detected as frontmatter format');
+    assert.ok(result.current_phase, 'should extract current_phase');
+    assert.ok(result.status, 'should extract status');
+  });
+
+  it('parses through dashboard parseFrontmatter', () => {
+    const content = readFixture('state.md');
+    const { frontmatter, body } = parseFrontmatter(content);
+    assert.ok(frontmatter.gsd_state_version, 'dashboard parser should extract gsd_state_version');
+    assert.ok(body.length > 0, 'should have body content');
+  });
+});
+
+describe('roadmap.md fixture', () => {
+  it('has required sections', () => {
+    const content = readFixture('roadmap.md');
+    assert.ok(content.includes('## Phases') || content.includes('## Phase Overview'), 'should have Phases section');
+    assert.ok(content.includes('## Phase Details') || content.match(/### Phase \d+:/), 'should have Phase Details');
+    assert.ok(content.includes('## Progress'), 'should have Progress section');
+  });
+
+  it('has progress table with correct columns', () => {
+    const content = readFixture('roadmap.md');
+    const progressSection = content.split('## Progress')[1];
+    assert.ok(progressSection, 'should have progress section');
+    assert.ok(progressSection.includes('Phase'), 'should have Phase column');
+    assert.ok(progressSection.includes('Status'), 'should have Status column');
+  });
+
+  it('has checkbox items', () => {
+    const content = readFixture('roadmap.md');
+    assert.ok(/- \[[ x]\]/.test(content), 'should have checkbox items');
+  });
+
+  it('parses through parseRoadmapMd', () => {
+    const content = readFixture('roadmap.md');
+    const result = parseRoadmapMd(content);
+    assert.ok(result, 'parseRoadmapMd should return a result');
+    assert.ok(result.has_progress_table, 'should detect progress table');
+  });
+});
+
+describe('project.md fixture', () => {
+  it('has required sections', () => {
+    const content = readFixture('project.md');
+    assert.ok(content.includes('## What This Is'), 'should have What This Is section');
+    assert.ok(content.includes('## Core Value'), 'should have Core Value section');
+    assert.ok(content.includes('## Requirements Summary'), 'should have Requirements Summary section');
+    assert.ok(content.includes('## Context'), 'should have Context section');
+  });
+
+  it('parses through dashboard parseFrontmatter', () => {
+    const content = readFixture('project.md');
+    const { body } = parseFrontmatter(content);
+    assert.ok(body.length > 0, 'should have body content');
+  });
+});
+
+describe('config.json fixture', () => {
+  it('has required fields with valid values', () => {
+    const content = readFixture('config.json');
+    const config = JSON.parse(content);
+    assert.ok(config.mode, 'should have mode');
+    assert.ok(config.depth, 'should have depth');
+    assert.equal(typeof config.parallelization, 'object', 'should have parallelization object');
+    assert.equal(typeof config.git, 'object', 'should have git object');
+    assert.ok(['interactive', 'autonomous'].includes(config.mode), 'mode should be valid');
+    assert.ok(['quick', 'standard', 'comprehensive'].includes(config.depth), 'depth should be valid');
+  });
+
+  it('has valid git settings', () => {
+    const content = readFixture('config.json');
+    const config = JSON.parse(content);
+    assert.ok(config.git.branching, 'should have git.branching');
+    assert.equal(typeof config.git.auto_commit, 'boolean', 'git.auto_commit should be boolean');
+  });
+});
+
+describe('plan.md fixture', () => {
+  it('has YAML frontmatter with required fields', () => {
+    const content = readFixture('plan.md');
+    const fm = parseYamlFrontmatter(content);
+    assert.ok(fm.phase, 'should have phase');
+    assert.ok(fm.plan, 'should have plan');
+    assert.ok(fm.type, 'should have type');
+    assert.ok(fm.wave !== undefined, 'should have wave');
+    assert.ok(fm.autonomous !== undefined, 'should have autonomous');
+  });
+
+  it('has required body sections', () => {
+    const content = readFixture('plan.md');
+    assert.ok(content.includes('<objective>'), 'should have objective section');
+    assert.ok(content.includes('<tasks>'), 'should have tasks section');
+    assert.ok(content.includes('<verification>'), 'should have verification section');
+    assert.ok(content.includes('<success_criteria>'), 'should have success_criteria section');
+  });
+
+  it('has must_haves in frontmatter', () => {
+    const content = readFixture('plan.md');
+    const fm = parseYamlFrontmatter(content);
+    assert.ok(fm.must_haves !== undefined || fm.files_modified !== undefined,
+      'should have must_haves or files_modified');
+  });
+
+  it('parses through dashboard parseFrontmatter', () => {
+    const content = readFixture('plan.md');
+    const { frontmatter } = parseFrontmatter(content);
+    assert.ok(frontmatter.phase, 'dashboard parser should extract phase');
+    assert.ok(frontmatter.plan, 'dashboard parser should extract plan');
+  });
+});
+
+describe('summary.md fixture', () => {
+  it('has YAML frontmatter with required fields', () => {
+    const content = readFixture('summary.md');
+    const { frontmatter } = parseFrontmatter(content);
+    assert.ok(frontmatter.phase, 'should have phase');
+    assert.ok(frontmatter.plan, 'should have plan');
+    assert.ok(frontmatter.status, 'should have status');
+    assert.ok(frontmatter.duration, 'should have duration');
+    assert.ok(frontmatter.tasks_completed !== undefined, 'should have tasks_completed');
+    assert.ok(frontmatter.tasks_total !== undefined, 'should have tasks_total');
+  });
+
+  it('has body with features or changes sections', () => {
+    const content = readFixture('summary.md');
+    const { body } = parseFrontmatter(content);
+    assert.ok(body.length > 0, 'should have body content');
+    assert.ok(
+      body.includes('## Features') || body.includes('## Changes') || body.includes('## What Was Built'),
+      'should have Features, Changes, or What Was Built section'
+    );
+  });
+});