gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/parsers.test.ts

@@ -1,14 +1,14 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 import { parseRoadmap, parsePlan } from '../parsers-legacy.ts';
 import { parseTaskPlanFile, parseSummary, parseContinue, parseRequirementCounts, parseSecretsManifest, formatSecretsManifest } from '../files.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
 // ═══════════════════════════════════════════════════════════════════════════
 // parseRoadmap tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-
-describe('parsers', () => {
-test('parseRoadmap: full roadmap', () => {
+console.log('\n=== parseRoadmap: full roadmap ===');
+{
   const content = `# M001: GSD Extension — Hierarchical Planning
 
 **Vision:** Build a structured planning system for coding agents.
@@ -57,43 +57,44 @@ Consumes from S03:
 
   const r = parseRoadmap(content);
 
-  assert.deepStrictEqual(r.title, 'M001: GSD Extension — Hierarchical Planning', 'roadmap title');
-  assert.deepStrictEqual(r.vision, 'Build a structured planning system for coding agents.', 'roadmap vision');
-  assert.deepStrictEqual(r.successCriteria.length, 3, 'success criteria count');
-  assert.deepStrictEqual(r.successCriteria[0], 'All parsers have test coverage', 'first success criterion');
-  assert.deepStrictEqual(r.successCriteria[2], 'State derivation works correctly', 'third success criterion');
+  assertEq(r.title, 'M001: GSD Extension — Hierarchical Planning', 'roadmap title');
+  assertEq(r.vision, 'Build a structured planning system for coding agents.', 'roadmap vision');
+  assertEq(r.successCriteria.length, 3, 'success criteria count');
+  assertEq(r.successCriteria[0], 'All parsers have test coverage', 'first success criterion');
+  assertEq(r.successCriteria[2], 'State derivation works correctly', 'third success criterion');
 
   // Slices
-  assert.deepStrictEqual(r.slices.length, 3, 'slice count');
-
-  assert.deepStrictEqual(r.slices[0].id, 'S01', 'S01 id');
-  assert.deepStrictEqual(r.slices[0].title, 'Types + File I/O', 'S01 title');
-  assert.deepStrictEqual(r.slices[0].risk, 'low', 'S01 risk');
-  assert.deepStrictEqual(r.slices[0].depends, [], 'S01 depends');
-  assert.deepStrictEqual(r.slices[0].done, true, 'S01 done');
-  assert.deepStrictEqual(r.slices[0].demo, 'All types defined and parsers work.', 'S01 demo');
-
-  assert.deepStrictEqual(r.slices[1].id, 'S02', 'S02 id');
-  assert.deepStrictEqual(r.slices[1].title, 'State Derivation', 'S02 title');
-  assert.deepStrictEqual(r.slices[1].risk, 'medium', 'S02 risk');
-  assert.deepStrictEqual(r.slices[1].depends, ['S01'], 'S02 depends');
-  assert.deepStrictEqual(r.slices[1].done, false, 'S02 done');
-
-  assert.deepStrictEqual(r.slices[2].id, 'S03', 'S03 id');
-  assert.deepStrictEqual(r.slices[2].risk, 'high', 'S03 risk');
-  assert.deepStrictEqual(r.slices[2].depends, ['S01', 'S02'], 'S03 depends');
-  assert.deepStrictEqual(r.slices[2].done, false, 'S03 done');
+  assertEq(r.slices.length, 3, 'slice count');
+
+  assertEq(r.slices[0].id, 'S01', 'S01 id');
+  assertEq(r.slices[0].title, 'Types + File I/O', 'S01 title');
+  assertEq(r.slices[0].risk, 'low', 'S01 risk');
+  assertEq(r.slices[0].depends, [], 'S01 depends');
+  assertEq(r.slices[0].done, true, 'S01 done');
+  assertEq(r.slices[0].demo, 'All types defined and parsers work.', 'S01 demo');
+
+  assertEq(r.slices[1].id, 'S02', 'S02 id');
+  assertEq(r.slices[1].title, 'State Derivation', 'S02 title');
+  assertEq(r.slices[1].risk, 'medium', 'S02 risk');
+  assertEq(r.slices[1].depends, ['S01'], 'S02 depends');
+  assertEq(r.slices[1].done, false, 'S02 done');
+
+  assertEq(r.slices[2].id, 'S03', 'S03 id');
+  assertEq(r.slices[2].risk, 'high', 'S03 risk');
+  assertEq(r.slices[2].depends, ['S01', 'S02'], 'S03 depends');
+  assertEq(r.slices[2].done, false, 'S03 done');
 
   // Boundary map
-  assert.deepStrictEqual(r.boundaryMap.length, 2, 'boundary map entry count');
-  assert.deepStrictEqual(r.boundaryMap[0].fromSlice, 'S01', 'bm[0] from');
-  assert.deepStrictEqual(r.boundaryMap[0].toSlice, 'S02', 'bm[0] to');
-  assert.ok(r.boundaryMap[0].produces.includes('types.ts'), 'bm[0] produces mentions types.ts');
-  assert.deepStrictEqual(r.boundaryMap[1].fromSlice, 'S02', 'bm[1] from');
-  assert.deepStrictEqual(r.boundaryMap[1].toSlice, 'S03', 'bm[1] to');
-});
-
-test('parseRoadmap: empty slices section', () => {
+  assertEq(r.boundaryMap.length, 2, 'boundary map entry count');
+  assertEq(r.boundaryMap[0].fromSlice, 'S01', 'bm[0] from');
+  assertEq(r.boundaryMap[0].toSlice, 'S02', 'bm[0] to');
+  assertTrue(r.boundaryMap[0].produces.includes('types.ts'), 'bm[0] produces mentions types.ts');
+  assertEq(r.boundaryMap[1].fromSlice, 'S02', 'bm[1] from');
+  assertEq(r.boundaryMap[1].toSlice, 'S03', 'bm[1] to');
+}
+
+console.log('\n=== parseRoadmap: empty slices section ===');
+{
   const content = `# M002: Empty Milestone
 
 **Vision:** Nothing yet.
@@ -104,12 +105,13 @@ test('parseRoadmap: empty slices section', () => {
 `;
 
   const r = parseRoadmap(content);
-  assert.deepStrictEqual(r.title, 'M002: Empty Milestone', 'title with empty slices');
-  assert.deepStrictEqual(r.slices.length, 0, 'no slices parsed');
-  assert.deepStrictEqual(r.boundaryMap.length, 0, 'no boundary map entries');
-});
+  assertEq(r.title, 'M002: Empty Milestone', 'title with empty slices');
+  assertEq(r.slices.length, 0, 'no slices parsed');
+  assertEq(r.boundaryMap.length, 0, 'no boundary map entries');
+}
 
-test('parseRoadmap: malformed checkbox lines', () => {
+console.log('\n=== parseRoadmap: malformed checkbox lines ===');
+{
   // Lines that don't match the expected bold pattern should be skipped
   const content = `# M003: Malformed
 
@@ -128,14 +130,15 @@ test('parseRoadmap: malformed checkbox lines', () => {
 
   const r = parseRoadmap(content);
   // Only S02 and S03 should be parsed (malformed lines without bold markers are skipped)
-  assert.deepStrictEqual(r.slices.length, 2, 'only valid slices parsed from malformed input');
-  assert.deepStrictEqual(r.slices[0].id, 'S02', 'first valid slice is S02');
-  assert.deepStrictEqual(r.slices[0].done, true, 'S02 done');
-  assert.deepStrictEqual(r.slices[1].id, 'S03', 'second valid slice is S03');
-  assert.deepStrictEqual(r.slices[1].depends, ['S02'], 'S03 depends on S02');
-});
-
-test('parseRoadmap: lowercase vs uppercase X for done', () => {
+  assertEq(r.slices.length, 2, 'only valid slices parsed from malformed input');
+  assertEq(r.slices[0].id, 'S02', 'first valid slice is S02');
+  assertEq(r.slices[0].done, true, 'S02 done');
+  assertEq(r.slices[1].id, 'S03', 'second valid slice is S03');
+  assertEq(r.slices[1].depends, ['S02'], 'S03 depends on S02');
+}
+
+console.log('\n=== parseRoadmap: lowercase vs uppercase X for done ===');
+{
   const content = `# M004: Case Test
 
 **Vision:** Test X case sensitivity.
@@ -153,13 +156,14 @@ test('parseRoadmap: lowercase vs uppercase X for done', () => {
 `;
 
   const r = parseRoadmap(content);
-  assert.deepStrictEqual(r.slices.length, 3, 'all three slices parsed');
-  assert.deepStrictEqual(r.slices[0].done, true, 'lowercase x is done');
-  assert.deepStrictEqual(r.slices[1].done, true, 'uppercase X is done');
-  assert.deepStrictEqual(r.slices[2].done, false, 'space is not done');
-});
-
-test('parseRoadmap: missing boundary map', () => {
+  assertEq(r.slices.length, 3, 'all three slices parsed');
+  assertEq(r.slices[0].done, true, 'lowercase x is done');
+  assertEq(r.slices[1].done, true, 'uppercase X is done');
+  assertEq(r.slices[2].done, false, 'space is not done');
+}
+
+console.log('\n=== parseRoadmap: missing boundary map ===');
+{
   const content = `# M005: No Boundary Map
 
 **Vision:** A roadmap without a boundary map section.
@@ -176,27 +180,29 @@ test('parseRoadmap: missing boundary map', () => {
 `;
 
   const r = parseRoadmap(content);
-  assert.deepStrictEqual(r.title, 'M005: No Boundary Map', 'title');
-  assert.deepStrictEqual(r.slices.length, 1, 'one slice');
-  assert.deepStrictEqual(r.boundaryMap.length, 0, 'empty boundary map when section missing');
-  assert.deepStrictEqual(r.successCriteria.length, 1, 'one success criterion');
-});
-
-test('parseRoadmap: no sections at all', () => {
+  assertEq(r.title, 'M005: No Boundary Map', 'title');
+  assertEq(r.slices.length, 1, 'one slice');
+  assertEq(r.boundaryMap.length, 0, 'empty boundary map when section missing');
+  assertEq(r.successCriteria.length, 1, 'one success criterion');
+}
+
+console.log('\n=== parseRoadmap: no sections at all ===');
+{
   const content = `# M006: Bare Minimum
 
 Just a title and nothing else.
 `;
 
   const r = parseRoadmap(content);
-  assert.deepStrictEqual(r.title, 'M006: Bare Minimum', 'title from bare roadmap');
-  assert.deepStrictEqual(r.vision, '', 'empty vision');
-  assert.deepStrictEqual(r.successCriteria.length, 0, 'no success criteria');
-  assert.deepStrictEqual(r.slices.length, 0, 'no slices');
-  assert.deepStrictEqual(r.boundaryMap.length, 0, 'no boundary map');
-});
-
-test('parseRoadmap: slice with no demo blockquote', () => {
+  assertEq(r.title, 'M006: Bare Minimum', 'title from bare roadmap');
+  assertEq(r.vision, '', 'empty vision');
+  assertEq(r.successCriteria.length, 0, 'no success criteria');
+  assertEq(r.slices.length, 0, 'no slices');
+  assertEq(r.boundaryMap.length, 0, 'no boundary map');
+}
+
+console.log('\n=== parseRoadmap: slice with no demo blockquote ===');
+{
   const content = `# M007: No Demo
 
 **Vision:** Testing slices without demo lines.
@@ -208,12 +214,13 @@ test('parseRoadmap: slice with no demo blockquote', () => {
 `;
 
   const r = parseRoadmap(content);
-  assert.deepStrictEqual(r.slices.length, 2, 'two slices without demos');
-  assert.deepStrictEqual(r.slices[0].demo, '', 'S01 demo empty');
-  assert.deepStrictEqual(r.slices[1].demo, '', 'S02 demo empty');
-});
+  assertEq(r.slices.length, 2, 'two slices without demos');
+  assertEq(r.slices[0].demo, '', 'S01 demo empty');
+  assertEq(r.slices[1].demo, '', 'S02 demo empty');
+}
 
-test('parseRoadmap: missing risk defaults to low', () => {
+console.log('\n=== parseRoadmap: missing risk defaults to low ===');
+{
   const content = `# M008: Default Risk
 
 **Vision:** Test default risk.
@@ -225,14 +232,16 @@ test('parseRoadmap: missing risk defaults to low', () => {
 `;
 
   const r = parseRoadmap(content);
-  assert.deepStrictEqual(r.slices.length, 1, 'one slice');
-  assert.deepStrictEqual(r.slices[0].risk, 'low', 'default risk is low');
-});
+  assertEq(r.slices.length, 1, 'one slice');
+  assertEq(r.slices[0].risk, 'low', 'default risk is low');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // parsePlan tests
 // ═══════════════════════════════════════════════════════════════════════════
-test('parsePlan: full plan', () => {
+
+console.log('\n=== parsePlan: full plan ===');
+{
   const content = `---
 estimated_steps: 6
 estimated_files: 3
@@ -268,41 +277,42 @@ skills_used:
 `;
 
   const taskPlan = parseTaskPlanFile(content);
-  assert.deepStrictEqual(taskPlan.frontmatter.estimated_steps, 6, 'task plan frontmatter estimated_steps');
-  assert.deepStrictEqual(taskPlan.frontmatter.estimated_files, 3, 'task plan frontmatter estimated_files');
-  assert.deepStrictEqual(taskPlan.frontmatter.skills_used.length, 2, 'task plan frontmatter skills_used count');
-  assert.deepStrictEqual(taskPlan.frontmatter.skills_used[0], 'typescript', 'first task plan skill');
-  assert.deepStrictEqual(taskPlan.frontmatter.skills_used[1], 'testing', 'second task plan skill');
+  assertEq(taskPlan.frontmatter.estimated_steps, 6, 'task plan frontmatter estimated_steps');
+  assertEq(taskPlan.frontmatter.estimated_files, 3, 'task plan frontmatter estimated_files');
+  assertEq(taskPlan.frontmatter.skills_used.length, 2, 'task plan frontmatter skills_used count');
+  assertEq(taskPlan.frontmatter.skills_used[0], 'typescript', 'first task plan skill');
+  assertEq(taskPlan.frontmatter.skills_used[1], 'testing', 'second task plan skill');
 
   const p = parsePlan(content);
 
-  assert.deepStrictEqual(p.id, 'S01', 'plan id');
-  assert.deepStrictEqual(p.title, 'Parser Test Suite', 'plan title');
-  assert.deepStrictEqual(p.goal, 'All 5 parsers have test coverage with edge cases.', 'plan goal');
-  assert.deepStrictEqual(p.demo, '`node --test tests/parsers.test.ts` passes with zero failures.', 'plan demo');
+  assertEq(p.id, 'S01', 'plan id');
+  assertEq(p.title, 'Parser Test Suite', 'plan title');
+  assertEq(p.goal, 'All 5 parsers have test coverage with edge cases.', 'plan goal');
+  assertEq(p.demo, '`node --test tests/parsers.test.ts` passes with zero failures.', 'plan demo');
 
   // Must-haves
-  assert.deepStrictEqual(p.mustHaves.length, 3, 'must-have count');
-  assert.deepStrictEqual(p.mustHaves[0], 'parseRoadmap tests cover happy path and edge cases', 'first must-have');
+  assertEq(p.mustHaves.length, 3, 'must-have count');
+  assertEq(p.mustHaves[0], 'parseRoadmap tests cover happy path and edge cases', 'first must-have');
 
   // Tasks
-  assert.deepStrictEqual(p.tasks.length, 2, 'task count');
+  assertEq(p.tasks.length, 2, 'task count');
 
-  assert.deepStrictEqual(p.tasks[0].id, 'T01', 'T01 id');
-  assert.deepStrictEqual(p.tasks[0].title, 'Test parseRoadmap and parsePlan', 'T01 title');
-  assert.deepStrictEqual(p.tasks[0].done, false, 'T01 not done');
-  assert.ok(p.tasks[0].description.includes('comprehensive tests'), 'T01 description content');
+  assertEq(p.tasks[0].id, 'T01', 'T01 id');
+  assertEq(p.tasks[0].title, 'Test parseRoadmap and parsePlan', 'T01 title');
+  assertEq(p.tasks[0].done, false, 'T01 not done');
+  assertTrue(p.tasks[0].description.includes('comprehensive tests'), 'T01 description content');
 
-  assert.deepStrictEqual(p.tasks[1].id, 'T02', 'T02 id');
-  assert.deepStrictEqual(p.tasks[1].title, 'Test parseSummary and parseContinue', 'T02 title');
-  assert.deepStrictEqual(p.tasks[1].done, true, 'T02 done');
+  assertEq(p.tasks[1].id, 'T02', 'T02 id');
+  assertEq(p.tasks[1].title, 'Test parseSummary and parseContinue', 'T02 title');
+  assertEq(p.tasks[1].done, true, 'T02 done');
 
   // Files likely touched
-  assert.deepStrictEqual(p.filesLikelyTouched.length, 3, 'files likely touched count');
-  assert.ok(p.filesLikelyTouched[0].includes('tests/parsers.test.ts'), 'first file');
-});
+  assertEq(p.filesLikelyTouched.length, 3, 'files likely touched count');
+  assertTrue(p.filesLikelyTouched[0].includes('tests/parsers.test.ts'), 'first file');
+}
 
-test('parseTaskPlanFile: defaults missing frontmatter fields', () => {
+console.log('\n=== parseTaskPlanFile: defaults missing frontmatter fields ===');
+{
   const content = `# T01: Minimal task plan
 
 ## Description
@@ -311,12 +321,13 @@ No frontmatter here.
 `;
 
   const taskPlan = parseTaskPlanFile(content);
-  assert.deepStrictEqual(taskPlan.frontmatter.estimated_steps, undefined, 'estimated_steps defaults undefined');
-  assert.deepStrictEqual(taskPlan.frontmatter.estimated_files, undefined, 'estimated_files defaults undefined');
-  assert.deepStrictEqual(taskPlan.frontmatter.skills_used.length, 0, 'skills_used defaults empty array');
-});
+  assertEq(taskPlan.frontmatter.estimated_steps, undefined, 'estimated_steps defaults undefined');
+  assertEq(taskPlan.frontmatter.estimated_files, undefined, 'estimated_files defaults undefined');
+  assertEq(taskPlan.frontmatter.skills_used.length, 0, 'skills_used defaults empty array');
+}
 
-test('parseTaskPlanFile: accepts scalar skills_used and numeric strings', () => {
+console.log('\n=== parseTaskPlanFile: accepts scalar skills_used and numeric strings ===');
+{
   const content = `---
 estimated_steps: "9"
 estimated_files: "4"
@@ -327,13 +338,14 @@ skills_used: react-best-practices
 `;
 
   const taskPlan = parseTaskPlanFile(content);
-  assert.deepStrictEqual(taskPlan.frontmatter.estimated_steps, 9, 'string estimated_steps parsed');
-  assert.deepStrictEqual(taskPlan.frontmatter.estimated_files, 4, 'string estimated_files parsed');
-  assert.deepStrictEqual(taskPlan.frontmatter.skills_used.length, 1, 'scalar skills_used normalized to array');
-  assert.deepStrictEqual(taskPlan.frontmatter.skills_used[0], 'react-best-practices', 'scalar skill preserved');
-});
-
-test('parseTaskPlanFile: filters blank skills_used items', () => {
+  assertEq(taskPlan.frontmatter.estimated_steps, 9, 'string estimated_steps parsed');
+  assertEq(taskPlan.frontmatter.estimated_files, 4, 'string estimated_files parsed');
+  assertEq(taskPlan.frontmatter.skills_used.length, 1, 'scalar skills_used normalized to array');
+  assertEq(taskPlan.frontmatter.skills_used[0], 'react-best-practices', 'scalar skill preserved');
+}
+
+console.log('\n=== parseTaskPlanFile: filters blank skills_used items ===');
+{
   const content = `---
 skills_used:
   - react
@@ -345,12 +357,13 @@ skills_used:
 `;
 
   const taskPlan = parseTaskPlanFile(content);
-  assert.deepStrictEqual(taskPlan.frontmatter.skills_used.length, 2, 'blank skill entries removed');
-  assert.deepStrictEqual(taskPlan.frontmatter.skills_used[0], 'react', 'first remaining skill');
-  assert.deepStrictEqual(taskPlan.frontmatter.skills_used[1], 'testing', 'second remaining skill');
-});
+  assertEq(taskPlan.frontmatter.skills_used.length, 2, 'blank skill entries removed');
+  assertEq(taskPlan.frontmatter.skills_used[0], 'react', 'first remaining skill');
+  assertEq(taskPlan.frontmatter.skills_used[1], 'testing', 'second remaining skill');
+}
 
-test('parseTaskPlanFile: invalid numeric frontmatter ignored', () => {
+console.log('\n=== parseTaskPlanFile: invalid numeric frontmatter ignored ===');
+{
   const content = `---
 estimated_steps: many
 estimated_files: unknown
@@ -360,11 +373,12 @@ estimated_files: unknown
 `;
 
   const taskPlan = parseTaskPlanFile(content);
-  assert.deepStrictEqual(taskPlan.frontmatter.estimated_steps, undefined, 'invalid estimated_steps ignored');
-  assert.deepStrictEqual(taskPlan.frontmatter.estimated_files, undefined, 'invalid estimated_files ignored');
-});
+  assertEq(taskPlan.frontmatter.estimated_steps, undefined, 'invalid estimated_steps ignored');
+  assertEq(taskPlan.frontmatter.estimated_files, undefined, 'invalid estimated_files ignored');
+}
 
-test('parseTaskPlanFile: parsePlan ignores task-plan frontmatter', () => {
+console.log('\n=== parseTaskPlanFile: parsePlan ignores task-plan frontmatter ===');
+{
   const content = `---
 estimated_steps: 2
 estimated_files: 1
@@ -384,11 +398,12 @@ skills_used:
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.id, 'S11', 'plan id still parsed with frontmatter');
-  assert.deepStrictEqual(p.tasks.length, 1, 'task still parsed with frontmatter');
-});
+  assertEq(p.id, 'S11', 'plan id still parsed with frontmatter');
+  assertEq(p.tasks.length, 1, 'task still parsed with frontmatter');
+}
 
-test('parsePlan: multi-line task description concatenation', () => {
+console.log('\n=== parsePlan: multi-line task description concatenation ===');
+{
   const content = `# S02: Multi-line Test
 
 **Goal:** Test multi-line descriptions.
@@ -415,15 +430,16 @@ test('parsePlan: multi-line task description concatenation', () => {
 
   const p = parsePlan(content);
 
-  assert.deepStrictEqual(p.tasks.length, 2, 'two tasks');
-  assert.ok(p.tasks[0].description.includes('First line'), 'T01 desc has first line');
-  assert.ok(p.tasks[0].description.includes('Second line'), 'T01 desc has second line');
-  assert.ok(p.tasks[0].description.includes('Third line'), 'T01 desc has third line');
-  assert.ok(p.tasks[0].description.includes('description. Second'), 'lines joined with space');
-  assert.deepStrictEqual(p.tasks[1].description, 'Just one line.', 'T02 single-line desc');
-});
+  assertEq(p.tasks.length, 2, 'two tasks');
+  assertTrue(p.tasks[0].description.includes('First line'), 'T01 desc has first line');
+  assertTrue(p.tasks[0].description.includes('Second line'), 'T01 desc has second line');
+  assertTrue(p.tasks[0].description.includes('Third line'), 'T01 desc has third line');
+  assertTrue(p.tasks[0].description.includes('description. Second'), 'lines joined with space');
+  assertEq(p.tasks[1].description, 'Just one line.', 'T02 single-line desc');
+}
 
-test('parsePlan: frontmatter does not pollute task descriptions', () => {
+console.log('\n=== parsePlan: frontmatter does not pollute task descriptions ===');
+{
   const content = `---
 estimated_steps: 2
 estimated_files: 1
@@ -441,11 +457,12 @@ skills_used:
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.tasks.length, 1, 'one task parsed with frontmatter');
-  assert.deepStrictEqual(p.tasks[0].description, 'First line of description. Second line of description.', 'frontmatter excluded from description');
-});
+  assertEq(p.tasks.length, 1, 'one task parsed with frontmatter');
+  assertEq(p.tasks[0].description, 'First line of description. Second line of description.', 'frontmatter excluded from description');
+}
 
-test('parsePlan: task with missing estimate', () => {
+console.log('\n=== parsePlan: task with missing estimate ===');
+{
   const content = `# S03: No Estimate
 
 **Goal:** Handle tasks without estimates.
@@ -461,14 +478,15 @@ test('parsePlan: task with missing estimate', () => {
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.tasks.length, 2, 'two tasks parsed');
-  assert.deepStrictEqual(p.tasks[0].id, 'T01', 'T01 id');
-  assert.deepStrictEqual(p.tasks[0].title, 'No Estimate Task', 'T01 title without estimate');
-  assert.deepStrictEqual(p.tasks[0].done, false, 'T01 not done');
-  assert.deepStrictEqual(p.tasks[1].id, 'T02', 'T02 id');
-});
-
-test('parsePlan: empty tasks section', () => {
+  assertEq(p.tasks.length, 2, 'two tasks parsed');
+  assertEq(p.tasks[0].id, 'T01', 'T01 id');
+  assertEq(p.tasks[0].title, 'No Estimate Task', 'T01 title without estimate');
+  assertEq(p.tasks[0].done, false, 'T01 not done');
+  assertEq(p.tasks[1].id, 'T02', 'T02 id');
+}
+
+console.log('\n=== parsePlan: empty tasks section ===');
+{
   const content = `# S04: Empty Tasks
 
 **Goal:** No tasks yet.
@@ -486,13 +504,14 @@ test('parsePlan: empty tasks section', () => {
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.id, 'S04', 'plan id with empty tasks');
-  assert.deepStrictEqual(p.tasks.length, 0, 'no tasks');
-  assert.deepStrictEqual(p.mustHaves.length, 1, 'one must-have');
-  assert.deepStrictEqual(p.filesLikelyTouched.length, 1, 'one file');
-});
-
-test('parsePlan: no H1', () => {
+  assertEq(p.id, 'S04', 'plan id with empty tasks');
+  assertEq(p.tasks.length, 0, 'no tasks');
+  assertEq(p.mustHaves.length, 1, 'one must-have');
+  assertEq(p.filesLikelyTouched.length, 1, 'one file');
+}
+
+console.log('\n=== parsePlan: no H1 ===');
+{
   const content = `**Goal:** A plan without a heading.
 **Demo:** Still parses.
 
@@ -503,14 +522,15 @@ test('parsePlan: no H1', () => {
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.id, '', 'empty id without H1');
-  assert.deepStrictEqual(p.title, '', 'empty title without H1');
-  assert.deepStrictEqual(p.goal, 'A plan without a heading.', 'goal still parsed');
-  assert.deepStrictEqual(p.tasks.length, 1, 'task still parsed');
-  assert.deepStrictEqual(p.tasks[0].id, 'T01', 'task id');
-});
-
-test('parsePlan: task estimate backtick in description', () => {
+  assertEq(p.id, '', 'empty id without H1');
+  assertEq(p.title, '', 'empty title without H1');
+  assertEq(p.goal, 'A plan without a heading.', 'goal still parsed');
+  assertEq(p.tasks.length, 1, 'task still parsed');
+  assertEq(p.tasks[0].id, 'T01', 'task id');
+}
+
+console.log('\n=== parsePlan: task estimate backtick in description ===');
+{
   const content = `# S05: Estimate Handling
 
 **Goal:** Test estimate text handling.
@@ -523,13 +543,14 @@ test('parsePlan: task estimate backtick in description', () => {
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.tasks.length, 1, 'one task');
-  assert.deepStrictEqual(p.tasks[0].id, 'T01', 'task id');
-  assert.deepStrictEqual(p.tasks[0].title, 'With Estimate', 'title excludes estimate');
-  assert.ok(p.tasks[0].description.includes('Main description'), 'description from continuation line');
-});
-
-test('parsePlan: uppercase X for done', () => {
+  assertEq(p.tasks.length, 1, 'one task');
+  assertEq(p.tasks[0].id, 'T01', 'task id');
+  assertEq(p.tasks[0].title, 'With Estimate', 'title excludes estimate');
+  assertTrue(p.tasks[0].description.includes('Main description'), 'description from continuation line');
+}
+
+console.log('\n=== parsePlan: uppercase X for done ===');
+{
   const content = `# S06: Case Test
 
 **Goal:** Test case.
@@ -545,11 +566,12 @@ test('parsePlan: uppercase X for done', () => {
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.tasks[0].done, true, 'uppercase X is done');
-  assert.deepStrictEqual(p.tasks[1].done, true, 'lowercase x is done');
-});
+  assertEq(p.tasks[0].done, true, 'uppercase X is done');
+  assertEq(p.tasks[1].done, true, 'lowercase x is done');
+}
 
-test('parsePlan: no Must-Haves section', () => {
+console.log('\n=== parsePlan: no Must-Haves section ===');
+{
   const content = `# S07: No Must-Haves
 
 **Goal:** Test missing must-haves.
@@ -562,11 +584,12 @@ test('parsePlan: no Must-Haves section', () => {
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.mustHaves.length, 0, 'empty must-haves');
-  assert.deepStrictEqual(p.tasks.length, 1, 'task still parsed');
-});
+  assertEq(p.mustHaves.length, 0, 'empty must-haves');
+  assertEq(p.tasks.length, 1, 'task still parsed');
+}
 
-test('parsePlan: no Files Likely Touched section', () => {
+console.log('\n=== parsePlan: no Files Likely Touched section ===');
+{
   const content = `# S08: No Files
 
 **Goal:** Test missing files section.
@@ -579,10 +602,11 @@ test('parsePlan: no Files Likely Touched section', () => {
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.filesLikelyTouched.length, 0, 'empty files likely touched');
-});
+  assertEq(p.filesLikelyTouched.length, 0, 'empty files likely touched');
+}
 
-test('parsePlan: old-format task entries (no sublines)', () => {
+console.log('\n=== parsePlan: old-format task entries (no sublines) ===');
+{
   const content = `# S09: Old Format
 
 **Goal:** Test old-format compatibility.
@@ -595,15 +619,16 @@ test('parsePlan: old-format task entries (no sublines)', () => {
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.tasks.length, 1, 'one task parsed');
-  assert.deepStrictEqual(p.tasks[0].id, 'T01', 'task id');
-  assert.deepStrictEqual(p.tasks[0].title, 'Classic Task', 'task title');
-  assert.deepStrictEqual(p.tasks[0].done, false, 'task not done');
-  assert.deepStrictEqual(p.tasks[0].files, undefined, 'files is undefined for old-format entry');
-  assert.deepStrictEqual(p.tasks[0].verify, undefined, 'verify is undefined for old-format entry');
-});
-
-test('parsePlan: new-format task entries with Files and Verify sublines', () => {
+  assertEq(p.tasks.length, 1, 'one task parsed');
+  assertEq(p.tasks[0].id, 'T01', 'task id');
+  assertEq(p.tasks[0].title, 'Classic Task', 'task title');
+  assertEq(p.tasks[0].done, false, 'task not done');
+  assertEq(p.tasks[0].files, undefined, 'files is undefined for old-format entry');
+  assertEq(p.tasks[0].verify, undefined, 'verify is undefined for old-format entry');
+}
+
+console.log('\n=== parsePlan: new-format task entries with Files and Verify sublines ===');
+{
   const content = `# S10: New Format
 
 **Goal:** Test new-format subline extraction.
@@ -618,17 +643,18 @@ test('parsePlan: new-format task entries with Files and Verify sublines', () =>
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.tasks.length, 1, 'one task parsed');
-  assert.deepStrictEqual(p.tasks[0].id, 'T01', 'task id');
-  assert.ok(Array.isArray(p.tasks[0].files), 'files is an array');
-  assert.deepStrictEqual(p.tasks[0].files!.length, 2, 'files array has two entries');
-  assert.deepStrictEqual(p.tasks[0].files![0], 'types.ts', 'first file is types.ts');
-  assert.deepStrictEqual(p.tasks[0].files![1], 'files.ts', 'second file is files.ts');
-  assert.deepStrictEqual(p.tasks[0].verify, 'run the test suite', 'verify string extracted correctly');
-  assert.ok(p.tasks[0].description.includes('Why: because we need typed plan entries'), 'Why line accumulates into description');
-});
-
-test('parsePlan: heading-style task entries (### T01 -- Title)', () => {
+  assertEq(p.tasks.length, 1, 'one task parsed');
+  assertEq(p.tasks[0].id, 'T01', 'task id');
+  assertTrue(Array.isArray(p.tasks[0].files), 'files is an array');
+  assertEq(p.tasks[0].files!.length, 2, 'files array has two entries');
+  assertEq(p.tasks[0].files![0], 'types.ts', 'first file is types.ts');
+  assertEq(p.tasks[0].files![1], 'files.ts', 'second file is files.ts');
+  assertEq(p.tasks[0].verify, 'run the test suite', 'verify string extracted correctly');
+  assertTrue(p.tasks[0].description.includes('Why: because we need typed plan entries'), 'Why line accumulates into description');
+}
+
+console.log('\n=== parsePlan: heading-style task entries (### T01 -- Title) ===');
+{
   const content = `# S11: Heading Style
 
 **Goal:** Test heading-style task parsing.
@@ -648,19 +674,20 @@ Some description for the second task.
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.tasks.length, 2, 'heading-style task count');
-  assert.deepStrictEqual(p.tasks[0].id, 'T01', 'heading T01 id');
-  assert.deepStrictEqual(p.tasks[0].title, 'Implement feature', 'heading T01 title');
-  assert.deepStrictEqual(p.tasks[0].done, false, 'heading T01 not done (headings have no checkbox)');
-  assert.deepStrictEqual(p.tasks[0].files![0], 'src/feature.ts', 'heading T01 files extracted');
-  assert.deepStrictEqual(p.tasks[0].verify, 'npm test', 'heading T01 verify extracted');
-  assert.deepStrictEqual(p.tasks[1].id, 'T02', 'heading T02 id');
-  assert.deepStrictEqual(p.tasks[1].title, 'Write tests', 'heading T02 title');
-  assert.deepStrictEqual(p.tasks[1].estimate, '1h', 'heading T02 estimate');
-  assert.ok(p.tasks[1].description.includes('Some description'), 'heading T02 description');
-});
-
-test('parsePlan: heading-style with colon separator (### T01: Title)', () => {
+  assertEq(p.tasks.length, 2, 'heading-style task count');
+  assertEq(p.tasks[0].id, 'T01', 'heading T01 id');
+  assertEq(p.tasks[0].title, 'Implement feature', 'heading T01 title');
+  assertEq(p.tasks[0].done, false, 'heading T01 not done (headings have no checkbox)');
+  assertEq(p.tasks[0].files![0], 'src/feature.ts', 'heading T01 files extracted');
+  assertEq(p.tasks[0].verify, 'npm test', 'heading T01 verify extracted');
+  assertEq(p.tasks[1].id, 'T02', 'heading T02 id');
+  assertEq(p.tasks[1].title, 'Write tests', 'heading T02 title');
+  assertEq(p.tasks[1].estimate, '1h', 'heading T02 estimate');
+  assertTrue(p.tasks[1].description.includes('Some description'), 'heading T02 description');
+}
+
+console.log('\n=== parsePlan: heading-style with colon separator (### T01: Title) ===');
+{
   const content = `# S12: Heading Colon Style
 
 **Goal:** Test colon-separated heading tasks.
@@ -676,15 +703,16 @@ test('parsePlan: heading-style with colon separator (### T01: Title)', () => {
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.tasks.length, 2, 'colon heading task count');
-  assert.deepStrictEqual(p.tasks[0].id, 'T01', 'colon heading T01 id');
-  assert.deepStrictEqual(p.tasks[0].title, 'Setup project', 'colon heading T01 title');
-  assert.deepStrictEqual(p.tasks[1].id, 'T02', 'colon heading T02 id');
-  assert.deepStrictEqual(p.tasks[1].title, 'Add CI pipeline', 'colon heading T02 title');
-  assert.deepStrictEqual(p.tasks[1].estimate, '30m', 'colon heading T02 estimate');
-});
-
-test('parsePlan: heading-style with em-dash separator (### T01 — Title)', () => {
+  assertEq(p.tasks.length, 2, 'colon heading task count');
+  assertEq(p.tasks[0].id, 'T01', 'colon heading T01 id');
+  assertEq(p.tasks[0].title, 'Setup project', 'colon heading T01 title');
+  assertEq(p.tasks[1].id, 'T02', 'colon heading T02 id');
+  assertEq(p.tasks[1].title, 'Add CI pipeline', 'colon heading T02 title');
+  assertEq(p.tasks[1].estimate, '30m', 'colon heading T02 estimate');
+}
+
+console.log('\n=== parsePlan: heading-style with em-dash separator (### T01 — Title) ===');
+{
   const content = `# S13: Em-Dash Style
 
 **Goal:** Test em-dash separated heading tasks.
@@ -698,12 +726,13 @@ Widget description.
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.tasks.length, 1, 'em-dash heading task count');
-  assert.deepStrictEqual(p.tasks[0].id, 'T01', 'em-dash heading T01 id');
-  assert.deepStrictEqual(p.tasks[0].title, 'Build the widget', 'em-dash heading T01 title');
-});
+  assertEq(p.tasks.length, 1, 'em-dash heading task count');
+  assertEq(p.tasks[0].id, 'T01', 'em-dash heading T01 id');
+  assertEq(p.tasks[0].title, 'Build the widget', 'em-dash heading T01 title');
+}
 
-test('parsePlan: mixed checkbox and heading-style tasks', () => {
+console.log('\n=== parsePlan: mixed checkbox and heading-style tasks ===');
+{
   const content = `# S14: Mixed Format
 
 **Goal:** Test mixed formats.
@@ -723,21 +752,23 @@ A heading-style task.
 `;
 
   const p = parsePlan(content);
-  assert.deepStrictEqual(p.tasks.length, 3, 'mixed format task count');
-  assert.deepStrictEqual(p.tasks[0].id, 'T01', 'mixed T01 id');
-  assert.deepStrictEqual(p.tasks[0].done, false, 'mixed T01 not done');
-  assert.deepStrictEqual(p.tasks[1].id, 'T02', 'mixed T02 id');
-  assert.deepStrictEqual(p.tasks[1].title, 'Heading task', 'mixed T02 title');
-  assert.deepStrictEqual(p.tasks[1].estimate, '15m', 'mixed T02 estimate');
-  assert.deepStrictEqual(p.tasks[1].done, false, 'mixed T02 not done (heading style)');
-  assert.deepStrictEqual(p.tasks[2].id, 'T03', 'mixed T03 id');
-  assert.deepStrictEqual(p.tasks[2].done, true, 'mixed T03 done');
-});
+  assertEq(p.tasks.length, 3, 'mixed format task count');
+  assertEq(p.tasks[0].id, 'T01', 'mixed T01 id');
+  assertEq(p.tasks[0].done, false, 'mixed T01 not done');
+  assertEq(p.tasks[1].id, 'T02', 'mixed T02 id');
+  assertEq(p.tasks[1].title, 'Heading task', 'mixed T02 title');
+  assertEq(p.tasks[1].estimate, '15m', 'mixed T02 estimate');
+  assertEq(p.tasks[1].done, false, 'mixed T02 not done (heading style)');
+  assertEq(p.tasks[2].id, 'T03', 'mixed T03 id');
+  assertEq(p.tasks[2].done, true, 'mixed T03 done');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // parseSummary tests
 // ═══════════════════════════════════════════════════════════════════════════
-test('parseSummary: full summary with all frontmatter fields', () => {
+
+console.log('\n=== parseSummary: full summary with all frontmatter fields ===');
+{
   const content = `---
 id: T01
 parent: S01
@@ -792,51 +823,52 @@ None.
   const s = parseSummary(content);
 
   // Frontmatter fields
-  assert.deepStrictEqual(s.frontmatter.id, 'T01', 'summary id');
-  assert.deepStrictEqual(s.frontmatter.parent, 'S01', 'summary parent');
-  assert.deepStrictEqual(s.frontmatter.milestone, 'M001', 'summary milestone');
-  assert.deepStrictEqual(s.frontmatter.provides.length, 2, 'provides count');
-  assert.deepStrictEqual(s.frontmatter.provides[0], 'parseRoadmap test coverage', 'first provides');
-  assert.deepStrictEqual(s.frontmatter.provides[1], 'parsePlan test coverage', 'second provides');
+  assertEq(s.frontmatter.id, 'T01', 'summary id');
+  assertEq(s.frontmatter.parent, 'S01', 'summary parent');
+  assertEq(s.frontmatter.milestone, 'M001', 'summary milestone');
+  assertEq(s.frontmatter.provides.length, 2, 'provides count');
+  assertEq(s.frontmatter.provides[0], 'parseRoadmap test coverage', 'first provides');
+  assertEq(s.frontmatter.provides[1], 'parsePlan test coverage', 'second provides');
 
   // requires (nested objects)
-  assert.deepStrictEqual(s.frontmatter.requires.length, 2, 'requires count');
-  assert.deepStrictEqual(s.frontmatter.requires[0].slice, 'S00', 'first requires slice');
-  assert.deepStrictEqual(s.frontmatter.requires[0].provides, 'type definitions', 'first requires provides');
-  assert.deepStrictEqual(s.frontmatter.requires[1].slice, 'S02', 'second requires slice');
-  assert.deepStrictEqual(s.frontmatter.requires[1].provides, 'state derivation', 'second requires provides');
-
-  assert.deepStrictEqual(s.frontmatter.affects.length, 1, 'affects count');
-  assert.deepStrictEqual(s.frontmatter.affects[0], 'auto-mode dispatch', 'affects value');
-  assert.deepStrictEqual(s.frontmatter.key_files.length, 2, 'key_files count');
-  assert.deepStrictEqual(s.frontmatter.key_decisions.length, 1, 'key_decisions count');
-  assert.deepStrictEqual(s.frontmatter.patterns_established.length, 1, 'patterns_established count');
-  assert.deepStrictEqual(s.frontmatter.drill_down_paths.length, 1, 'drill_down_paths count');
+  assertEq(s.frontmatter.requires.length, 2, 'requires count');
+  assertEq(s.frontmatter.requires[0].slice, 'S00', 'first requires slice');
+  assertEq(s.frontmatter.requires[0].provides, 'type definitions', 'first requires provides');
+  assertEq(s.frontmatter.requires[1].slice, 'S02', 'second requires slice');
+  assertEq(s.frontmatter.requires[1].provides, 'state derivation', 'second requires provides');
+
+  assertEq(s.frontmatter.affects.length, 1, 'affects count');
+  assertEq(s.frontmatter.affects[0], 'auto-mode dispatch', 'affects value');
+  assertEq(s.frontmatter.key_files.length, 2, 'key_files count');
+  assertEq(s.frontmatter.key_decisions.length, 1, 'key_decisions count');
+  assertEq(s.frontmatter.patterns_established.length, 1, 'patterns_established count');
+  assertEq(s.frontmatter.drill_down_paths.length, 1, 'drill_down_paths count');
 
   // observability_surfaces extraction
-  assert.deepStrictEqual(s.frontmatter.observability_surfaces.length, 2, 'observability_surfaces count');
-  assert.deepStrictEqual(s.frontmatter.observability_surfaces[0], 'test pass/fail output from node --test', 'first observability surface');
-  assert.deepStrictEqual(s.frontmatter.observability_surfaces[1], 'exit code 1 on failure', 'second observability surface');
+  assertEq(s.frontmatter.observability_surfaces.length, 2, 'observability_surfaces count');
+  assertEq(s.frontmatter.observability_surfaces[0], 'test pass/fail output from node --test', 'first observability surface');
+  assertEq(s.frontmatter.observability_surfaces[1], 'exit code 1 on failure', 'second observability surface');
 
-  assert.deepStrictEqual(s.frontmatter.duration, '23min', 'duration');
-  assert.deepStrictEqual(s.frontmatter.verification_result, 'pass', 'verification_result');
-  assert.deepStrictEqual(s.frontmatter.completed_at, '2025-03-10T08:00:00Z', 'completed_at');
+  assertEq(s.frontmatter.duration, '23min', 'duration');
+  assertEq(s.frontmatter.verification_result, 'pass', 'verification_result');
+  assertEq(s.frontmatter.completed_at, '2025-03-10T08:00:00Z', 'completed_at');
 
   // Body fields
-  assert.deepStrictEqual(s.title, 'T01: Test parseRoadmap and parsePlan', 'summary title');
-  assert.deepStrictEqual(s.oneLiner, 'Created parsers.test.ts with 98 assertions across 16 test groups.', 'one-liner');
-  assert.ok(s.whatHappened.includes('comprehensive tests'), 'whatHappened content');
-  assert.deepStrictEqual(s.deviations, 'None.', 'deviations');
+  assertEq(s.title, 'T01: Test parseRoadmap and parsePlan', 'summary title');
+  assertEq(s.oneLiner, 'Created parsers.test.ts with 98 assertions across 16 test groups.', 'one-liner');
+  assertTrue(s.whatHappened.includes('comprehensive tests'), 'whatHappened content');
+  assertEq(s.deviations, 'None.', 'deviations');
 
   // Files modified
-  assert.deepStrictEqual(s.filesModified.length, 3, 'filesModified count');
-  assert.deepStrictEqual(s.filesModified[0].path, 'tests/parsers.test.ts', 'first file path');
-  assert.ok(s.filesModified[0].description.includes('98 assertions'), 'first file description');
-  assert.deepStrictEqual(s.filesModified[1].path, 'types.ts', 'second file path');
-  assert.deepStrictEqual(s.filesModified[2].path, 'files.ts', 'third file path');
-});
-
-test('parseSummary: one-liner extraction (bold-wrapped line after H1)', () => {
+  assertEq(s.filesModified.length, 3, 'filesModified count');
+  assertEq(s.filesModified[0].path, 'tests/parsers.test.ts', 'first file path');
+  assertTrue(s.filesModified[0].description.includes('98 assertions'), 'first file description');
+  assertEq(s.filesModified[1].path, 'types.ts', 'second file path');
+  assertEq(s.filesModified[2].path, 'files.ts', 'third file path');
+}
+
+console.log('\n=== parseSummary: one-liner extraction (bold-wrapped line after H1) ===');
+{
   const content = `# S01: Parser Test Suite
 
 **All 5 parsers have test coverage with edge cases.**
@@ -847,11 +879,12 @@ Things happened.
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.title, 'S01: Parser Test Suite', 'title');
-  assert.deepStrictEqual(s.oneLiner, 'All 5 parsers have test coverage with edge cases.', 'bold one-liner');
-});
+  assertEq(s.title, 'S01: Parser Test Suite', 'title');
+  assertEq(s.oneLiner, 'All 5 parsers have test coverage with edge cases.', 'bold one-liner');
+}
 
-test('parseSummary: non-bold paragraph after H1 (empty one-liner)', () => {
+console.log('\n=== parseSummary: non-bold paragraph after H1 (empty one-liner) ===');
+{
   const content = `# T02: Some Task
 
 This is just a regular paragraph, not bold.
@@ -862,11 +895,12 @@ Did stuff.
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.title, 'T02: Some Task', 'title');
-  assert.deepStrictEqual(s.oneLiner, '', 'non-bold line results in empty one-liner');
-});
+  assertEq(s.title, 'T02: Some Task', 'title');
+  assertEq(s.oneLiner, '', 'non-bold line results in empty one-liner');
+}
 
-test('parseSummary: files-modified parsing (backtick path — description format)', () => {
+console.log('\n=== parseSummary: files-modified parsing (backtick path — description format) ===');
+{
   const content = `# T03: File Changes
 
 **One-liner.**
@@ -879,14 +913,15 @@ test('parseSummary: files-modified parsing (backtick path — description format
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.filesModified.length, 3, 'three files');
-  assert.deepStrictEqual(s.filesModified[0].path, 'src/index.ts', 'first path');
-  assert.deepStrictEqual(s.filesModified[0].description, 'main entry point', 'first description');
-  assert.deepStrictEqual(s.filesModified[1].path, 'src/utils.ts', 'second path');
-  assert.deepStrictEqual(s.filesModified[2].path, 'README.md', 'third path');
-});
-
-test('parseSummary: missing frontmatter (safe defaults)', () => {
+  assertEq(s.filesModified.length, 3, 'three files');
+  assertEq(s.filesModified[0].path, 'src/index.ts', 'first path');
+  assertEq(s.filesModified[0].description, 'main entry point', 'first description');
+  assertEq(s.filesModified[1].path, 'src/utils.ts', 'second path');
+  assertEq(s.filesModified[2].path, 'README.md', 'third path');
+}
+
+console.log('\n=== parseSummary: missing frontmatter (safe defaults) ===');
+{
   const content = `# T04: No Frontmatter
 
 **Did something.**
@@ -897,25 +932,26 @@ No frontmatter at all.
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.frontmatter.id, '', 'default id empty');
-  assert.deepStrictEqual(s.frontmatter.parent, '', 'default parent empty');
-  assert.deepStrictEqual(s.frontmatter.milestone, '', 'default milestone empty');
-  assert.deepStrictEqual(s.frontmatter.provides.length, 0, 'default provides empty');
-  assert.deepStrictEqual(s.frontmatter.requires.length, 0, 'default requires empty');
-  assert.deepStrictEqual(s.frontmatter.affects.length, 0, 'default affects empty');
-  assert.deepStrictEqual(s.frontmatter.key_files.length, 0, 'default key_files empty');
-  assert.deepStrictEqual(s.frontmatter.key_decisions.length, 0, 'default key_decisions empty');
-  assert.deepStrictEqual(s.frontmatter.patterns_established.length, 0, 'default patterns_established empty');
-  assert.deepStrictEqual(s.frontmatter.drill_down_paths.length, 0, 'default drill_down_paths empty');
-  assert.deepStrictEqual(s.frontmatter.observability_surfaces.length, 0, 'default observability_surfaces empty');
-  assert.deepStrictEqual(s.frontmatter.duration, '', 'default duration empty');
-  assert.deepStrictEqual(s.frontmatter.verification_result, 'untested', 'default verification_result');
-  assert.deepStrictEqual(s.frontmatter.completed_at, '', 'default completed_at empty');
-  assert.deepStrictEqual(s.title, 'T04: No Frontmatter', 'title still parsed');
-  assert.deepStrictEqual(s.oneLiner, 'Did something.', 'one-liner still parsed');
-});
-
-test('parseSummary: empty body', () => {
+  assertEq(s.frontmatter.id, '', 'default id empty');
+  assertEq(s.frontmatter.parent, '', 'default parent empty');
+  assertEq(s.frontmatter.milestone, '', 'default milestone empty');
+  assertEq(s.frontmatter.provides.length, 0, 'default provides empty');
+  assertEq(s.frontmatter.requires.length, 0, 'default requires empty');
+  assertEq(s.frontmatter.affects.length, 0, 'default affects empty');
+  assertEq(s.frontmatter.key_files.length, 0, 'default key_files empty');
+  assertEq(s.frontmatter.key_decisions.length, 0, 'default key_decisions empty');
+  assertEq(s.frontmatter.patterns_established.length, 0, 'default patterns_established empty');
+  assertEq(s.frontmatter.drill_down_paths.length, 0, 'default drill_down_paths empty');
+  assertEq(s.frontmatter.observability_surfaces.length, 0, 'default observability_surfaces empty');
+  assertEq(s.frontmatter.duration, '', 'default duration empty');
+  assertEq(s.frontmatter.verification_result, 'untested', 'default verification_result');
+  assertEq(s.frontmatter.completed_at, '', 'default completed_at empty');
+  assertEq(s.title, 'T04: No Frontmatter', 'title still parsed');
+  assertEq(s.oneLiner, 'Did something.', 'one-liner still parsed');
+}
+
+console.log('\n=== parseSummary: empty body ===');
+{
   const content = `---
 id: T05
 parent: S01
@@ -924,15 +960,16 @@ milestone: M001
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.frontmatter.id, 'T05', 'id from frontmatter');
-  assert.deepStrictEqual(s.title, '', 'empty title');
-  assert.deepStrictEqual(s.oneLiner, '', 'empty one-liner');
-  assert.deepStrictEqual(s.whatHappened, '', 'empty whatHappened');
-  assert.deepStrictEqual(s.deviations, '', 'empty deviations');
-  assert.deepStrictEqual(s.filesModified.length, 0, 'no files modified');
-});
-
-test('parseSummary: summary with requires array (nested objects)', () => {
+  assertEq(s.frontmatter.id, 'T05', 'id from frontmatter');
+  assertEq(s.title, '', 'empty title');
+  assertEq(s.oneLiner, '', 'empty one-liner');
+  assertEq(s.whatHappened, '', 'empty whatHappened');
+  assertEq(s.deviations, '', 'empty deviations');
+  assertEq(s.filesModified.length, 0, 'no files modified');
+}
+
+console.log('\n=== parseSummary: summary with requires array (nested objects) ===');
+{
   const content = `---
 id: T06
 parent: S02
@@ -967,18 +1004,20 @@ Tested.
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.frontmatter.requires.length, 3, 'three requires entries');
-  assert.deepStrictEqual(s.frontmatter.requires[0].slice, 'S01', 'first requires slice');
-  assert.deepStrictEqual(s.frontmatter.requires[0].provides, 'parser functions', 'first requires provides');
-  assert.deepStrictEqual(s.frontmatter.requires[1].slice, 'S00', 'second requires slice');
-  assert.deepStrictEqual(s.frontmatter.requires[2].slice, 'S03', 'third requires slice');
-  assert.deepStrictEqual(s.frontmatter.requires[2].provides, 'state engine', 'third requires provides');
-});
+  assertEq(s.frontmatter.requires.length, 3, 'three requires entries');
+  assertEq(s.frontmatter.requires[0].slice, 'S01', 'first requires slice');
+  assertEq(s.frontmatter.requires[0].provides, 'parser functions', 'first requires provides');
+  assertEq(s.frontmatter.requires[1].slice, 'S00', 'second requires slice');
+  assertEq(s.frontmatter.requires[2].slice, 'S03', 'third requires slice');
+  assertEq(s.frontmatter.requires[2].provides, 'state engine', 'third requires provides');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // parseContinue tests
 // ═══════════════════════════════════════════════════════════════════════════
-test('parseContinue: full continue file with all frontmatter fields', () => {
+
+console.log('\n=== parseContinue: full continue file with all frontmatter fields ===');
+{
   const content = `---
 milestone: M001
 slice: S01
@@ -1013,23 +1052,24 @@ Run the full test suite with node --test.
   const c = parseContinue(content);
 
   // Frontmatter
-  assert.deepStrictEqual(c.frontmatter.milestone, 'M001', 'continue milestone');
-  assert.deepStrictEqual(c.frontmatter.slice, 'S01', 'continue slice');
-  assert.deepStrictEqual(c.frontmatter.task, 'T02', 'continue task');
-  assert.deepStrictEqual(c.frontmatter.step, 3, 'continue step');
-  assert.deepStrictEqual(c.frontmatter.totalSteps, 5, 'continue totalSteps');
-  assert.deepStrictEqual(c.frontmatter.status, 'in_progress', 'continue status');
-  assert.deepStrictEqual(c.frontmatter.savedAt, '2025-03-10T08:30:00Z', 'continue savedAt');
+  assertEq(c.frontmatter.milestone, 'M001', 'continue milestone');
+  assertEq(c.frontmatter.slice, 'S01', 'continue slice');
+  assertEq(c.frontmatter.task, 'T02', 'continue task');
+  assertEq(c.frontmatter.step, 3, 'continue step');
+  assertEq(c.frontmatter.totalSteps, 5, 'continue totalSteps');
+  assertEq(c.frontmatter.status, 'in_progress', 'continue status');
+  assertEq(c.frontmatter.savedAt, '2025-03-10T08:30:00Z', 'continue savedAt');
 
   // Body sections
-  assert.ok(c.completedWork.includes('Steps 1-3 are done'), 'completedWork content');
-  assert.ok(c.remainingWork.includes('Steps 4-5'), 'remainingWork content');
-  assert.ok(c.decisions.includes('manual assert pattern'), 'decisions content');
-  assert.ok(c.context.includes('gsd-s01 worktree'), 'context content');
-  assert.ok(c.nextAction.includes('node --test'), 'nextAction content');
-});
-
-test('parseContinue: string step/totalSteps parsed as integers', () => {
+  assertTrue(c.completedWork.includes('Steps 1-3 are done'), 'completedWork content');
+  assertTrue(c.remainingWork.includes('Steps 4-5'), 'remainingWork content');
+  assertTrue(c.decisions.includes('manual assert pattern'), 'decisions content');
+  assertTrue(c.context.includes('gsd-s01 worktree'), 'context content');
+  assertTrue(c.nextAction.includes('node --test'), 'nextAction content');
+}
+
+console.log('\n=== parseContinue: string step/totalSteps parsed as integers ===');
+{
   const content = `---
 milestone: M002
 slice: S03
@@ -1062,13 +1102,14 @@ Continue.
 `;
 
   const c = parseContinue(content);
-  assert.deepStrictEqual(c.frontmatter.step, 7, 'step parsed as integer 7');
-  assert.deepStrictEqual(c.frontmatter.totalSteps, 12, 'totalSteps parsed as integer 12');
-  assert.deepStrictEqual(typeof c.frontmatter.step, 'number', 'step is number type');
-  assert.deepStrictEqual(typeof c.frontmatter.totalSteps, 'number', 'totalSteps is number type');
-});
-
-test('parseContinue: NaN step values (non-numeric strings)', () => {
+  assertEq(c.frontmatter.step, 7, 'step parsed as integer 7');
+  assertEq(c.frontmatter.totalSteps, 12, 'totalSteps parsed as integer 12');
+  assertEq(typeof c.frontmatter.step, 'number', 'step is number type');
+  assertEq(typeof c.frontmatter.totalSteps, 'number', 'totalSteps is number type');
+}
+
+console.log('\n=== parseContinue: NaN step values (non-numeric strings) ===');
+{
   const content = `---
 milestone: M001
 slice: S01
@@ -1110,11 +1151,12 @@ Do things.
   const totalIsNaN = Number.isNaN(c.frontmatter.totalSteps);
   // The parser does parseInt which returns NaN for non-numeric strings
   // There's no || 0 fallback on the parseInt path, so NaN is expected
-  assert.ok(stepIsNaN, 'NaN step when non-numeric string');
-  assert.ok(totalIsNaN, 'NaN totalSteps when non-numeric string');
-});
+  assertTrue(stepIsNaN, 'NaN step when non-numeric string');
+  assertTrue(totalIsNaN, 'NaN totalSteps when non-numeric string');
+}
 
-test('parseContinue: all three status variants', () => {
+console.log('\n=== parseContinue: all three status variants ===');
+{
   for (const status of ['in_progress', 'interrupted', 'compacted'] as const) {
     const content = `---
 milestone: M001
@@ -1132,11 +1174,12 @@ Work.
 `;
 
     const c = parseContinue(content);
-    assert.deepStrictEqual(c.frontmatter.status, status, `status variant: ${status}`);
+    assertEq(c.frontmatter.status, status, `status variant: ${status}`);
   }
-});
+}
 
-test('parseContinue: missing frontmatter', () => {
+console.log('\n=== parseContinue: missing frontmatter ===');
+{
   const content = `## Completed Work
 
 Some work done.
@@ -1159,23 +1202,24 @@ Next thing.
 `;
 
   const c = parseContinue(content);
-  assert.deepStrictEqual(c.frontmatter.milestone, '', 'default milestone empty');
-  assert.deepStrictEqual(c.frontmatter.slice, '', 'default slice empty');
-  assert.deepStrictEqual(c.frontmatter.task, '', 'default task empty');
-  assert.deepStrictEqual(c.frontmatter.step, 0, 'default step 0');
-  assert.deepStrictEqual(c.frontmatter.totalSteps, 0, 'default totalSteps 0');
-  assert.deepStrictEqual(c.frontmatter.status, 'in_progress', 'default status in_progress');
-  assert.deepStrictEqual(c.frontmatter.savedAt, '', 'default savedAt empty');
+  assertEq(c.frontmatter.milestone, '', 'default milestone empty');
+  assertEq(c.frontmatter.slice, '', 'default slice empty');
+  assertEq(c.frontmatter.task, '', 'default task empty');
+  assertEq(c.frontmatter.step, 0, 'default step 0');
+  assertEq(c.frontmatter.totalSteps, 0, 'default totalSteps 0');
+  assertEq(c.frontmatter.status, 'in_progress', 'default status in_progress');
+  assertEq(c.frontmatter.savedAt, '', 'default savedAt empty');
 
   // Body sections still parse
-  assert.ok(c.completedWork.includes('Some work done'), 'completedWork without frontmatter');
-  assert.ok(c.remainingWork.includes('More to do'), 'remainingWork without frontmatter');
-  assert.ok(c.decisions.includes('A decision'), 'decisions without frontmatter');
-  assert.ok(c.context.includes('Some context'), 'context without frontmatter');
-  assert.ok(c.nextAction.includes('Next thing'), 'nextAction without frontmatter');
-});
-
-test('parseContinue: body section extraction', () => {
+  assertTrue(c.completedWork.includes('Some work done'), 'completedWork without frontmatter');
+  assertTrue(c.remainingWork.includes('More to do'), 'remainingWork without frontmatter');
+  assertTrue(c.decisions.includes('A decision'), 'decisions without frontmatter');
+  assertTrue(c.context.includes('Some context'), 'context without frontmatter');
+  assertTrue(c.nextAction.includes('Next thing'), 'nextAction without frontmatter');
+}
+
+console.log('\n=== parseContinue: body section extraction ===');
+{
   const content = `---
 milestone: M001
 slice: S01
@@ -1209,15 +1253,16 @@ Pick up at step 3: run the integration tests.
 `;
 
   const c = parseContinue(content);
-  assert.ok(c.completedWork.includes('First paragraph'), 'completedWork first paragraph');
-  assert.ok(c.completedWork.includes('Second paragraph'), 'completedWork second paragraph');
-  assert.ok(c.remainingWork.includes('step 3 and step 4'), 'remainingWork detail');
-  assert.ok(c.decisions.includes('approach A over approach B'), 'decisions detail');
-  assert.ok(c.context.includes('Node 22 required'), 'context detail');
-  assert.ok(c.nextAction.includes('step 3: run the integration tests'), 'nextAction detail');
-});
-
-test('parseContinue: total_steps vs totalSteps key support', () => {
+  assertTrue(c.completedWork.includes('First paragraph'), 'completedWork first paragraph');
+  assertTrue(c.completedWork.includes('Second paragraph'), 'completedWork second paragraph');
+  assertTrue(c.remainingWork.includes('step 3 and step 4'), 'remainingWork detail');
+  assertTrue(c.decisions.includes('approach A over approach B'), 'decisions detail');
+  assertTrue(c.context.includes('Node 22 required'), 'context detail');
+  assertTrue(c.nextAction.includes('step 3: run the integration tests'), 'nextAction detail');
+}
+
+console.log('\n=== parseContinue: total_steps vs totalSteps key support ===');
+{
   // Test total_steps (snake_case) — the primary format
   const content1 = `---
 milestone: M001
@@ -1235,7 +1280,7 @@ Work.
 `;
 
   const c1 = parseContinue(content1);
-  assert.deepStrictEqual(c1.frontmatter.totalSteps, 8, 'total_steps snake_case works');
+  assertEq(c1.frontmatter.totalSteps, 8, 'total_steps snake_case works');
 
   // Test totalSteps (camelCase) — the fallback
   const content2 = `---
@@ -1254,13 +1299,15 @@ Work.
 `;
 
   const c2 = parseContinue(content2);
-  assert.deepStrictEqual(c2.frontmatter.totalSteps, 6, 'totalSteps camelCase works');
-});
+  assertEq(c2.frontmatter.totalSteps, 6, 'totalSteps camelCase works');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // parseRequirementCounts tests
 // ═══════════════════════════════════════════════════════════════════════════
-test('parseRequirementCounts: full requirements file', () => {
+
+console.log('\n=== parseRequirementCounts: full requirements file ===');
+{
   const content = `# Requirements
 
 ## Active
@@ -1297,25 +1344,27 @@ test('parseRequirementCounts: full requirements file', () => {
 `;
 
   const counts = parseRequirementCounts(content);
-  assert.deepStrictEqual(counts.active, 3, 'active count');
-  assert.deepStrictEqual(counts.validated, 2, 'validated count');
-  assert.deepStrictEqual(counts.deferred, 1, 'deferred count');
-  assert.deepStrictEqual(counts.outOfScope, 2, 'outOfScope count');
-  assert.deepStrictEqual(counts.blocked, 1, 'blocked count');
-  assert.deepStrictEqual(counts.total, 8, 'total is sum of active+validated+deferred+outOfScope');
-});
-
-test('parseRequirementCounts: null input returns all zeros', () => {
+  assertEq(counts.active, 3, 'active count');
+  assertEq(counts.validated, 2, 'validated count');
+  assertEq(counts.deferred, 1, 'deferred count');
+  assertEq(counts.outOfScope, 2, 'outOfScope count');
+  assertEq(counts.blocked, 1, 'blocked count');
+  assertEq(counts.total, 8, 'total is sum of active+validated+deferred+outOfScope');
+}
+
+console.log('\n=== parseRequirementCounts: null input returns all zeros ===');
+{
   const counts = parseRequirementCounts(null);
-  assert.deepStrictEqual(counts.active, 0, 'null active');
-  assert.deepStrictEqual(counts.validated, 0, 'null validated');
-  assert.deepStrictEqual(counts.deferred, 0, 'null deferred');
-  assert.deepStrictEqual(counts.outOfScope, 0, 'null outOfScope');
-  assert.deepStrictEqual(counts.blocked, 0, 'null blocked');
-  assert.deepStrictEqual(counts.total, 0, 'null total');
-});
-
-test('parseRequirementCounts: empty sections return zero counts', () => {
+  assertEq(counts.active, 0, 'null active');
+  assertEq(counts.validated, 0, 'null validated');
+  assertEq(counts.deferred, 0, 'null deferred');
+  assertEq(counts.outOfScope, 0, 'null outOfScope');
+  assertEq(counts.blocked, 0, 'null blocked');
+  assertEq(counts.total, 0, 'null total');
+}
+
+console.log('\n=== parseRequirementCounts: empty sections return zero counts ===');
+{
   const content = `# Requirements
 
 ## Active
@@ -1328,15 +1377,16 @@ test('parseRequirementCounts: empty sections return zero counts', () => {
 `;
 
   const counts = parseRequirementCounts(content);
-  assert.deepStrictEqual(counts.active, 0, 'empty active');
-  assert.deepStrictEqual(counts.validated, 0, 'empty validated');
-  assert.deepStrictEqual(counts.deferred, 0, 'empty deferred');
-  assert.deepStrictEqual(counts.outOfScope, 0, 'empty outOfScope');
-  assert.deepStrictEqual(counts.blocked, 0, 'empty blocked');
-  assert.deepStrictEqual(counts.total, 0, 'empty total');
-});
-
-test('parseRequirementCounts: blocked status counting', () => {
+  assertEq(counts.active, 0, 'empty active');
+  assertEq(counts.validated, 0, 'empty validated');
+  assertEq(counts.deferred, 0, 'empty deferred');
+  assertEq(counts.outOfScope, 0, 'empty outOfScope');
+  assertEq(counts.blocked, 0, 'empty blocked');
+  assertEq(counts.total, 0, 'empty total');
+}
+
+console.log('\n=== parseRequirementCounts: blocked status counting ===');
+{
   const content = `# Requirements
 
 ## Active
@@ -1361,12 +1411,13 @@ test('parseRequirementCounts: blocked status counting', () => {
 `;
 
   const counts = parseRequirementCounts(content);
-  assert.deepStrictEqual(counts.active, 3, 'active includes blocked items in Active section');
-  assert.deepStrictEqual(counts.blocked, 3, 'blocked counts all blocked statuses across sections');
-  assert.deepStrictEqual(counts.deferred, 1, 'deferred section count');
-});
+  assertEq(counts.active, 3, 'active includes blocked items in Active section');
+  assertEq(counts.blocked, 3, 'blocked counts all blocked statuses across sections');
+  assertEq(counts.deferred, 1, 'deferred section count');
+}
 
-test('parseRequirementCounts: total is sum of all section counts', () => {
+console.log('\n=== parseRequirementCounts: total is sum of all section counts ===');
+{
   const content = `# Requirements
 
 ## Active
@@ -1400,18 +1451,20 @@ test('parseRequirementCounts: total is sum of all section counts', () => {
 `;
 
   const counts = parseRequirementCounts(content);
-  assert.deepStrictEqual(counts.active, 1, 'one active');
-  assert.deepStrictEqual(counts.validated, 2, 'two validated');
-  assert.deepStrictEqual(counts.deferred, 3, 'three deferred');
-  assert.deepStrictEqual(counts.outOfScope, 1, 'one outOfScope');
-  assert.deepStrictEqual(counts.total, 7, 'total = 1 + 2 + 3 + 1');
-  assert.deepStrictEqual(counts.total, counts.active + counts.validated + counts.deferred + counts.outOfScope, 'total is exact sum');
-});
+  assertEq(counts.active, 1, 'one active');
+  assertEq(counts.validated, 2, 'two validated');
+  assertEq(counts.deferred, 3, 'three deferred');
+  assertEq(counts.outOfScope, 1, 'one outOfScope');
+  assertEq(counts.total, 7, 'total = 1 + 2 + 3 + 1');
+  assertEq(counts.total, counts.active + counts.validated + counts.deferred + counts.outOfScope, 'total is exact sum');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // parseSecretsManifest / formatSecretsManifest tests
 // ═══════════════════════════════════════════════════════════════════════════
-test('parseSecretsManifest: full manifest with 3 keys', () => {
+
+console.log('\n=== parseSecretsManifest: full manifest with 3 keys ===');
+{
   const content = `# Secrets Manifest
 
 **Milestone:** M003
@@ -1455,36 +1508,37 @@ test('parseSecretsManifest: full manifest with 3 keys', () => {
 
   const m = parseSecretsManifest(content);
 
-  assert.deepStrictEqual(m.milestone, 'M003', 'manifest milestone');
-  assert.deepStrictEqual(m.generatedAt, '2025-06-15T10:00:00Z', 'manifest generatedAt');
-  assert.deepStrictEqual(m.entries.length, 3, 'three entries');
+  assertEq(m.milestone, 'M003', 'manifest milestone');
+  assertEq(m.generatedAt, '2025-06-15T10:00:00Z', 'manifest generatedAt');
+  assertEq(m.entries.length, 3, 'three entries');
 
   // First entry
-  assert.deepStrictEqual(m.entries[0].key, 'OPENAI_API_KEY', 'entry 0 key');
-  assert.deepStrictEqual(m.entries[0].service, 'OpenAI', 'entry 0 service');
-  assert.deepStrictEqual(m.entries[0].dashboardUrl, 'https://platform.openai.com/api-keys', 'entry 0 dashboardUrl');
-  assert.deepStrictEqual(m.entries[0].formatHint, 'starts with sk-', 'entry 0 formatHint');
-  assert.deepStrictEqual(m.entries[0].status, 'pending', 'entry 0 status');
-  assert.deepStrictEqual(m.entries[0].destination, 'dotenv', 'entry 0 destination');
-  assert.deepStrictEqual(m.entries[0].guidance.length, 3, 'entry 0 guidance count');
-  assert.deepStrictEqual(m.entries[0].guidance[0], 'Go to https://platform.openai.com/api-keys', 'entry 0 guidance[0]');
-  assert.deepStrictEqual(m.entries[0].guidance[2], 'Copy the key immediately — it won\'t be shown again', 'entry 0 guidance[2]');
+  assertEq(m.entries[0].key, 'OPENAI_API_KEY', 'entry 0 key');
+  assertEq(m.entries[0].service, 'OpenAI', 'entry 0 service');
+  assertEq(m.entries[0].dashboardUrl, 'https://platform.openai.com/api-keys', 'entry 0 dashboardUrl');
+  assertEq(m.entries[0].formatHint, 'starts with sk-', 'entry 0 formatHint');
+  assertEq(m.entries[0].status, 'pending', 'entry 0 status');
+  assertEq(m.entries[0].destination, 'dotenv', 'entry 0 destination');
+  assertEq(m.entries[0].guidance.length, 3, 'entry 0 guidance count');
+  assertEq(m.entries[0].guidance[0], 'Go to https://platform.openai.com/api-keys', 'entry 0 guidance[0]');
+  assertEq(m.entries[0].guidance[2], 'Copy the key immediately — it won\'t be shown again', 'entry 0 guidance[2]');
 
   // Second entry
-  assert.deepStrictEqual(m.entries[1].key, 'STRIPE_SECRET_KEY', 'entry 1 key');
-  assert.deepStrictEqual(m.entries[1].service, 'Stripe', 'entry 1 service');
-  assert.deepStrictEqual(m.entries[1].status, 'collected', 'entry 1 status');
-  assert.deepStrictEqual(m.entries[1].formatHint, 'starts with sk_test_ or sk_live_', 'entry 1 formatHint');
-  assert.deepStrictEqual(m.entries[1].guidance.length, 3, 'entry 1 guidance count');
+  assertEq(m.entries[1].key, 'STRIPE_SECRET_KEY', 'entry 1 key');
+  assertEq(m.entries[1].service, 'Stripe', 'entry 1 service');
+  assertEq(m.entries[1].status, 'collected', 'entry 1 status');
+  assertEq(m.entries[1].formatHint, 'starts with sk_test_ or sk_live_', 'entry 1 formatHint');
+  assertEq(m.entries[1].guidance.length, 3, 'entry 1 guidance count');
 
   // Third entry
-  assert.deepStrictEqual(m.entries[2].key, 'SUPABASE_URL', 'entry 2 key');
-  assert.deepStrictEqual(m.entries[2].status, 'skipped', 'entry 2 status');
-  assert.deepStrictEqual(m.entries[2].destination, 'vercel', 'entry 2 destination');
-  assert.deepStrictEqual(m.entries[2].guidance.length, 2, 'entry 2 guidance count');
-});
-
-test('parseSecretsManifest: single-key manifest', () => {
+  assertEq(m.entries[2].key, 'SUPABASE_URL', 'entry 2 key');
+  assertEq(m.entries[2].status, 'skipped', 'entry 2 status');
+  assertEq(m.entries[2].destination, 'vercel', 'entry 2 destination');
+  assertEq(m.entries[2].guidance.length, 2, 'entry 2 guidance count');
+}
+
+console.log('\n=== parseSecretsManifest: single-key manifest ===');
+{
   const content = `# Secrets Manifest
 
 **Milestone:** M001
@@ -1503,14 +1557,15 @@ test('parseSecretsManifest: single-key manifest', () => {
 `;
 
   const m = parseSecretsManifest(content);
-  assert.deepStrictEqual(m.milestone, 'M001', 'single-key milestone');
-  assert.deepStrictEqual(m.entries.length, 1, 'single entry');
-  assert.deepStrictEqual(m.entries[0].key, 'DATABASE_URL', 'single entry key');
-  assert.deepStrictEqual(m.entries[0].service, 'PostgreSQL', 'single entry service');
-  assert.deepStrictEqual(m.entries[0].guidance.length, 2, 'single entry guidance count');
-});
-
-test('parseSecretsManifest: empty/no-secrets manifest', () => {
+  assertEq(m.milestone, 'M001', 'single-key milestone');
+  assertEq(m.entries.length, 1, 'single entry');
+  assertEq(m.entries[0].key, 'DATABASE_URL', 'single entry key');
+  assertEq(m.entries[0].service, 'PostgreSQL', 'single entry service');
+  assertEq(m.entries[0].guidance.length, 2, 'single entry guidance count');
+}
+
+console.log('\n=== parseSecretsManifest: empty/no-secrets manifest ===');
+{
   const content = `# Secrets Manifest
 
 **Milestone:** M002
@@ -1518,12 +1573,13 @@ test('parseSecretsManifest: empty/no-secrets manifest', () => {
 `;
 
   const m = parseSecretsManifest(content);
-  assert.deepStrictEqual(m.milestone, 'M002', 'empty manifest milestone');
-  assert.deepStrictEqual(m.generatedAt, '2025-06-15T14:00:00Z', 'empty manifest generatedAt');
-  assert.deepStrictEqual(m.entries.length, 0, 'no entries in empty manifest');
-});
+  assertEq(m.milestone, 'M002', 'empty manifest milestone');
+  assertEq(m.generatedAt, '2025-06-15T14:00:00Z', 'empty manifest generatedAt');
+  assertEq(m.entries.length, 0, 'no entries in empty manifest');
+}
 
-test('parseSecretsManifest: missing optional fields default correctly', () => {
+console.log('\n=== parseSecretsManifest: missing optional fields default correctly ===');
+{
   const content = `# Secrets Manifest
 
 **Milestone:** M004
@@ -1537,17 +1593,18 @@ test('parseSecretsManifest: missing optional fields default correctly', () => {
 `;
 
   const m = parseSecretsManifest(content);
-  assert.deepStrictEqual(m.entries.length, 1, 'one entry with missing fields');
-  assert.deepStrictEqual(m.entries[0].key, 'SOME_API_KEY', 'key parsed');
-  assert.deepStrictEqual(m.entries[0].service, 'SomeService', 'service parsed');
-  assert.deepStrictEqual(m.entries[0].dashboardUrl, '', 'missing dashboardUrl defaults to empty string');
-  assert.deepStrictEqual(m.entries[0].formatHint, '', 'missing formatHint defaults to empty string');
-  assert.deepStrictEqual(m.entries[0].status, 'pending', 'missing status defaults to pending');
-  assert.deepStrictEqual(m.entries[0].destination, 'dotenv', 'missing destination defaults to dotenv');
-  assert.deepStrictEqual(m.entries[0].guidance.length, 1, 'guidance still parsed');
-});
-
-test('parseSecretsManifest: all three status values parse', () => {
+  assertEq(m.entries.length, 1, 'one entry with missing fields');
+  assertEq(m.entries[0].key, 'SOME_API_KEY', 'key parsed');
+  assertEq(m.entries[0].service, 'SomeService', 'service parsed');
+  assertEq(m.entries[0].dashboardUrl, '', 'missing dashboardUrl defaults to empty string');
+  assertEq(m.entries[0].formatHint, '', 'missing formatHint defaults to empty string');
+  assertEq(m.entries[0].status, 'pending', 'missing status defaults to pending');
+  assertEq(m.entries[0].destination, 'dotenv', 'missing destination defaults to dotenv');
+  assertEq(m.entries[0].guidance.length, 1, 'guidance still parsed');
+}
+
+console.log('\n=== parseSecretsManifest: all three status values parse ===');
+{
   for (const status of ['pending', 'collected', 'skipped'] as const) {
     const content = `# Secrets Manifest
 
@@ -1563,11 +1620,12 @@ test('parseSecretsManifest: all three status values parse', () => {
 `;
 
     const m = parseSecretsManifest(content);
-    assert.deepStrictEqual(m.entries[0].status, status, `status variant: ${status}`);
+    assertEq(m.entries[0].status, status, `status variant: ${status}`);
   }
-});
+}
 
-test('parseSecretsManifest: invalid status defaults to pending', () => {
+console.log('\n=== parseSecretsManifest: invalid status defaults to pending ===');
+{
   const content = `# Secrets Manifest
 
 **Milestone:** M006
@@ -1582,10 +1640,11 @@ test('parseSecretsManifest: invalid status defaults to pending', () => {
 `;
 
   const m = parseSecretsManifest(content);
-  assert.deepStrictEqual(m.entries[0].status, 'pending', 'invalid status defaults to pending');
-});
+  assertEq(m.entries[0].status, 'pending', 'invalid status defaults to pending');
+}
 
-test('parseSecretsManifest + formatSecretsManifest: round-trip', () => {
+console.log('\n=== parseSecretsManifest + formatSecretsManifest: round-trip ===');
+{
   const original = `# Secrets Manifest
 
 **Milestone:** M007
@@ -1620,30 +1679,32 @@ test('parseSecretsManifest + formatSecretsManifest: round-trip', () => {
   const parsed2 = parseSecretsManifest(formatted);
 
   // Verify semantic equality after round-trip
-  assert.deepStrictEqual(parsed2.milestone, parsed1.milestone, 'round-trip milestone');
-  assert.deepStrictEqual(parsed2.generatedAt, parsed1.generatedAt, 'round-trip generatedAt');
-  assert.deepStrictEqual(parsed2.entries.length, parsed1.entries.length, 'round-trip entry count');
+  assertEq(parsed2.milestone, parsed1.milestone, 'round-trip milestone');
+  assertEq(parsed2.generatedAt, parsed1.generatedAt, 'round-trip generatedAt');
+  assertEq(parsed2.entries.length, parsed1.entries.length, 'round-trip entry count');
 
   for (let i = 0; i < parsed1.entries.length; i++) {
     const e1 = parsed1.entries[i];
     const e2 = parsed2.entries[i];
-    assert.deepStrictEqual(e2.key, e1.key, `round-trip entry ${i} key`);
-    assert.deepStrictEqual(e2.service, e1.service, `round-trip entry ${i} service`);
-    assert.deepStrictEqual(e2.dashboardUrl, e1.dashboardUrl, `round-trip entry ${i} dashboardUrl`);
-    assert.deepStrictEqual(e2.formatHint, e1.formatHint, `round-trip entry ${i} formatHint`);
-    assert.deepStrictEqual(e2.status, e1.status, `round-trip entry ${i} status`);
-    assert.deepStrictEqual(e2.destination, e1.destination, `round-trip entry ${i} destination`);
-    assert.deepStrictEqual(e2.guidance.length, e1.guidance.length, `round-trip entry ${i} guidance length`);
+    assertEq(e2.key, e1.key, `round-trip entry ${i} key`);
+    assertEq(e2.service, e1.service, `round-trip entry ${i} service`);
+    assertEq(e2.dashboardUrl, e1.dashboardUrl, `round-trip entry ${i} dashboardUrl`);
+    assertEq(e2.formatHint, e1.formatHint, `round-trip entry ${i} formatHint`);
+    assertEq(e2.status, e1.status, `round-trip entry ${i} status`);
+    assertEq(e2.destination, e1.destination, `round-trip entry ${i} destination`);
+    assertEq(e2.guidance.length, e1.guidance.length, `round-trip entry ${i} guidance length`);
     for (let j = 0; j < e1.guidance.length; j++) {
-      assert.deepStrictEqual(e2.guidance[j], e1.guidance[j], `round-trip entry ${i} guidance[${j}]`);
+      assertEq(e2.guidance[j], e1.guidance[j], `round-trip entry ${i} guidance[${j}]`);
     }
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // LLM-style round-trip tests — realistic manifest variations
 // ═══════════════════════════════════════════════════════════════════════════
-test('LLM round-trip: extra whitespace', () => {
+
+console.log('\n=== LLM round-trip: extra whitespace ===');
+{
   // LLMs often produce inconsistent indentation and trailing spaces
   const messy = `# Secrets Manifest
 
@@ -1674,33 +1735,34 @@ test('LLM round-trip: extra whitespace', () => {
   const formatted = formatSecretsManifest(parsed1);
   const parsed2 = parseSecretsManifest(formatted);
 
-  assert.deepStrictEqual(parsed2.milestone, parsed1.milestone, 'whitespace round-trip milestone');
-  assert.deepStrictEqual(parsed2.generatedAt, parsed1.generatedAt, 'whitespace round-trip generatedAt');
-  assert.deepStrictEqual(parsed2.entries.length, parsed1.entries.length, 'whitespace round-trip entry count');
-  assert.deepStrictEqual(parsed2.entries.length, 2, 'whitespace: two entries parsed');
+  assertEq(parsed2.milestone, parsed1.milestone, 'whitespace round-trip milestone');
+  assertEq(parsed2.generatedAt, parsed1.generatedAt, 'whitespace round-trip generatedAt');
+  assertEq(parsed2.entries.length, parsed1.entries.length, 'whitespace round-trip entry count');
+  assertEq(parsed2.entries.length, 2, 'whitespace: two entries parsed');
 
   for (let i = 0; i < parsed1.entries.length; i++) {
     const e1 = parsed1.entries[i];
     const e2 = parsed2.entries[i];
-    assert.deepStrictEqual(e2.key, e1.key, `whitespace round-trip entry ${i} key`);
-    assert.deepStrictEqual(e2.service, e1.service, `whitespace round-trip entry ${i} service`);
-    assert.deepStrictEqual(e2.dashboardUrl, e1.dashboardUrl, `whitespace round-trip entry ${i} dashboardUrl`);
-    assert.deepStrictEqual(e2.formatHint, e1.formatHint, `whitespace round-trip entry ${i} formatHint`);
-    assert.deepStrictEqual(e2.status, e1.status, `whitespace round-trip entry ${i} status`);
-    assert.deepStrictEqual(e2.destination, e1.destination, `whitespace round-trip entry ${i} destination`);
-    assert.deepStrictEqual(e2.guidance.length, e1.guidance.length, `whitespace round-trip entry ${i} guidance length`);
+    assertEq(e2.key, e1.key, `whitespace round-trip entry ${i} key`);
+    assertEq(e2.service, e1.service, `whitespace round-trip entry ${i} service`);
+    assertEq(e2.dashboardUrl, e1.dashboardUrl, `whitespace round-trip entry ${i} dashboardUrl`);
+    assertEq(e2.formatHint, e1.formatHint, `whitespace round-trip entry ${i} formatHint`);
+    assertEq(e2.status, e1.status, `whitespace round-trip entry ${i} status`);
+    assertEq(e2.destination, e1.destination, `whitespace round-trip entry ${i} destination`);
+    assertEq(e2.guidance.length, e1.guidance.length, `whitespace round-trip entry ${i} guidance length`);
     for (let j = 0; j < e1.guidance.length; j++) {
-      assert.deepStrictEqual(e2.guidance[j], e1.guidance[j], `whitespace round-trip entry ${i} guidance[${j}]`);
+      assertEq(e2.guidance[j], e1.guidance[j], `whitespace round-trip entry ${i} guidance[${j}]`);
     }
   }
 
   // Verify the parser correctly stripped trailing whitespace
-  assert.deepStrictEqual(parsed1.milestone, 'M010', 'whitespace: milestone trimmed');
-  assert.deepStrictEqual(parsed1.entries[0].key, 'OPENAI_API_KEY', 'whitespace: key trimmed');
-  assert.deepStrictEqual(parsed1.entries[0].service, 'OpenAI', 'whitespace: service trimmed');
-});
+  assertEq(parsed1.milestone, 'M010', 'whitespace: milestone trimmed');
+  assertEq(parsed1.entries[0].key, 'OPENAI_API_KEY', 'whitespace: key trimmed');
+  assertEq(parsed1.entries[0].service, 'OpenAI', 'whitespace: service trimmed');
+}
 
-test('LLM round-trip: missing optional fields', () => {
+console.log('\n=== LLM round-trip: missing optional fields ===');
+{
   // LLMs may omit Dashboard and Format hint lines entirely
   const minimal = `# Secrets Manifest
 
@@ -1728,31 +1790,32 @@ test('LLM round-trip: missing optional fields', () => {
   const parsed1 = parseSecretsManifest(minimal);
 
   // Verify missing optional fields get defaults
-  assert.deepStrictEqual(parsed1.entries[0].dashboardUrl, '', 'missing-optional: no dashboard → empty string');
-  assert.deepStrictEqual(parsed1.entries[0].formatHint, '', 'missing-optional: no format hint → empty string');
-  assert.deepStrictEqual(parsed1.entries[1].dashboardUrl, '', 'missing-optional: entry 2 no dashboard → empty string');
-  assert.deepStrictEqual(parsed1.entries[1].formatHint, '', 'missing-optional: entry 2 no format hint → empty string');
+  assertEq(parsed1.entries[0].dashboardUrl, '', 'missing-optional: no dashboard → empty string');
+  assertEq(parsed1.entries[0].formatHint, '', 'missing-optional: no format hint → empty string');
+  assertEq(parsed1.entries[1].dashboardUrl, '', 'missing-optional: entry 2 no dashboard → empty string');
+  assertEq(parsed1.entries[1].formatHint, '', 'missing-optional: entry 2 no format hint → empty string');
 
   // Round-trip: formatter omits empty optional fields, re-parse preserves defaults
   const formatted = formatSecretsManifest(parsed1);
   const parsed2 = parseSecretsManifest(formatted);
 
-  assert.deepStrictEqual(parsed2.entries.length, parsed1.entries.length, 'missing-optional round-trip entry count');
+  assertEq(parsed2.entries.length, parsed1.entries.length, 'missing-optional round-trip entry count');
 
   for (let i = 0; i < parsed1.entries.length; i++) {
     const e1 = parsed1.entries[i];
     const e2 = parsed2.entries[i];
-    assert.deepStrictEqual(e2.key, e1.key, `missing-optional round-trip entry ${i} key`);
-    assert.deepStrictEqual(e2.service, e1.service, `missing-optional round-trip entry ${i} service`);
-    assert.deepStrictEqual(e2.dashboardUrl, e1.dashboardUrl, `missing-optional round-trip entry ${i} dashboardUrl`);
-    assert.deepStrictEqual(e2.formatHint, e1.formatHint, `missing-optional round-trip entry ${i} formatHint`);
-    assert.deepStrictEqual(e2.status, e1.status, `missing-optional round-trip entry ${i} status`);
-    assert.deepStrictEqual(e2.destination, e1.destination, `missing-optional round-trip entry ${i} destination`);
-    assert.deepStrictEqual(e2.guidance.length, e1.guidance.length, `missing-optional round-trip entry ${i} guidance length`);
+    assertEq(e2.key, e1.key, `missing-optional round-trip entry ${i} key`);
+    assertEq(e2.service, e1.service, `missing-optional round-trip entry ${i} service`);
+    assertEq(e2.dashboardUrl, e1.dashboardUrl, `missing-optional round-trip entry ${i} dashboardUrl`);
+    assertEq(e2.formatHint, e1.formatHint, `missing-optional round-trip entry ${i} formatHint`);
+    assertEq(e2.status, e1.status, `missing-optional round-trip entry ${i} status`);
+    assertEq(e2.destination, e1.destination, `missing-optional round-trip entry ${i} destination`);
+    assertEq(e2.guidance.length, e1.guidance.length, `missing-optional round-trip entry ${i} guidance length`);
   }
-});
+}
 
-test('LLM round-trip: extra blank lines', () => {
+console.log('\n=== LLM round-trip: extra blank lines ===');
+{
   // LLMs sometimes insert excessive blank lines between sections
   const blanky = `# Secrets Manifest
 
@@ -1796,40 +1859,42 @@ test('LLM round-trip: extra blank lines', () => {
 
   const parsed1 = parseSecretsManifest(blanky);
 
-  assert.deepStrictEqual(parsed1.entries.length, 2, 'blank-lines: two entries parsed');
-  assert.deepStrictEqual(parsed1.milestone, 'M012', 'blank-lines: milestone parsed');
-  assert.deepStrictEqual(parsed1.entries[0].key, 'API_KEY_ONE', 'blank-lines: first key');
-  assert.deepStrictEqual(parsed1.entries[0].guidance.length, 2, 'blank-lines: first entry guidance count');
-  assert.deepStrictEqual(parsed1.entries[1].key, 'API_KEY_TWO', 'blank-lines: second key');
-  assert.deepStrictEqual(parsed1.entries[1].status, 'skipped', 'blank-lines: second entry status');
+  assertEq(parsed1.entries.length, 2, 'blank-lines: two entries parsed');
+  assertEq(parsed1.milestone, 'M012', 'blank-lines: milestone parsed');
+  assertEq(parsed1.entries[0].key, 'API_KEY_ONE', 'blank-lines: first key');
+  assertEq(parsed1.entries[0].guidance.length, 2, 'blank-lines: first entry guidance count');
+  assertEq(parsed1.entries[1].key, 'API_KEY_TWO', 'blank-lines: second key');
+  assertEq(parsed1.entries[1].status, 'skipped', 'blank-lines: second entry status');
 
   // Round-trip produces clean output
   const formatted = formatSecretsManifest(parsed1);
   const parsed2 = parseSecretsManifest(formatted);
 
-  assert.deepStrictEqual(parsed2.entries.length, parsed1.entries.length, 'blank-lines round-trip entry count');
+  assertEq(parsed2.entries.length, parsed1.entries.length, 'blank-lines round-trip entry count');
 
   for (let i = 0; i < parsed1.entries.length; i++) {
     const e1 = parsed1.entries[i];
     const e2 = parsed2.entries[i];
-    assert.deepStrictEqual(e2.key, e1.key, `blank-lines round-trip entry ${i} key`);
-    assert.deepStrictEqual(e2.service, e1.service, `blank-lines round-trip entry ${i} service`);
-    assert.deepStrictEqual(e2.dashboardUrl, e1.dashboardUrl, `blank-lines round-trip entry ${i} dashboardUrl`);
-    assert.deepStrictEqual(e2.formatHint, e1.formatHint, `blank-lines round-trip entry ${i} formatHint`);
-    assert.deepStrictEqual(e2.status, e1.status, `blank-lines round-trip entry ${i} status`);
-    assert.deepStrictEqual(e2.destination, e1.destination, `blank-lines round-trip entry ${i} destination`);
-    assert.deepStrictEqual(e2.guidance.length, e1.guidance.length, `blank-lines round-trip entry ${i} guidance length`);
+    assertEq(e2.key, e1.key, `blank-lines round-trip entry ${i} key`);
+    assertEq(e2.service, e1.service, `blank-lines round-trip entry ${i} service`);
+    assertEq(e2.dashboardUrl, e1.dashboardUrl, `blank-lines round-trip entry ${i} dashboardUrl`);
+    assertEq(e2.formatHint, e1.formatHint, `blank-lines round-trip entry ${i} formatHint`);
+    assertEq(e2.status, e1.status, `blank-lines round-trip entry ${i} status`);
+    assertEq(e2.destination, e1.destination, `blank-lines round-trip entry ${i} destination`);
+    assertEq(e2.guidance.length, e1.guidance.length, `blank-lines round-trip entry ${i} guidance length`);
   }
 
   // Verify the formatted output is cleaner (fewer consecutive blank lines)
   const consecutiveBlanks = formatted.match(/\n{4,}/g);
-  assert.ok(consecutiveBlanks === null, 'blank-lines: formatted output has no 4+ consecutive newlines');
-});
+  assertTrue(consecutiveBlanks === null, 'blank-lines: formatted output has no 4+ consecutive newlines');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // parseRoadmap: boundary map with embedded code fences (#468)
 // ═══════════════════════════════════════════════════════════════════════════
-test('parseRoadmap: boundary map with code fences (#468)', () => {
+
+console.log('\n=== parseRoadmap: boundary map with code fences (#468) ===');
+{
   const content = `# M001: Test
 
 **Vision:** Test
@@ -1858,10 +1923,10 @@ Consumes: nothing
   const r = parseRoadmap(content);
   const elapsed = Date.now() - start;
 
-  assert.ok(elapsed < 1000, `boundary map with code fences parsed in ${elapsed}ms (should be < 1s)`);
-  assert.deepStrictEqual(r.slices.length, 2, 'code-fence roadmap: slice count');
+  assertTrue(elapsed < 1000, `boundary map with code fences parsed in ${elapsed}ms (should be < 1s)`);
+  assertEq(r.slices.length, 2, 'code-fence roadmap: slice count');
   // Boundary map should still parse (may not capture perfectly with code fences, but must not hang)
-  assert.ok(r.boundaryMap.length >= 0, 'code-fence roadmap: boundary map parsed without hanging');
-});
+  assertTrue(r.boundaryMap.length >= 0, 'code-fence roadmap: boundary map parsed without hanging');
+}
 
-});
+report();