gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/db-writer.test.ts

@@ -1,5 +1,4 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import * as fs from 'node:fs';
@@ -27,6 +26,8 @@ import {
 } from '../db-writer.ts';
 import type { Decision, Requirement } from '../types.ts';
 
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
@@ -150,433 +151,462 @@ const SAMPLE_REQUIREMENTS: Requirement[] = [
 // Round-Trip Tests: Decisions
 // ═══════════════════════════════════════════════════════════════════════════
 
-describe('db-writer', () => {
-  test('generateDecisionsMd round-trip', () => {
-    const md = generateDecisionsMd(SAMPLE_DECISIONS);
-    const parsed = parseDecisionsTable(md);
-
-    assert.deepStrictEqual(parsed.length, SAMPLE_DECISIONS.length, 'decisions count matches');
-
-    for (let i = 0; i < SAMPLE_DECISIONS.length; i++) {
-      const orig = SAMPLE_DECISIONS[i];
-      const rt = parsed[i];
-      assert.deepStrictEqual(rt.id, orig.id, `decision ${orig.id} id round-trips`);
-      assert.deepStrictEqual(rt.when_context, orig.when_context, `decision ${orig.id} when_context round-trips`);
-      assert.deepStrictEqual(rt.scope, orig.scope, `decision ${orig.id} scope round-trips`);
-      assert.deepStrictEqual(rt.decision, orig.decision, `decision ${orig.id} decision round-trips`);
-      assert.deepStrictEqual(rt.choice, orig.choice, `decision ${orig.id} choice round-trips`);
-      assert.deepStrictEqual(rt.rationale, orig.rationale, `decision ${orig.id} rationale round-trips`);
-      assert.deepStrictEqual(rt.revisable, orig.revisable, `decision ${orig.id} revisable round-trips`);
-      assert.deepStrictEqual(rt.made_by, orig.made_by, `decision ${orig.id} made_by round-trips`);
-    }
-  });
+console.log('\n── generateDecisionsMd round-trip ──');
+
+{
+  const md = generateDecisionsMd(SAMPLE_DECISIONS);
+  const parsed = parseDecisionsTable(md);
+
+  assertEq(parsed.length, SAMPLE_DECISIONS.length, 'decisions count matches');
+
+  for (let i = 0; i < SAMPLE_DECISIONS.length; i++) {
+    const orig = SAMPLE_DECISIONS[i];
+    const rt = parsed[i];
+    assertEq(rt.id, orig.id, `decision ${orig.id} id round-trips`);
+    assertEq(rt.when_context, orig.when_context, `decision ${orig.id} when_context round-trips`);
+    assertEq(rt.scope, orig.scope, `decision ${orig.id} scope round-trips`);
+    assertEq(rt.decision, orig.decision, `decision ${orig.id} decision round-trips`);
+    assertEq(rt.choice, orig.choice, `decision ${orig.id} choice round-trips`);
+    assertEq(rt.rationale, orig.rationale, `decision ${orig.id} rationale round-trips`);
+    assertEq(rt.revisable, orig.revisable, `decision ${orig.id} revisable round-trips`);
+    assertEq(rt.made_by, orig.made_by, `decision ${orig.id} made_by round-trips`);
+  }
+}
 
-  test('generateDecisionsMd format', () => {
-    const md = generateDecisionsMd(SAMPLE_DECISIONS);
-    assert.ok(md.startsWith('# Decisions Register\n'), 'starts with H1 header');
-    assert.ok(md.includes('<!-- Append-only'), 'contains HTML comment block');
-    assert.ok(md.includes('| # | When | Scope'), 'contains table header');
-    assert.ok(md.includes('|---|------|-------'), 'contains separator row');
-    assert.ok(md.includes('| Made By |'), 'contains Made By column header');
-  });
+console.log('\n── generateDecisionsMd format ──');
 
-  test('generateDecisionsMd empty input', () => {
-    const md = generateDecisionsMd([]);
-    const parsed = parseDecisionsTable(md);
-    assert.deepStrictEqual(parsed.length, 0, 'empty decisions produces empty parse');
-    assert.ok(md.includes('| # | When | Scope'), 'still has table header even when empty');
-  });
+{
+  const md = generateDecisionsMd(SAMPLE_DECISIONS);
+  assertTrue(md.startsWith('# Decisions Register\n'), 'starts with H1 header');
+  assertTrue(md.includes('<!-- Append-only'), 'contains HTML comment block');
+  assertTrue(md.includes('| # | When | Scope'), 'contains table header');
+  assertTrue(md.includes('|---|------|-------'), 'contains separator row');
+  assertTrue(md.includes('| Made By |'), 'contains Made By column header');
+}
 
-  test('generateDecisionsMd pipe escaping', () => {
-    const withPipe: Decision = {
-      seq: 1,
-      id: 'D001',
-      when_context: 'M001',
-      scope: 'arch',
-      decision: 'Choice A | Choice B comparison',
-      choice: 'A',
-      rationale: 'Better',
-      revisable: 'No',
-      made_by: 'agent',
-      superseded_by: null,
-    };
-    const md = generateDecisionsMd([withPipe]);
-    // Should not break the table — pipe in decision text should be escaped
-    const parsed = parseDecisionsTable(md);
-    assert.ok(parsed.length >= 1, 'pipe-containing decision parses without breaking table');
-  });
+console.log('\n── generateDecisionsMd empty input ──');
+
+{
+  const md = generateDecisionsMd([]);
+  const parsed = parseDecisionsTable(md);
+  assertEq(parsed.length, 0, 'empty decisions produces empty parse');
+  assertTrue(md.includes('| # | When | Scope'), 'still has table header even when empty');
+}
+
+console.log('\n── generateDecisionsMd pipe escaping ──');
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Round-Trip Tests: Requirements
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  test('generateRequirementsMd round-trip', () => {
-    const md = generateRequirementsMd(SAMPLE_REQUIREMENTS);
-    const parsed = parseRequirementsSections(md);
-
-    assert.deepStrictEqual(parsed.length, SAMPLE_REQUIREMENTS.length, 'requirements count matches');
-
-    for (const orig of SAMPLE_REQUIREMENTS) {
-      const rt = parsed.find(r => r.id === orig.id);
-      assert.ok(!!rt, `requirement ${orig.id} found in parsed output`);
-      if (rt) {
-        assert.deepStrictEqual(rt.class, orig.class, `requirement ${orig.id} class round-trips`);
-        assert.deepStrictEqual(rt.description, orig.description, `requirement ${orig.id} description round-trips`);
-        assert.deepStrictEqual(rt.why, orig.why, `requirement ${orig.id} why round-trips`);
-        assert.deepStrictEqual(rt.source, orig.source, `requirement ${orig.id} source round-trips`);
-        assert.deepStrictEqual(rt.primary_owner, orig.primary_owner, `requirement ${orig.id} primary_owner round-trips`);
-        assert.deepStrictEqual(rt.supporting_slices, orig.supporting_slices, `requirement ${orig.id} supporting_slices round-trips`);
-        if (orig.notes) {
-          assert.deepStrictEqual(rt.notes, orig.notes, `requirement ${orig.id} notes round-trips`);
-        }
+{
+  const withPipe: Decision = {
+    seq: 1,
+    id: 'D001',
+    when_context: 'M001',
+    scope: 'arch',
+    decision: 'Choice A | Choice B comparison',
+    choice: 'A',
+    rationale: 'Better',
+    revisable: 'No',
+    made_by: 'agent',
+    superseded_by: null,
+  };
+  const md = generateDecisionsMd([withPipe]);
+  // Should not break the table — pipe in decision text should be escaped
+  const parsed = parseDecisionsTable(md);
+  assertTrue(parsed.length >= 1, 'pipe-containing decision parses without breaking table');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Round-Trip Tests: Requirements
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── generateRequirementsMd round-trip ──');
+
+{
+  const md = generateRequirementsMd(SAMPLE_REQUIREMENTS);
+  const parsed = parseRequirementsSections(md);
+
+  assertEq(parsed.length, SAMPLE_REQUIREMENTS.length, 'requirements count matches');
+
+  for (const orig of SAMPLE_REQUIREMENTS) {
+    const rt = parsed.find(r => r.id === orig.id);
+    assertTrue(!!rt, `requirement ${orig.id} found in parsed output`);
+    if (rt) {
+      assertEq(rt.class, orig.class, `requirement ${orig.id} class round-trips`);
+      assertEq(rt.description, orig.description, `requirement ${orig.id} description round-trips`);
+      assertEq(rt.why, orig.why, `requirement ${orig.id} why round-trips`);
+      assertEq(rt.source, orig.source, `requirement ${orig.id} source round-trips`);
+      assertEq(rt.primary_owner, orig.primary_owner, `requirement ${orig.id} primary_owner round-trips`);
+      assertEq(rt.supporting_slices, orig.supporting_slices, `requirement ${orig.id} supporting_slices round-trips`);
+      if (orig.notes) {
+        assertEq(rt.notes, orig.notes, `requirement ${orig.id} notes round-trips`);
       }
     }
-  });
+  }
+}
 
-  test('generateRequirementsMd sections', () => {
-    const md = generateRequirementsMd(SAMPLE_REQUIREMENTS);
-    assert.ok(md.includes('## Active'), 'has Active section');
-    assert.ok(md.includes('## Validated'), 'has Validated section');
-    assert.ok(md.includes('## Deferred'), 'has Deferred section');
-    assert.ok(md.includes('## Out of Scope'), 'has Out of Scope section');
-    assert.ok(md.includes('## Traceability'), 'has Traceability section');
-    assert.ok(md.includes('## Coverage Summary'), 'has Coverage Summary section');
-  });
+console.log('\n── generateRequirementsMd sections ──');
 
-  test('generateRequirementsMd only populated sections', () => {
-    // Only active requirements — should only have Active section
-    const activeOnly = SAMPLE_REQUIREMENTS.filter(r => r.status === 'active');
-    const md = generateRequirementsMd(activeOnly);
-    assert.ok(md.includes('## Active'), 'has Active section');
-    assert.ok(!md.includes('## Validated'), 'no Validated section when no validated reqs');
-    assert.ok(!md.includes('## Deferred'), 'no Deferred section when no deferred reqs');
-    assert.ok(!md.includes('## Out of Scope'), 'no Out of Scope section when no out-of-scope reqs');
-  });
+{
+  const md = generateRequirementsMd(SAMPLE_REQUIREMENTS);
+  assertTrue(md.includes('## Active'), 'has Active section');
+  assertTrue(md.includes('## Validated'), 'has Validated section');
+  assertTrue(md.includes('## Deferred'), 'has Deferred section');
+  assertTrue(md.includes('## Out of Scope'), 'has Out of Scope section');
+  assertTrue(md.includes('## Traceability'), 'has Traceability section');
+  assertTrue(md.includes('## Coverage Summary'), 'has Coverage Summary section');
+}
 
-  test('generateRequirementsMd empty input', () => {
-    const md = generateRequirementsMd([]);
-    const parsed = parseRequirementsSections(md);
-    assert.deepStrictEqual(parsed.length, 0, 'empty requirements produces empty parse');
-  });
+console.log('\n── generateRequirementsMd only populated sections ──');
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // nextDecisionId Tests
-  // ═══════════════════════════════════════════════════════════════════════════
+{
+  // Only active requirements — should only have Active section
+  const activeOnly = SAMPLE_REQUIREMENTS.filter(r => r.status === 'active');
+  const md = generateRequirementsMd(activeOnly);
+  assertTrue(md.includes('## Active'), 'has Active section');
+  assertTrue(!md.includes('## Validated'), 'no Validated section when no validated reqs');
+  assertTrue(!md.includes('## Deferred'), 'no Deferred section when no deferred reqs');
+  assertTrue(!md.includes('## Out of Scope'), 'no Out of Scope section when no out-of-scope reqs');
+}
 
-  test('nextDecisionId', async () => {
-    // Open in-memory DB
-    openDatabase(':memory:');
+console.log('\n── generateRequirementsMd empty input ──');
 
-    const id1 = await nextDecisionId();
-    assert.deepStrictEqual(id1, 'D001', 'first ID when no decisions exist');
+{
+  const md = generateRequirementsMd([]);
+  const parsed = parseRequirementsSections(md);
+  assertEq(parsed.length, 0, 'empty requirements produces empty parse');
+}
 
-    // Insert some decisions
-    upsertDecision({
-      id: 'D001',
-      when_context: 'M001',
-      scope: 'test',
-      decision: 'test decision',
-      choice: 'test choice',
-      rationale: 'test',
-      revisable: 'No',
-      made_by: 'agent',
-      superseded_by: null,
-    });
-    upsertDecision({
-      id: 'D005',
-      when_context: 'M001',
-      scope: 'test',
-      decision: 'test decision 5',
-      choice: 'test choice',
-      rationale: 'test',
-      revisable: 'No',
-      made_by: 'agent',
-      superseded_by: null,
-    });
+// ═══════════════════════════════════════════════════════════════════════════
+// nextDecisionId Tests
+// ═══════════════════════════════════════════════════════════════════════════
 
-    const id2 = await nextDecisionId();
-    assert.deepStrictEqual(id2, 'D006', 'next ID after D005 is D006');
+console.log('\n── nextDecisionId ──');
 
-    closeDatabase();
+{
+  // Open in-memory DB
+  openDatabase(':memory:');
+
+  const id1 = await nextDecisionId();
+  assertEq(id1, 'D001', 'first ID when no decisions exist');
+
+  // Insert some decisions
+  upsertDecision({
+    id: 'D001',
+    when_context: 'M001',
+    scope: 'test',
+    decision: 'test decision',
+    choice: 'test choice',
+    rationale: 'test',
+    revisable: 'No',
+    made_by: 'agent',
+    superseded_by: null,
+  });
+  upsertDecision({
+    id: 'D005',
+    when_context: 'M001',
+    scope: 'test',
+    decision: 'test decision 5',
+    choice: 'test choice',
+    rationale: 'test',
+    revisable: 'No',
+    made_by: 'agent',
+    superseded_by: null,
   });
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // saveDecisionToDb Tests
-  // ═══════════════════════════════════════════════════════════════════════════
+  const id2 = await nextDecisionId();
+  assertEq(id2, 'D006', 'next ID after D005 is D006');
 
-  test('saveDecisionToDb', async () => {
-    const tmpDir = makeTmpDir();
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    openDatabase(dbPath);
+  closeDatabase();
+}
 
-    try {
-      const result = await saveDecisionToDb({
-        scope: 'arch',
-        decision: 'Test decision',
-        choice: 'Option A',
-        rationale: 'Best option',
-        when_context: 'M001',
-      }, tmpDir);
-
-      assert.deepStrictEqual(result.id, 'D001', 'saveDecisionToDb returns D001 as first ID');
-
-      // Verify DB state
-      const dbDecision = getDecisionById('D001');
-      assert.ok(!!dbDecision, 'decision exists in DB after save');
-      assert.deepStrictEqual(dbDecision?.scope, 'arch', 'DB decision has correct scope');
-      assert.deepStrictEqual(dbDecision?.choice, 'Option A', 'DB decision has correct choice');
-
-      // Verify markdown file was written
-      const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
-      assert.ok(fs.existsSync(mdPath), 'DECISIONS.md file created');
-
-      const mdContent = fs.readFileSync(mdPath, 'utf-8');
-      assert.ok(mdContent.includes('D001'), 'DECISIONS.md contains new decision ID');
-      assert.ok(mdContent.includes('Test decision'), 'DECISIONS.md contains decision text');
-
-      // Verify round-trip of the written file
-      const parsed = parseDecisionsTable(mdContent);
-      assert.deepStrictEqual(parsed.length, 1, 'written DECISIONS.md parses to 1 decision');
-      assert.deepStrictEqual(parsed[0].id, 'D001', 'parsed decision has correct ID');
-
-      // Add second decision
-      const result2 = await saveDecisionToDb({
-        scope: 'impl',
-        decision: 'Second decision',
-        choice: 'Option B',
-        rationale: 'Also good',
-      }, tmpDir);
-
-      assert.deepStrictEqual(result2.id, 'D002', 'second decision gets D002');
-
-      const mdContent2 = fs.readFileSync(mdPath, 'utf-8');
-      const parsed2 = parseDecisionsTable(mdContent2);
-      assert.deepStrictEqual(parsed2.length, 2, 'DECISIONS.md now has 2 decisions');
-    } finally {
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
+// ═══════════════════════════════════════════════════════════════════════════
+// saveDecisionToDb Tests
+// ═══════════════════════════════════════════════════════════════════════════
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // updateRequirementInDb Tests
-  // ═══════════════════════════════════════════════════════════════════════════
+console.log('\n── saveDecisionToDb ──');
 
-  test('updateRequirementInDb', async () => {
-    const tmpDir = makeTmpDir();
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    openDatabase(dbPath);
+{
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
 
-    try {
-      // Seed a requirement
-      upsertRequirement({
-        id: 'R001',
-        class: 'core-capability',
-        status: 'active',
-        description: 'Test requirement',
-        why: 'Testing',
-        source: 'test',
-        primary_owner: 'M001/S01',
-        supporting_slices: 'none',
-        validation: 'unmapped',
-        notes: '',
-        full_content: '',
-        superseded_by: null,
-      });
-
-      // Update it
-      await updateRequirementInDb('R001', {
-        status: 'validated',
-        validation: 'S01 — all tests pass',
-        notes: 'Validated in S01',
-      }, tmpDir);
-
-      // Verify DB state
-      const updated = getRequirementById('R001');
-      assert.ok(!!updated, 'requirement still exists after update');
-      assert.deepStrictEqual(updated?.status, 'validated', 'status updated in DB');
-      assert.deepStrictEqual(updated?.validation, 'S01 — all tests pass', 'validation updated in DB');
-      assert.deepStrictEqual(updated?.description, 'Test requirement', 'description preserved after update');
-
-      // Verify markdown file was written
-      const mdPath = path.join(tmpDir, '.gsd', 'REQUIREMENTS.md');
-      assert.ok(fs.existsSync(mdPath), 'REQUIREMENTS.md file created');
-
-      const mdContent = fs.readFileSync(mdPath, 'utf-8');
-      assert.ok(mdContent.includes('R001'), 'REQUIREMENTS.md contains requirement ID');
-      assert.ok(mdContent.includes('validated'), 'REQUIREMENTS.md shows updated status');
-
-      // Verify round-trip
-      const parsed = parseRequirementsSections(mdContent);
-      assert.deepStrictEqual(parsed.length, 1, 'parsed 1 requirement from written file');
-      assert.deepStrictEqual(parsed[0].status, 'validated', 'parsed status matches update');
-    } finally {
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
+  try {
+    const result = await saveDecisionToDb({
+      scope: 'arch',
+      decision: 'Test decision',
+      choice: 'Option A',
+      rationale: 'Best option',
+      when_context: 'M001',
+    }, tmpDir);
+
+    assertEq(result.id, 'D001', 'saveDecisionToDb returns D001 as first ID');
+
+    // Verify DB state
+    const dbDecision = getDecisionById('D001');
+    assertTrue(!!dbDecision, 'decision exists in DB after save');
+    assertEq(dbDecision?.scope, 'arch', 'DB decision has correct scope');
+    assertEq(dbDecision?.choice, 'Option A', 'DB decision has correct choice');
+
+    // Verify markdown file was written
+    const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
+    assertTrue(fs.existsSync(mdPath), 'DECISIONS.md file created');
+
+    const mdContent = fs.readFileSync(mdPath, 'utf-8');
+    assertTrue(mdContent.includes('D001'), 'DECISIONS.md contains new decision ID');
+    assertTrue(mdContent.includes('Test decision'), 'DECISIONS.md contains decision text');
+
+    // Verify round-trip of the written file
+    const parsed = parseDecisionsTable(mdContent);
+    assertEq(parsed.length, 1, 'written DECISIONS.md parses to 1 decision');
+    assertEq(parsed[0].id, 'D001', 'parsed decision has correct ID');
+
+    // Add second decision
+    const result2 = await saveDecisionToDb({
+      scope: 'impl',
+      decision: 'Second decision',
+      choice: 'Option B',
+      rationale: 'Also good',
+    }, tmpDir);
+
+    assertEq(result2.id, 'D002', 'second decision gets D002');
+
+    const mdContent2 = fs.readFileSync(mdPath, 'utf-8');
+    const parsed2 = parseDecisionsTable(mdContent2);
+    assertEq(parsed2.length, 2, 'DECISIONS.md now has 2 decisions');
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+}
 
-  test('updateRequirementInDb — not found', async () => {
-    const tmpDir = makeTmpDir();
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    openDatabase(dbPath);
+// ═══════════════════════════════════════════════════════════════════════════
+// updateRequirementInDb Tests
+// ═══════════════════════════════════════════════════════════════════════════
 
-    try {
-      let threw = false;
-      try {
-        await updateRequirementInDb('R999', { status: 'validated' }, tmpDir);
-      } catch (err) {
-        threw = true;
-        assert.ok(
-          (err as Error).message.includes('R999'),
-          'error message mentions the missing ID',
-        );
-      }
-      assert.ok(threw, 'throws when requirement not found');
-    } finally {
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
+console.log('\n── updateRequirementInDb ──');
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // saveArtifactToDb Tests
-  // ═══════════════════════════════════════════════════════════════════════════
+{
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    // Seed a requirement
+    upsertRequirement({
+      id: 'R001',
+      class: 'core-capability',
+      status: 'active',
+      description: 'Test requirement',
+      why: 'Testing',
+      source: 'test',
+      primary_owner: 'M001/S01',
+      supporting_slices: 'none',
+      validation: 'unmapped',
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+
+    // Update it
+    await updateRequirementInDb('R001', {
+      status: 'validated',
+      validation: 'S01 — all tests pass',
+      notes: 'Validated in S01',
+    }, tmpDir);
+
+    // Verify DB state
+    const updated = getRequirementById('R001');
+    assertTrue(!!updated, 'requirement still exists after update');
+    assertEq(updated?.status, 'validated', 'status updated in DB');
+    assertEq(updated?.validation, 'S01 — all tests pass', 'validation updated in DB');
+    assertEq(updated?.description, 'Test requirement', 'description preserved after update');
+
+    // Verify markdown file was written
+    const mdPath = path.join(tmpDir, '.gsd', 'REQUIREMENTS.md');
+    assertTrue(fs.existsSync(mdPath), 'REQUIREMENTS.md file created');
+
+    const mdContent = fs.readFileSync(mdPath, 'utf-8');
+    assertTrue(mdContent.includes('R001'), 'REQUIREMENTS.md contains requirement ID');
+    assertTrue(mdContent.includes('validated'), 'REQUIREMENTS.md shows updated status');
+
+    // Verify round-trip
+    const parsed = parseRequirementsSections(mdContent);
+    assertEq(parsed.length, 1, 'parsed 1 requirement from written file');
+    assertEq(parsed[0].status, 'validated', 'parsed status matches update');
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+}
 
-  test('saveArtifactToDb', async () => {
-    const tmpDir = makeTmpDir();
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    openDatabase(dbPath);
+console.log('\n── updateRequirementInDb — not found ──');
 
+{
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    let threw = false;
     try {
-      const content = '# Task Summary\n\nTest content\n';
-      await saveArtifactToDb({
-        path: 'milestones/M001/slices/S06/tasks/T01-SUMMARY.md',
-        artifact_type: 'SUMMARY',
-        content,
-        milestone_id: 'M001',
-        slice_id: 'S06',
-        task_id: 'T01',
-      }, tmpDir);
-
-      // Verify DB state
-      const adapter = _getAdapter();
-      assert.ok(!!adapter, 'adapter available');
-      const row = adapter!
-        .prepare('SELECT * FROM artifacts WHERE path = ?')
-        .get('milestones/M001/slices/S06/tasks/T01-SUMMARY.md');
-      assert.ok(!!row, 'artifact exists in DB');
-      assert.deepStrictEqual(row!['artifact_type'], 'SUMMARY', 'artifact type correct in DB');
-      assert.deepStrictEqual(row!['milestone_id'], 'M001', 'milestone_id correct in DB');
-      assert.deepStrictEqual(row!['slice_id'], 'S06', 'slice_id correct in DB');
-      assert.deepStrictEqual(row!['task_id'], 'T01', 'task_id correct in DB');
-
-      // Verify file on disk
-      const filePath = path.join(
-        tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S06', 'tasks', 'T01-SUMMARY.md',
+      await updateRequirementInDb('R999', { status: 'validated' }, tmpDir);
+    } catch (err) {
+      threw = true;
+      assertTrue(
+        (err as Error).message.includes('R999'),
+        'error message mentions the missing ID',
       );
-      assert.ok(fs.existsSync(filePath), 'artifact file written to disk');
-      assert.deepStrictEqual(fs.readFileSync(filePath, 'utf-8'), content, 'file content matches');
-    } finally {
-      closeDatabase();
-      cleanupDir(tmpDir);
     }
-  });
+    assertTrue(threw, 'throws when requirement not found');
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+}
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Full Round-Trip: DB → Markdown → Parse → Compare
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  test('Full DB round-trip: decisions', () => {
-    openDatabase(':memory:');
-
-    // Insert via DB
-    for (const d of SAMPLE_DECISIONS) {
-      upsertDecision({
-        id: d.id,
-        when_context: d.when_context,
-        scope: d.scope,
-        decision: d.decision,
-        choice: d.choice,
-        rationale: d.rationale,
-        revisable: d.revisable,
-        made_by: d.made_by,
-        superseded_by: d.superseded_by,
-      });
-    }
+// ═══════════════════════════════════════════════════════════════════════════
+// saveArtifactToDb Tests
+// ═══════════════════════════════════════════════════════════════════════════
 
-    // Generate markdown from DB state
-    const adapter = _getAdapter()!;
-    const rows = adapter.prepare('SELECT * FROM decisions ORDER BY seq').all();
-    const dbDecisions: Decision[] = rows.map(row => ({
-      seq: row['seq'] as number,
-      id: row['id'] as string,
-      when_context: row['when_context'] as string,
-      scope: row['scope'] as string,
-      decision: row['decision'] as string,
-      choice: row['choice'] as string,
-      rationale: row['rationale'] as string,
-      revisable: row['revisable'] as string,
-      made_by: (row['made_by'] as string as import('../types.js').DecisionMadeBy) ?? 'agent',
-      superseded_by: (row['superseded_by'] as string) ?? null,
-    }));
-
-    const md = generateDecisionsMd(dbDecisions);
-    const parsed = parseDecisionsTable(md);
-
-    assert.deepStrictEqual(parsed.length, SAMPLE_DECISIONS.length, 'DB round-trip decision count');
-    for (const orig of SAMPLE_DECISIONS) {
-      const rt = parsed.find(p => p.id === orig.id);
-      assert.ok(!!rt, `DB round-trip: ${orig.id} found`);
-      if (rt) {
-        assert.deepStrictEqual(rt.scope, orig.scope, `DB round-trip: ${orig.id} scope`);
-        assert.deepStrictEqual(rt.choice, orig.choice, `DB round-trip: ${orig.id} choice`);
-      }
-    }
+console.log('\n── saveArtifactToDb ──');
+
+{
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
 
+  try {
+    const content = '# Task Summary\n\nTest content\n';
+    await saveArtifactToDb({
+      path: 'milestones/M001/slices/S06/tasks/T01-SUMMARY.md',
+      artifact_type: 'SUMMARY',
+      content,
+      milestone_id: 'M001',
+      slice_id: 'S06',
+      task_id: 'T01',
+    }, tmpDir);
+
+    // Verify DB state
+    const adapter = _getAdapter();
+    assertTrue(!!adapter, 'adapter available');
+    const row = adapter!
+      .prepare('SELECT * FROM artifacts WHERE path = ?')
+      .get('milestones/M001/slices/S06/tasks/T01-SUMMARY.md');
+    assertTrue(!!row, 'artifact exists in DB');
+    assertEq(row!['artifact_type'], 'SUMMARY', 'artifact type correct in DB');
+    assertEq(row!['milestone_id'], 'M001', 'milestone_id correct in DB');
+    assertEq(row!['slice_id'], 'S06', 'slice_id correct in DB');
+    assertEq(row!['task_id'], 'T01', 'task_id correct in DB');
+
+    // Verify file on disk
+    const filePath = path.join(
+      tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S06', 'tasks', 'T01-SUMMARY.md',
+    );
+    assertTrue(fs.existsSync(filePath), 'artifact file written to disk');
+    assertEq(fs.readFileSync(filePath, 'utf-8'), content, 'file content matches');
+  } finally {
     closeDatabase();
-  });
+    cleanupDir(tmpDir);
+  }
+}
 
-  test('Full DB round-trip: requirements', () => {
-    openDatabase(':memory:');
+// ═══════════════════════════════════════════════════════════════════════════
+// Full Round-Trip: DB → Markdown → Parse → Compare
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Full DB round-trip: decisions ──');
+
+{
+  openDatabase(':memory:');
 
-    for (const r of SAMPLE_REQUIREMENTS) {
-      upsertRequirement(r);
+  // Insert via DB
+  for (const d of SAMPLE_DECISIONS) {
+    upsertDecision({
+      id: d.id,
+      when_context: d.when_context,
+      scope: d.scope,
+      decision: d.decision,
+      choice: d.choice,
+      rationale: d.rationale,
+      revisable: d.revisable,
+      made_by: d.made_by,
+      superseded_by: d.superseded_by,
+    });
+  }
+
+  // Generate markdown from DB state
+  const adapter = _getAdapter()!;
+  const rows = adapter.prepare('SELECT * FROM decisions ORDER BY seq').all();
+  const dbDecisions: Decision[] = rows.map(row => ({
+    seq: row['seq'] as number,
+    id: row['id'] as string,
+    when_context: row['when_context'] as string,
+    scope: row['scope'] as string,
+    decision: row['decision'] as string,
+    choice: row['choice'] as string,
+    rationale: row['rationale'] as string,
+    revisable: row['revisable'] as string,
+    made_by: (row['made_by'] as string as import('../types.js').DecisionMadeBy) ?? 'agent',
+    superseded_by: (row['superseded_by'] as string) ?? null,
+  }));
+
+  const md = generateDecisionsMd(dbDecisions);
+  const parsed = parseDecisionsTable(md);
+
+  assertEq(parsed.length, SAMPLE_DECISIONS.length, 'DB round-trip decision count');
+  for (const orig of SAMPLE_DECISIONS) {
+    const rt = parsed.find(p => p.id === orig.id);
+    assertTrue(!!rt, `DB round-trip: ${orig.id} found`);
+    if (rt) {
+      assertEq(rt.scope, orig.scope, `DB round-trip: ${orig.id} scope`);
+      assertEq(rt.choice, orig.choice, `DB round-trip: ${orig.id} choice`);
     }
+  }
 
-    const adapter = _getAdapter()!;
-    const rows = adapter.prepare('SELECT * FROM requirements ORDER BY id').all();
-    const dbReqs: Requirement[] = rows.map(row => ({
-      id: row['id'] as string,
-      class: row['class'] as string,
-      status: row['status'] as string,
-      description: row['description'] as string,
-      why: row['why'] as string,
-      source: row['source'] as string,
-      primary_owner: row['primary_owner'] as string,
-      supporting_slices: row['supporting_slices'] as string,
-      validation: row['validation'] as string,
-      notes: row['notes'] as string,
-      full_content: row['full_content'] as string,
-      superseded_by: (row['superseded_by'] as string) ?? null,
-    }));
-
-    const md = generateRequirementsMd(dbReqs);
-    const parsed = parseRequirementsSections(md);
-
-    assert.deepStrictEqual(parsed.length, SAMPLE_REQUIREMENTS.length, 'DB round-trip requirement count');
-    for (const orig of SAMPLE_REQUIREMENTS) {
-      const rt = parsed.find(p => p.id === orig.id);
-      assert.ok(!!rt, `DB round-trip: ${orig.id} found`);
-      if (rt) {
-        assert.deepStrictEqual(rt.class, orig.class, `DB round-trip: ${orig.id} class`);
-        assert.deepStrictEqual(rt.description, orig.description, `DB round-trip: ${orig.id} description`);
-      }
+  closeDatabase();
+}
+
+console.log('\n── Full DB round-trip: requirements ──');
+
+{
+  openDatabase(':memory:');
+
+  for (const r of SAMPLE_REQUIREMENTS) {
+    upsertRequirement(r);
+  }
+
+  const adapter = _getAdapter()!;
+  const rows = adapter.prepare('SELECT * FROM requirements ORDER BY id').all();
+  const dbReqs: Requirement[] = rows.map(row => ({
+    id: row['id'] as string,
+    class: row['class'] as string,
+    status: row['status'] as string,
+    description: row['description'] as string,
+    why: row['why'] as string,
+    source: row['source'] as string,
+    primary_owner: row['primary_owner'] as string,
+    supporting_slices: row['supporting_slices'] as string,
+    validation: row['validation'] as string,
+    notes: row['notes'] as string,
+    full_content: row['full_content'] as string,
+    superseded_by: (row['superseded_by'] as string) ?? null,
+  }));
+
+  const md = generateRequirementsMd(dbReqs);
+  const parsed = parseRequirementsSections(md);
+
+  assertEq(parsed.length, SAMPLE_REQUIREMENTS.length, 'DB round-trip requirement count');
+  for (const orig of SAMPLE_REQUIREMENTS) {
+    const rt = parsed.find(p => p.id === orig.id);
+    assertTrue(!!rt, `DB round-trip: ${orig.id} found`);
+    if (rt) {
+      assertEq(rt.class, orig.class, `DB round-trip: ${orig.id} class`);
+      assertEq(rt.description, orig.description, `DB round-trip: ${orig.id} description`);
     }
+  }
 
-    closeDatabase();
-  });
+  closeDatabase();
+}
 
-  // ═══════════════════════════════════════════════════════════════════════════
+// ═══════════════════════════════════════════════════════════════════════════
 
-});
+report();