gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/integration-edge.test.ts

@@ -19,8 +19,9 @@ import {
   formatDecisionsForPrompt,
   formatRequirementsForPrompt,
 } from '../context-store.ts';
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── Fixture Helper ────────────────────────────────────────────────────────
 
@@ -47,7 +48,8 @@ function generateDecisionsMarkdown(count: number): string {
 // Edge Case 1: Empty Project
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('integration-edge: empty project', () => {
+console.log('\n=== integration-edge: empty project ===');
+{
   const base = mkdtempSync(join(tmpdir(), 'gsd-int-edge-empty-'));
   const gsdDir = join(base, '.gsd');
   mkdirSync(gsdDir, { recursive: true });
@@ -57,54 +59,55 @@ test('integration-edge: empty project', () => {
   try {
     // Open DB first so migrateFromMarkdown doesn't auto-create at default path
     openDatabase(dbPath);
-    assert.ok(isDbAvailable(), 'empty: DB available after open');
+    assertTrue(isDbAvailable(), 'empty: DB available after open');
 
     // Migrate with no markdown files on disk
     const result = migrateFromMarkdown(base);
 
-    assert.deepStrictEqual(result.decisions, 0, 'empty: 0 decisions imported');
-    assert.deepStrictEqual(result.requirements, 0, 'empty: 0 requirements imported');
-    assert.deepStrictEqual(result.artifacts, 0, 'empty: 0 artifacts imported');
+    assertEq(result.decisions, 0, 'empty: 0 decisions imported');
+    assertEq(result.requirements, 0, 'empty: 0 requirements imported');
+    assertEq(result.artifacts, 0, 'empty: 0 artifacts imported');
 
     // Query decisions → empty array
     const decisions = queryDecisions();
-    assert.deepStrictEqual(decisions.length, 0, 'empty: queryDecisions returns empty array');
+    assertEq(decisions.length, 0, 'empty: queryDecisions returns empty array');
 
     // Query requirements → empty array
     const requirements = queryRequirements();
-    assert.deepStrictEqual(requirements.length, 0, 'empty: queryRequirements returns empty array');
+    assertEq(requirements.length, 0, 'empty: queryRequirements returns empty array');
 
     // Query with scope filters → still empty, no crash
     const scopedDecisions = queryDecisions({ milestoneId: 'M001' });
-    assert.deepStrictEqual(scopedDecisions.length, 0, 'empty: scoped queryDecisions returns empty');
+    assertEq(scopedDecisions.length, 0, 'empty: scoped queryDecisions returns empty');
 
     const scopedRequirements = queryRequirements({ sliceId: 'S01' });
-    assert.deepStrictEqual(scopedRequirements.length, 0, 'empty: scoped queryRequirements returns empty');
+    assertEq(scopedRequirements.length, 0, 'empty: scoped queryRequirements returns empty');
 
     // Format empty results → empty strings
     const formattedD = formatDecisionsForPrompt([]);
     const formattedR = formatRequirementsForPrompt([]);
-    assert.deepStrictEqual(formattedD, '', 'empty: formatDecisionsForPrompt returns empty string');
-    assert.deepStrictEqual(formattedR, '', 'empty: formatRequirementsForPrompt returns empty string');
+    assertEq(formattedD, '', 'empty: formatDecisionsForPrompt returns empty string');
+    assertEq(formattedR, '', 'empty: formatRequirementsForPrompt returns empty string');
 
     // Format with actual empty query results
     const formattedD2 = formatDecisionsForPrompt(decisions);
     const formattedR2 = formatRequirementsForPrompt(requirements);
-    assert.deepStrictEqual(formattedD2, '', 'empty: format of empty query decisions is empty string');
-    assert.deepStrictEqual(formattedR2, '', 'empty: format of empty query requirements is empty string');
+    assertEq(formattedD2, '', 'empty: format of empty query decisions is empty string');
+    assertEq(formattedR2, '', 'empty: format of empty query requirements is empty string');
 
     closeDatabase();
   } finally {
     closeDatabase();
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Edge Case 2: Partial Migration (decisions only, no requirements)
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('integration-edge: partial migration', () => {
+console.log('\n=== integration-edge: partial migration ===');
+{
   const base = mkdtempSync(join(tmpdir(), 'gsd-int-edge-partial-'));
   const gsdDir = join(base, '.gsd');
   mkdirSync(gsdDir, { recursive: true });
@@ -117,48 +120,49 @@ test('integration-edge: partial migration', () => {
 
   try {
     openDatabase(dbPath);
-    assert.ok(isDbAvailable(), 'partial: DB available after open');
+    assertTrue(isDbAvailable(), 'partial: DB available after open');
 
     const result = migrateFromMarkdown(base);
 
     // Decisions imported, requirements skipped gracefully
-    assert.ok(result.decisions === 6, `partial: imported ${result.decisions} decisions, expected 6`);
-    assert.deepStrictEqual(result.requirements, 0, 'partial: 0 requirements imported (no file)');
+    assertTrue(result.decisions === 6, `partial: imported ${result.decisions} decisions, expected 6`);
+    assertEq(result.requirements, 0, 'partial: 0 requirements imported (no file)');
 
     // Decisions queryable
     const decisions = queryDecisions();
-    assert.ok(decisions.length === 6, `partial: queryDecisions returns 6 (got ${decisions.length})`);
+    assertTrue(decisions.length === 6, `partial: queryDecisions returns 6 (got ${decisions.length})`);
 
     const m001Decisions = queryDecisions({ milestoneId: 'M001' });
-    assert.ok(m001Decisions.length > 0, 'partial: M001 decisions non-empty');
-    assert.ok(m001Decisions.length < decisions.length, 'partial: M001 scope filters correctly');
+    assertTrue(m001Decisions.length > 0, 'partial: M001 decisions non-empty');
+    assertTrue(m001Decisions.length < decisions.length, 'partial: M001 scope filters correctly');
 
     // Requirements return empty — no crash
     const requirements = queryRequirements();
-    assert.deepStrictEqual(requirements.length, 0, 'partial: queryRequirements returns empty');
+    assertEq(requirements.length, 0, 'partial: queryRequirements returns empty');
 
     const scopedReqs = queryRequirements({ sliceId: 'S01' });
-    assert.deepStrictEqual(scopedReqs.length, 0, 'partial: scoped queryRequirements returns empty');
+    assertEq(scopedReqs.length, 0, 'partial: scoped queryRequirements returns empty');
 
     // Format works on partial data
     const formattedD = formatDecisionsForPrompt(m001Decisions);
-    assert.ok(formattedD.length > 0, 'partial: formatted decisions non-empty');
+    assertTrue(formattedD.length > 0, 'partial: formatted decisions non-empty');
 
     const formattedR = formatRequirementsForPrompt(requirements);
-    assert.deepStrictEqual(formattedR, '', 'partial: formatted empty requirements is empty string');
+    assertEq(formattedR, '', 'partial: formatted empty requirements is empty string');
 
     closeDatabase();
   } finally {
     closeDatabase();
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Edge Case 3: Fallback Mode (_resetProvider)
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('integration-edge: fallback mode', () => {
+console.log('\n=== integration-edge: fallback mode ===');
+{
   const base = mkdtempSync(join(tmpdir(), 'gsd-int-edge-fallback-'));
   const gsdDir = join(base, '.gsd');
   mkdirSync(gsdDir, { recursive: true });
@@ -171,53 +175,54 @@ test('integration-edge: fallback mode', () => {
   try {
     // Step 1: Open DB normally and verify it works
     openDatabase(dbPath);
-    assert.ok(isDbAvailable(), 'fallback: DB available after open');
+    assertTrue(isDbAvailable(), 'fallback: DB available after open');
 
     migrateFromMarkdown(base);
     const before = queryDecisions();
-    assert.ok(before.length === 4, `fallback: 4 decisions before reset (got ${before.length})`);
+    assertTrue(before.length === 4, `fallback: 4 decisions before reset (got ${before.length})`);
 
     // Step 2: Close and reset provider → DB unavailable
     closeDatabase();
     _resetProvider();
-    assert.ok(!isDbAvailable(), 'fallback: DB unavailable after _resetProvider');
+    assertTrue(!isDbAvailable(), 'fallback: DB unavailable after _resetProvider');
 
     // Step 3: Queries degrade gracefully (return empty, don't throw)
     const degradedDecisions = queryDecisions();
-    assert.deepStrictEqual(degradedDecisions.length, 0, 'fallback: queryDecisions returns empty when unavailable');
+    assertEq(degradedDecisions.length, 0, 'fallback: queryDecisions returns empty when unavailable');
 
     const degradedRequirements = queryRequirements();
-    assert.deepStrictEqual(degradedRequirements.length, 0, 'fallback: queryRequirements returns empty when unavailable');
+    assertEq(degradedRequirements.length, 0, 'fallback: queryRequirements returns empty when unavailable');
 
     const degradedScopedD = queryDecisions({ milestoneId: 'M001' });
-    assert.deepStrictEqual(degradedScopedD.length, 0, 'fallback: scoped queryDecisions returns empty when unavailable');
+    assertEq(degradedScopedD.length, 0, 'fallback: scoped queryDecisions returns empty when unavailable');
 
     const degradedScopedR = queryRequirements({ sliceId: 'S01' });
-    assert.deepStrictEqual(degradedScopedR.length, 0, 'fallback: scoped queryRequirements returns empty when unavailable');
+    assertEq(degradedScopedR.length, 0, 'fallback: scoped queryRequirements returns empty when unavailable');
 
     // Format functions work on empty arrays (no crash)
     const formattedD = formatDecisionsForPrompt(degradedDecisions);
-    assert.deepStrictEqual(formattedD, '', 'fallback: format degraded decisions is empty');
+    assertEq(formattedD, '', 'fallback: format degraded decisions is empty');
 
     const formattedR = formatRequirementsForPrompt(degradedRequirements);
-    assert.deepStrictEqual(formattedR, '', 'fallback: format degraded requirements is empty');
+    assertEq(formattedR, '', 'fallback: format degraded requirements is empty');
 
     // Step 4: Re-open DB → restores availability
     openDatabase(dbPath);
-    assert.ok(isDbAvailable(), 'fallback: DB available after re-open');
+    assertTrue(isDbAvailable(), 'fallback: DB available after re-open');
 
     // Data should be there from the file-backed DB (persisted by first open)
     // But rows may need re-import since the DB was freshly opened from the file
     migrateFromMarkdown(base);
     const restored = queryDecisions();
-    assert.ok(restored.length === 4, `fallback: 4 decisions after re-open (got ${restored.length})`);
+    assertTrue(restored.length === 4, `fallback: 4 decisions after re-open (got ${restored.length})`);
 
     closeDatabase();
   } finally {
     closeDatabase();
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
 // ─── Report ────────────────────────────────────────────────────────────────
 
+report();

package/src/resources/extensions/gsd/tests/integration-lifecycle.test.ts

@@ -21,8 +21,9 @@ import {
   formatRequirementsForPrompt,
 } from '../context-store.ts';
 import { saveDecisionToDb, generateDecisionsMd } from '../db-writer.ts';
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 
 // ─── Fixture Generators (duplicated from token-savings.test.ts — file-scoped) ──
 
@@ -118,7 +119,10 @@ const ROADMAP_CONTENT = `# M001: Test Milestone\n\n**Vision:** Integration test
 // Full Lifecycle Integration Test
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('integration-lifecycle: full pipeline', async () => {
+async function main(): Promise<void> {
+
+  console.log('\n=== integration-lifecycle: full pipeline ===');
+  {
     // ── Step 1: Set up temp dir with realistic .gsd/ structure ──────────
     const base = mkdtempSync(join(tmpdir(), 'gsd-int-lifecycle-'));
     const gsdDir = join(base, '.gsd');
@@ -138,37 +142,37 @@ test('integration-lifecycle: full pipeline', async () => {
     try {
       // ── Step 2: Open file-backed DB + migrateFromMarkdown ──────────────
       openDatabase(dbPath);
-      assert.ok(isDbAvailable(), 'lifecycle: DB is available after open');
+      assertTrue(isDbAvailable(), 'lifecycle: DB is available after open');
 
       const result = migrateFromMarkdown(base);
 
-      assert.ok(result.decisions === DECISIONS_COUNT, `lifecycle: imported ${result.decisions} decisions, expected ${DECISIONS_COUNT}`);
-      assert.ok(result.requirements === REQUIREMENTS_COUNT, `lifecycle: imported ${result.requirements} requirements, expected ${REQUIREMENTS_COUNT}`);
-      assert.ok(result.artifacts >= 1, `lifecycle: imported at least 1 artifact (got ${result.artifacts})`);
+      assertTrue(result.decisions === DECISIONS_COUNT, `lifecycle: imported ${result.decisions} decisions, expected ${DECISIONS_COUNT}`);
+      assertTrue(result.requirements === REQUIREMENTS_COUNT, `lifecycle: imported ${result.requirements} requirements, expected ${REQUIREMENTS_COUNT}`);
+      assertTrue(result.artifacts >= 1, `lifecycle: imported at least 1 artifact (got ${result.artifacts})`);
 
       // Verify file-backed DB uses WAL
       const adapter = _getAdapter()!;
       const mode = adapter.prepare('PRAGMA journal_mode').get();
-      assert.deepStrictEqual(mode?.['journal_mode'], 'wal', 'lifecycle: file-backed DB uses WAL mode');
+      assertEq(mode?.['journal_mode'], 'wal', 'lifecycle: file-backed DB uses WAL mode');
 
       // ── Step 3: Scoped queries — decisions by milestone ────────────────
       const allDecisions = queryDecisions();
       const m001Decisions = queryDecisions({ milestoneId: 'M001' });
       const m002Decisions = queryDecisions({ milestoneId: 'M002' });
 
-      assert.ok(allDecisions.length === DECISIONS_COUNT, `lifecycle: all decisions count = ${DECISIONS_COUNT} (got ${allDecisions.length})`);
-      assert.ok(m001Decisions.length > 0, 'lifecycle: M001 decisions non-empty');
-      assert.ok(m002Decisions.length > 0, 'lifecycle: M002 decisions non-empty');
-      assert.ok(m001Decisions.length < allDecisions.length, 'lifecycle: M001 filtered count < total count');
-      assert.ok(m002Decisions.length < allDecisions.length, 'lifecycle: M002 filtered count < total count');
-      assert.deepStrictEqual(m001Decisions.length + m002Decisions.length, allDecisions.length, 'lifecycle: M001 + M002 = total decisions');
+      assertTrue(allDecisions.length === DECISIONS_COUNT, `lifecycle: all decisions count = ${DECISIONS_COUNT} (got ${allDecisions.length})`);
+      assertTrue(m001Decisions.length > 0, 'lifecycle: M001 decisions non-empty');
+      assertTrue(m002Decisions.length > 0, 'lifecycle: M002 decisions non-empty');
+      assertTrue(m001Decisions.length < allDecisions.length, 'lifecycle: M001 filtered count < total count');
+      assertTrue(m002Decisions.length < allDecisions.length, 'lifecycle: M002 filtered count < total count');
+      assertEq(m001Decisions.length + m002Decisions.length, allDecisions.length, 'lifecycle: M001 + M002 = total decisions');
 
       // Verify scoping correctness
       for (const d of m001Decisions) {
-        assert.ok(d.when_context.includes('M001'), `lifecycle: M001 decision ${d.id} has M001 in when_context`);
+        assertTrue(d.when_context.includes('M001'), `lifecycle: M001 decision ${d.id} has M001 in when_context`);
       }
       for (const d of m002Decisions) {
-        assert.ok(d.when_context.includes('M002'), `lifecycle: M002 decision ${d.id} has M002 in when_context`);
+        assertTrue(d.when_context.includes('M002'), `lifecycle: M002 decision ${d.id} has M002 in when_context`);
       }
 
       // ── Step 4: Scoped queries — requirements by slice ─────────────────
@@ -176,19 +180,19 @@ test('integration-lifecycle: full pipeline', async () => {
       const s01Requirements = queryRequirements({ sliceId: 'S01' });
       const s04Requirements = queryRequirements({ sliceId: 'S04' });
 
-      assert.ok(allRequirements.length === REQUIREMENTS_COUNT, `lifecycle: all requirements count = ${REQUIREMENTS_COUNT} (got ${allRequirements.length})`);
-      assert.ok(s01Requirements.length > 0, 'lifecycle: S01 requirements non-empty');
-      assert.ok(s04Requirements.length > 0, 'lifecycle: S04 requirements non-empty');
-      assert.ok(s01Requirements.length < allRequirements.length, 'lifecycle: S01 filtered count < total count');
+      assertTrue(allRequirements.length === REQUIREMENTS_COUNT, `lifecycle: all requirements count = ${REQUIREMENTS_COUNT} (got ${allRequirements.length})`);
+      assertTrue(s01Requirements.length > 0, 'lifecycle: S01 requirements non-empty');
+      assertTrue(s04Requirements.length > 0, 'lifecycle: S04 requirements non-empty');
+      assertTrue(s01Requirements.length < allRequirements.length, 'lifecycle: S01 filtered count < total count');
 
       // ── Step 5: Format + token savings validation ──────────────────────
       const formattedDecisions = formatDecisionsForPrompt(m001Decisions);
       const formattedRequirements = formatRequirementsForPrompt(s01Requirements);
 
-      assert.ok(formattedDecisions.length > 0, 'lifecycle: formatted M001 decisions non-empty');
-      assert.ok(formattedRequirements.length > 0, 'lifecycle: formatted S01 requirements non-empty');
-      assert.match(formattedDecisions, /\| D/, 'lifecycle: formatted decisions contains decision rows');
-      assert.match(formattedRequirements, /### R\d+/, 'lifecycle: formatted requirements has headings');
+      assertTrue(formattedDecisions.length > 0, 'lifecycle: formatted M001 decisions non-empty');
+      assertTrue(formattedRequirements.length > 0, 'lifecycle: formatted S01 requirements non-empty');
+      assertMatch(formattedDecisions, /\| D/, 'lifecycle: formatted decisions contains decision rows');
+      assertMatch(formattedRequirements, /### R\d+/, 'lifecycle: formatted requirements has headings');
 
       // Token savings: scoped output vs full file content
       const fullDecisionsContent = readFileSync(join(gsdDir, 'DECISIONS.md'), 'utf-8');
@@ -199,24 +203,24 @@ test('integration-lifecycle: full pipeline', async () => {
 
       console.log(`  Token savings: ${savingsPercent.toFixed(1)}% (scoped: ${dbScopedTotal}, full: ${fullTotal})`);
 
-      assert.ok(dbScopedTotal > 0, 'lifecycle: scoped content non-empty');
-      assert.ok(dbScopedTotal < fullTotal, 'lifecycle: scoped content smaller than full content');
-      assert.ok(savingsPercent >= 30, `lifecycle: savings ≥30% (actual: ${savingsPercent.toFixed(1)}%)`);
+      assertTrue(dbScopedTotal > 0, 'lifecycle: scoped content non-empty');
+      assertTrue(dbScopedTotal < fullTotal, 'lifecycle: scoped content smaller than full content');
+      assertTrue(savingsPercent >= 30, `lifecycle: savings ≥30% (actual: ${savingsPercent.toFixed(1)}%)`);
 
       // ── Step 6: Simulate content change → re-import ────────────────────
       const newDecisionRow = `| D${DECISIONS_COUNT + 1} | M001/S01 | testing | new decision added after initial import | choice X | rationale Y | yes |`;
       appendFileSync(join(gsdDir, 'DECISIONS.md'), '\n' + newDecisionRow + '\n');
 
       const result2 = migrateFromMarkdown(base);
-      assert.ok(result2.decisions === DECISIONS_COUNT + 1, `lifecycle: re-import got ${result2.decisions} decisions, expected ${DECISIONS_COUNT + 1}`);
+      assertTrue(result2.decisions === DECISIONS_COUNT + 1, `lifecycle: re-import got ${result2.decisions} decisions, expected ${DECISIONS_COUNT + 1}`);
 
       const afterReimport = queryDecisions();
-      assert.ok(afterReimport.length === DECISIONS_COUNT + 1, `lifecycle: DB has ${DECISIONS_COUNT + 1} decisions after re-import (got ${afterReimport.length})`);
+      assertTrue(afterReimport.length === DECISIONS_COUNT + 1, `lifecycle: DB has ${DECISIONS_COUNT + 1} decisions after re-import (got ${afterReimport.length})`);
 
       // Verify the new decision is queryable
       const newM001 = queryDecisions({ milestoneId: 'M001' });
       const foundNew = newM001.some(d => d.id === `D${DECISIONS_COUNT + 1}`);
-      assert.ok(foundNew, `lifecycle: newly imported D${DECISIONS_COUNT + 1} found in M001 scope`);
+      assertTrue(foundNew, `lifecycle: newly imported D${DECISIONS_COUNT + 1} found in M001 scope`);
 
       // ── Step 7: saveDecisionToDb write-back + round-trip ───────────────
       const saved = await saveDecisionToDb(
@@ -230,37 +234,44 @@ test('integration-lifecycle: full pipeline', async () => {
         base,
       );
 
-      assert.ok(typeof saved.id === 'string', 'lifecycle: saveDecisionToDb returned an id');
-      assert.match(saved.id, /^D\d+$/, 'lifecycle: saved ID matches D### pattern');
+      assertTrue(typeof saved.id === 'string', 'lifecycle: saveDecisionToDb returned an id');
+      assertMatch(saved.id, /^D\d+$/, 'lifecycle: saved ID matches D### pattern');
 
       // Query back from DB
       const allAfterSave = queryDecisions();
       const savedDecision = allAfterSave.find(d => d.id === saved.id);
-      assert.ok(savedDecision !== null && savedDecision !== undefined, `lifecycle: saved decision ${saved.id} found in DB`);
-      assert.deepStrictEqual(savedDecision?.decision, 'integration test write-back decision', 'lifecycle: saved decision text matches');
-      assert.deepStrictEqual(savedDecision?.choice, 'option Z', 'lifecycle: saved choice matches');
+      assertTrue(savedDecision !== null && savedDecision !== undefined, `lifecycle: saved decision ${saved.id} found in DB`);
+      assertEq(savedDecision?.decision, 'integration test write-back decision', 'lifecycle: saved decision text matches');
+      assertEq(savedDecision?.choice, 'option Z', 'lifecycle: saved choice matches');
 
       // Verify DECISIONS.md was regenerated with the new decision
       const regeneratedMd = readFileSync(join(gsdDir, 'DECISIONS.md'), 'utf-8');
-      assert.ok(regeneratedMd.includes(saved.id), `lifecycle: regenerated DECISIONS.md contains ${saved.id}`);
-      assert.ok(regeneratedMd.includes('integration test write-back decision'), 'lifecycle: regenerated md contains write-back text');
+      assertTrue(regeneratedMd.includes(saved.id), `lifecycle: regenerated DECISIONS.md contains ${saved.id}`);
+      assertTrue(regeneratedMd.includes('integration test write-back decision'), 'lifecycle: regenerated md contains write-back text');
 
       // Round-trip: parse regenerated markdown back → verify field fidelity
       const reparsed = parseDecisionsTable(regeneratedMd);
       const reparsedSaved = reparsed.find(d => d.id === saved.id);
-      assert.ok(reparsedSaved !== undefined, `lifecycle: reparsed markdown contains ${saved.id}`);
-      assert.deepStrictEqual(reparsedSaved?.choice, 'option Z', 'lifecycle: round-trip choice preserved');
-      assert.deepStrictEqual(reparsedSaved?.rationale, 'proves round-trip fidelity', 'lifecycle: round-trip rationale preserved');
+      assertTrue(reparsedSaved !== undefined, `lifecycle: reparsed markdown contains ${saved.id}`);
+      assertEq(reparsedSaved?.choice, 'option Z', 'lifecycle: round-trip choice preserved');
+      assertEq(reparsedSaved?.rationale, 'proves round-trip fidelity', 'lifecycle: round-trip rationale preserved');
 
       // ── Step 8: DB consistency — total count sanity ─────────────────────
       const finalCount = queryDecisions().length;
       // Original 14 + 1 re-import + 1 saveDecisionToDb = 16
-      assert.ok(finalCount === DECISIONS_COUNT + 2, `lifecycle: final DB count = ${DECISIONS_COUNT + 2} (got ${finalCount})`);
+      assertTrue(finalCount === DECISIONS_COUNT + 2, `lifecycle: final DB count = ${DECISIONS_COUNT + 2} (got ${finalCount})`);
 
       closeDatabase();
     } finally {
       closeDatabase();
       rmSync(base, { recursive: true, force: true });
     }
-});
+  }
 
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});