@sienklogic/plan-build-run 2.1.0 → 2.1.1

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'
+    );
+  });
+});

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

@@ -0,0 +1,142 @@
+/**
+ * Unit tests for lib/phase.js — Phase operations (frontmatter, planIndex, phaseList).
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { frontmatter, planIndex, phaseList } = require('../lib/phase');
+
+// --- Minimal PLAN.md content ---
+const PLAN_CONTENT = [
+  '---',
+  'phase: 01',
+  'plan: 01',
+  'type: execute',
+  'wave: 1',
+  'depends_on: []',
+  'autonomous: true',
+  '---',
+  '',
+  '<objective>',
+  'Test objective here.',
+  '</objective>',
+  '',
+  '<tasks>',
+  '<task type="auto">',
+  '  <name>Task 1: Do something</name>',
+  '</task>',
+  '</tasks>',
+].join('\n');
+
+const PLAN_CONTENT_CRLF = PLAN_CONTENT.replace(/\n/g, '\r\n');
+
+// --- Minimal SUMMARY.md content ---
+const SUMMARY_CONTENT = [
+  '---',
+  'phase: 01',
+  'plan: 01',
+  'status: complete',
+  '---',
+  '# Summary',
+  '',
+  'Tasks completed.',
+].join('\n');
+
+describe('frontmatter', () => {
+  it('extracts frontmatter from a PLAN.md file', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'phase-test-'));
+    const planPath = path.join(tmpDir, 'PLAN-01.md');
+    fs.writeFileSync(planPath, PLAN_CONTENT, 'utf8');
+
+    const result = frontmatter(planPath);
+    assert.strictEqual(result.phase, 1);
+    assert.strictEqual(result.plan, 1);
+    assert.strictEqual(result.type, 'execute');
+    assert.strictEqual(result.autonomous, true);
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('returns error for missing file', () => {
+    const result = frontmatter('/nonexistent/file.md');
+    assert.ok(result.error);
+    assert.ok(result.error.includes('not found'));
+  });
+
+  it('handles CRLF content in frontmatter parsing', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'phase-test-'));
+    const planPath = path.join(tmpDir, 'PLAN-01.md');
+    fs.writeFileSync(planPath, PLAN_CONTENT_CRLF, 'utf8');
+
+    const result = frontmatter(planPath);
+    assert.strictEqual(result.phase, 1);
+    assert.strictEqual(result.plan, 1);
+    assert.strictEqual(result.autonomous, true);
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+});
+
+describe('planIndex', () => {
+  it('returns plan inventory for a phase directory', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'phase-test-'));
+    const phasesDir = path.join(tmpDir, 'phases', '01-foundation');
+    fs.mkdirSync(phasesDir, { recursive: true });
+    fs.writeFileSync(path.join(phasesDir, 'PLAN-01.md'), PLAN_CONTENT, 'utf8');
+
+    const result = planIndex('1', tmpDir);
+    assert.strictEqual(result.total_plans, 1);
+    assert.strictEqual(result.plans[0].wave, 1);
+    assert.strictEqual(result.plans[0].autonomous, true);
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('returns error when phases directory is missing', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'phase-test-'));
+    const result = planIndex('1', tmpDir);
+    assert.ok(result.error);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+});
+
+describe('phaseList', () => {
+  it('lists phase directories with status', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'phase-test-'));
+    const phasesDir = path.join(tmpDir, 'phases');
+    fs.mkdirSync(path.join(phasesDir, '01-foundation'), { recursive: true });
+    fs.mkdirSync(path.join(phasesDir, '02-templates'), { recursive: true });
+    fs.writeFileSync(path.join(phasesDir, '01-foundation', 'PLAN-01.md'), PLAN_CONTENT, 'utf8');
+
+    const result = phaseList(tmpDir);
+    assert.strictEqual(result.phases.length, 2);
+    assert.strictEqual(result.phases[0].num, 1);
+    assert.strictEqual(result.phases[0].slug, 'foundation');
+    assert.strictEqual(result.phases[0].hasPlan, true);
+    assert.strictEqual(result.phases[1].hasPlan, false);
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('returns empty when no phases directory', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'phase-test-'));
+    const result = phaseList(tmpDir);
+    assert.deepStrictEqual(result.phases, []);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+});
+
+describe('phase path construction', () => {
+  it('uses path.join for cross-platform safety', () => {
+    // Verify that path.join produces valid paths on current platform
+    const joined = path.join('phases', '01-foundation', 'PLAN-01.md');
+    assert.ok(joined.includes('01-foundation'));
+    assert.ok(joined.includes('PLAN-01.md'));
+    // Should NOT contain double separators
+    assert.ok(!joined.includes('//'));
+    assert.ok(!joined.includes('\\\\'));
+  });
+});

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

@@ -0,0 +1,96 @@
+/**
+ * Unit tests for lib/roadmap.js — ROADMAP.md parsing and table operations.
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { parseRoadmapMd, findRoadmapRow, updateTableRow } = require('../lib/roadmap');
+
+// --- Minimal valid ROADMAP.md content ---
+const ROADMAP_CONTENT = [
+  '# Roadmap',
+  '',
+  '## Phase Overview',
+  '',
+  '| Phase | Name | Goal | Plans | Wave | Status |',
+  '|-------|------|------|-------|------|--------|',
+  '| 01 | Foundation | Setup base | 2/2 | 1 | Complete |',
+  '| 02 | Templates | Create templates | 1/3 | 1 | Building |',
+  '| 03 | Research | Research pipeline | 0/0 | 2 | Pending |',
+  '',
+  '## Progress',
+  '',
+  '| 1. Foundation | 2/2 | Complete |',
+  '| 2. Templates | 1/3 | Building |',
+  '| 3. Research | 0/0 | Pending |',
+].join('\n');
+
+const ROADMAP_CRLF = ROADMAP_CONTENT.replace(/\n/g, '\r\n');
+
+describe('parseRoadmapMd', () => {
+  it('extracts phase list with status from ROADMAP.md content', () => {
+    const result = parseRoadmapMd(ROADMAP_CONTENT);
+    assert.strictEqual(result.phases.length, 3);
+    assert.strictEqual(result.phases[0].number, '01');
+    assert.strictEqual(result.phases[0].name, 'Foundation');
+    assert.strictEqual(result.phases[0].goal, 'Setup base');
+    assert.strictEqual(result.phases[0].status, 'Complete');
+    assert.strictEqual(result.phases[1].status, 'Building');
+    assert.strictEqual(result.phases[2].status, 'Pending');
+  });
+
+  it('detects progress table', () => {
+    const result = parseRoadmapMd(ROADMAP_CONTENT);
+    assert.strictEqual(result.has_progress_table, true);
+  });
+
+  it('returns empty phases for content without Phase Overview', () => {
+    const result = parseRoadmapMd('# Roadmap\n\nNo phases here.');
+    assert.strictEqual(result.phases.length, 0);
+    assert.strictEqual(result.has_progress_table, false);
+  });
+
+  it('CRLF content produces same result as LF content', () => {
+    const lfResult = parseRoadmapMd(ROADMAP_CONTENT);
+    const crlfResult = parseRoadmapMd(ROADMAP_CRLF);
+    assert.strictEqual(crlfResult.phases.length, lfResult.phases.length);
+    for (let i = 0; i < lfResult.phases.length; i++) {
+      assert.strictEqual(crlfResult.phases[i].number, lfResult.phases[i].number);
+      assert.strictEqual(crlfResult.phases[i].name, lfResult.phases[i].name);
+      assert.strictEqual(crlfResult.phases[i].status, lfResult.phases[i].status);
+    }
+    assert.strictEqual(crlfResult.has_progress_table, lfResult.has_progress_table);
+  });
+});
+
+describe('findRoadmapRow', () => {
+  it('finds the correct row index for a phase number', () => {
+    const lines = ROADMAP_CONTENT.split('\n');
+    const idx = findRoadmapRow(lines, '02');
+    assert.ok(idx > 0);
+    assert.ok(lines[idx].includes('Templates'));
+  });
+
+  it('returns -1 for non-existent phase', () => {
+    const lines = ROADMAP_CONTENT.split('\n');
+    const idx = findRoadmapRow(lines, '99');
+    assert.strictEqual(idx, -1);
+  });
+});
+
+describe('updateTableRow', () => {
+  it('updates a specific column value', () => {
+    const row = '| 01 | Foundation | Setup base | 2/2 | 1 | Complete |';
+    const updated = updateTableRow(row, 5, 'Verified');
+    assert.ok(updated.includes('Verified'));
+    assert.ok(updated.includes('Foundation'));
+  });
+
+  it('preserves other columns', () => {
+    const row = '| 01 | Foundation | Setup base | 2/2 | 1 | Complete |';
+    const updated = updateTableRow(row, 3, '3/3');
+    assert.ok(updated.includes('3/3'));
+    assert.ok(updated.includes('Foundation'));
+    assert.ok(updated.includes('Complete'));
+  });
+});

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

@@ -0,0 +1,163 @@
+/**
+ * Unit tests for lib/state.js — STATE.md parsing and mutation.
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { parseStateMd, updateLegacyStateField, updateFrontmatterField, syncBodyLine, buildProgressBar } = require('../lib/state');
+
+// --- Minimal valid STATE.md content (v2 frontmatter format) ---
+const STATE_V2 = [
+  '---',
+  'version: 2',
+  'current_phase: 3',
+  'status: "building"',
+  'progress_percent: 45',
+  'last_activity: "2026-03-01"',
+  'last_command: "/pbr:execute-phase 3"',
+  'blockers: []',
+  'plans_complete: 2',
+  'plans_total: 5',
+  'phase_slug: "pre-condition-gates"',
+  '---',
+  '# Project State',
+  '',
+  '## Current Position',
+  'Phase: 3 of 8 (Pre Condition Gates)',
+  'Status: Building',
+  'Plan: 2 of 5 in current phase',
+  'Progress: [█████████░░░░░░░░░░░] 45%',
+  'Last activity: 2026-03-01',
+].join('\n');
+
+const STATE_V2_CRLF = STATE_V2.replace(/\n/g, '\r\n');
+
+// --- Minimal valid STATE.md content (v1 legacy format) ---
+const STATE_V1 = [
+  '# Project State',
+  '',
+  '## Current Position',
+  'Phase: 2 of 6 -- Foundation Setup',
+  'Status: planned',
+  'Plan: 1 of 3 in current phase',
+  'Progress: [████░░░░░░░░░░░░░░░░] 20%',
+  'Last Activity: 2026-02-15',
+].join('\n');
+
+describe('parseStateMd', () => {
+  it('returns structured object from valid v2 STATE.md content', () => {
+    const result = parseStateMd(STATE_V2);
+    assert.strictEqual(result.format, 'frontmatter');
+    assert.strictEqual(result.current_phase, 3);
+    assert.strictEqual(result.status, 'building');
+    assert.strictEqual(result.progress, 45);
+    assert.strictEqual(result.plans_complete, 2);
+    assert.strictEqual(result.plans_total, 5);
+    assert.strictEqual(result.phase_name, 'pre-condition-gates');
+  });
+
+  it('handles CRLF line endings identically to LF', () => {
+    const lfResult = parseStateMd(STATE_V2);
+    const crlfResult = parseStateMd(STATE_V2_CRLF);
+    assert.strictEqual(crlfResult.format, lfResult.format);
+    assert.strictEqual(crlfResult.current_phase, lfResult.current_phase);
+    assert.strictEqual(crlfResult.status, lfResult.status);
+    assert.strictEqual(crlfResult.progress, lfResult.progress);
+    assert.strictEqual(crlfResult.plans_complete, lfResult.plans_complete);
+  });
+
+  it('parses legacy v1 format correctly', () => {
+    // Suppress the deprecation warning to stderr
+    const origWrite = process.stderr.write;
+    process.stderr.write = () => true;
+    try {
+      const result = parseStateMd(STATE_V1);
+      assert.strictEqual(result.format, 'legacy');
+      assert.strictEqual(result.current_phase, 2);
+      assert.strictEqual(result.status, 'planned');
+      assert.strictEqual(result.progress, 20);
+    } finally {
+      process.stderr.write = origWrite;
+    }
+  });
+
+  it('returns defaults for empty content', () => {
+    const result = parseStateMd('');
+    assert.strictEqual(result.current_phase, null);
+    assert.strictEqual(result.status, null);
+    assert.strictEqual(result.format, 'legacy');
+  });
+});
+
+describe('updateFrontmatterField', () => {
+  it('updates an existing field in YAML frontmatter', () => {
+    const updated = updateFrontmatterField(STATE_V2, 'status', 'built');
+    assert.ok(updated.includes('status: "built"'));
+    assert.ok(!updated.includes('status: "building"'));
+  });
+
+  it('adds a new field if not present', () => {
+    const minimal = '---\nversion: 2\n---\n# State';
+    const updated = updateFrontmatterField(minimal, 'status', 'planned');
+    assert.ok(updated.includes('status: "planned"'));
+  });
+
+  it('formats integers without quotes', () => {
+    const updated = updateFrontmatterField(STATE_V2, 'current_phase', 5);
+    assert.ok(updated.includes('current_phase: 5'));
+  });
+});
+
+describe('syncBodyLine', () => {
+  it('updates Status line in body', () => {
+    const updated = syncBodyLine(STATE_V2, 'status', 'built');
+    assert.ok(updated.includes('Status: Built'));
+  });
+
+  it('updates Plan count in body', () => {
+    const updated = syncBodyLine(STATE_V2, 'plans_complete', 4);
+    assert.ok(updated.includes('Plan: 4 of'));
+  });
+
+  it('updates Progress bar in body', () => {
+    const updated = syncBodyLine(STATE_V2, 'progress_percent', 80);
+    assert.ok(updated.includes('80%'));
+  });
+
+  it('returns content unchanged for unknown field', () => {
+    const updated = syncBodyLine(STATE_V2, 'nonexistent_field', 'value');
+    assert.strictEqual(updated, STATE_V2);
+  });
+});
+
+describe('buildProgressBar', () => {
+  it('generates correct bar for 0%', () => {
+    const bar = buildProgressBar(0);
+    assert.strictEqual(bar, '[░░░░░░░░░░░░░░░░░░░░] 0%');
+  });
+
+  it('generates correct bar for 100%', () => {
+    const bar = buildProgressBar(100);
+    assert.strictEqual(bar, '[████████████████████] 100%');
+  });
+
+  it('generates correct bar for 50%', () => {
+    const bar = buildProgressBar(50);
+    assert.ok(bar.includes('50%'));
+    assert.ok(bar.includes('██████████'));
+  });
+});
+
+describe('updateLegacyStateField', () => {
+  it('updates status field in legacy format', () => {
+    // Suppress deprecation warning
+    const origWrite = process.stderr.write;
+    process.stderr.write = () => true;
+    try {
+      const updated = updateLegacyStateField(STATE_V1, 'status', 'building');
+      assert.ok(updated.includes('Status: building'));
+    } finally {
+      process.stderr.write = origWrite;
+    }
+  });
+});