gsd-pi 2.44.0-dev.62b5d6c → 2.44.0-dev.a5271fc

package/src/resources/extensions/gsd/tests/context-store.test.ts

@@ -1,4 +1,5 @@
-import { createTestContext } from './test-helpers.ts';
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
 import {
   openDatabase,
   closeDatabase,
@@ -16,452 +17,438 @@ import {
   queryProject,
 } from '../context-store.ts';
 
-const { assertEq, assertTrue, assertMatch, report } = createTestContext();
-
 // ═══════════════════════════════════════════════════════════════════════════
 // context-store: fallback when DB not open
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== context-store: fallback returns empty when DB not open ===');
-{
-  closeDatabase();
-  assertTrue(!isDbAvailable(), 'DB should not be available');
+describe("context-store: fallback when DB not open", () => {
+  test("returns empty when DB not open", () => {
+    closeDatabase();
+    assert.ok(!isDbAvailable(), 'DB should not be available');
 
-  const d = queryDecisions();
-  assertEq(d, [], 'queryDecisions returns [] when DB closed');
+    const d = queryDecisions();
+    assert.deepStrictEqual(d, [], 'queryDecisions returns [] when DB closed');
 
-  const r = queryRequirements();
-  assertEq(r, [], 'queryRequirements returns [] when DB closed');
+    const r = queryRequirements();
+    assert.deepStrictEqual(r, [], 'queryRequirements returns [] when DB closed');
 
-  const df = queryDecisions({ milestoneId: 'M001' });
-  assertEq(df, [], 'queryDecisions with opts returns [] when DB closed');
+    const df = queryDecisions({ milestoneId: 'M001' });
+    assert.deepStrictEqual(df, [], 'queryDecisions with opts returns [] when DB closed');
 
-  const rf = queryRequirements({ sliceId: 'S01' });
-  assertEq(rf, [], 'queryRequirements with opts returns [] when DB closed');
-}
+    const rf = queryRequirements({ sliceId: 'S01' });
+    assert.deepStrictEqual(rf, [], 'queryRequirements with opts returns [] when DB closed');
+  });
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // context-store: query decisions
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== context-store: query all active decisions ===');
-{
-  openDatabase(':memory:');
+describe("context-store: query decisions", () => {
+  afterEach(() => closeDatabase());
 
-  insertDecision({
-    id: 'D001', when_context: 'M001/S01', scope: 'architecture',
-    decision: 'use SQLite', choice: 'node:sqlite', rationale: 'built-in',
-    revisable: 'yes', made_by: 'agent', superseded_by: 'D003', // superseded!
-  });
-  insertDecision({
-    id: 'D002', when_context: 'M001/S01', scope: 'architecture',
-    decision: 'use WAL mode', choice: 'WAL', rationale: 'concurrent reads',
-    revisable: 'no', made_by: 'agent', superseded_by: null,
-  });
-  insertDecision({
-    id: 'D003', when_context: 'M002/S01', scope: 'performance',
-    decision: 'use better-sqlite3', choice: 'better-sqlite3', rationale: 'faster',
-    revisable: 'yes', made_by: 'agent', superseded_by: null,
-  });
+  test("query all active decisions", () => {
+    openDatabase(':memory:');
 
-  const all = queryDecisions();
-  assertEq(all.length, 2, 'query all active decisions returns 2 (superseded excluded)');
-  const ids = all.map(d => d.id);
-  assertTrue(ids.includes('D002'), 'D002 should be in active results');
-  assertTrue(ids.includes('D003'), 'D003 should be in active results');
-  assertTrue(!ids.includes('D001'), 'D001 (superseded) should NOT be in active results');
-
-  closeDatabase();
-}
-
-console.log('\n=== context-store: query decisions by milestone ===');
-{
-  openDatabase(':memory:');
-
-  insertDecision({
-    id: 'D001', when_context: 'M001/S01', scope: 'architecture',
-    decision: 'decision A', choice: 'A', rationale: 'r', revisable: 'yes',
-    made_by: 'agent',
-    superseded_by: null,
-  });
-  insertDecision({
-    id: 'D002', when_context: 'M002/S02', scope: 'architecture',
-    decision: 'decision B', choice: 'B', rationale: 'r', revisable: 'yes',
-    made_by: 'agent',
-    superseded_by: null,
-  });
+    insertDecision({
+      id: 'D001', when_context: 'M001/S01', scope: 'architecture',
+      decision: 'use SQLite', choice: 'node:sqlite', rationale: 'built-in',
+      revisable: 'yes', made_by: 'agent', superseded_by: 'D003', // superseded!
+    });
+    insertDecision({
+      id: 'D002', when_context: 'M001/S01', scope: 'architecture',
+      decision: 'use WAL mode', choice: 'WAL', rationale: 'concurrent reads',
+      revisable: 'no', made_by: 'agent', superseded_by: null,
+    });
+    insertDecision({
+      id: 'D003', when_context: 'M002/S01', scope: 'performance',
+      decision: 'use better-sqlite3', choice: 'better-sqlite3', rationale: 'faster',
+      revisable: 'yes', made_by: 'agent', superseded_by: null,
+    });
 
-  const m1 = queryDecisions({ milestoneId: 'M001' });
-  assertEq(m1.length, 1, 'milestone filter M001 returns 1');
-  assertEq(m1[0]?.id, 'D001', 'milestone filter returns D001');
+    const all = queryDecisions();
+    assert.strictEqual(all.length, 2, 'query all active decisions returns 2 (superseded excluded)');
+    const ids = all.map(d => d.id);
+    assert.ok(ids.includes('D002'), 'D002 should be in active results');
+    assert.ok(ids.includes('D003'), 'D003 should be in active results');
+    assert.ok(!ids.includes('D001'), 'D001 (superseded) should NOT be in active results');
+  });
 
-  const m2 = queryDecisions({ milestoneId: 'M002' });
-  assertEq(m2.length, 1, 'milestone filter M002 returns 1');
-  assertEq(m2[0]?.id, 'D002', 'milestone filter returns D002');
+  test("query decisions by milestone", () => {
+    openDatabase(':memory:');
 
-  closeDatabase();
-}
+    insertDecision({
+      id: 'D001', when_context: 'M001/S01', scope: 'architecture',
+      decision: 'decision A', choice: 'A', rationale: 'r', revisable: 'yes',
+      made_by: 'agent',
+      superseded_by: null,
+    });
+    insertDecision({
+      id: 'D002', when_context: 'M002/S02', scope: 'architecture',
+      decision: 'decision B', choice: 'B', rationale: 'r', revisable: 'yes',
+      made_by: 'agent',
+      superseded_by: null,
+    });
 
-console.log('\n=== context-store: query decisions by scope ===');
-{
-  openDatabase(':memory:');
+    const m1 = queryDecisions({ milestoneId: 'M001' });
+    assert.strictEqual(m1.length, 1, 'milestone filter M001 returns 1');
+    assert.strictEqual(m1[0]?.id, 'D001', 'milestone filter returns D001');
 
-  insertDecision({
-    id: 'D001', when_context: 'M001/S01', scope: 'architecture',
-    decision: 'decision A', choice: 'A', rationale: 'r', revisable: 'yes',
-    made_by: 'agent',
-    superseded_by: null,
-  });
-  insertDecision({
-    id: 'D002', when_context: 'M001/S01', scope: 'performance',
-    decision: 'decision B', choice: 'B', rationale: 'r', revisable: 'yes',
-    made_by: 'agent',
-    superseded_by: null,
+    const m2 = queryDecisions({ milestoneId: 'M002' });
+    assert.strictEqual(m2.length, 1, 'milestone filter M002 returns 1');
+    assert.strictEqual(m2[0]?.id, 'D002', 'milestone filter returns D002');
   });
 
-  const arch = queryDecisions({ scope: 'architecture' });
-  assertEq(arch.length, 1, 'scope filter architecture returns 1');
-  assertEq(arch[0]?.id, 'D001', 'scope filter returns D001');
+  test("query decisions by scope", () => {
+    openDatabase(':memory:');
+
+    insertDecision({
+      id: 'D001', when_context: 'M001/S01', scope: 'architecture',
+      decision: 'decision A', choice: 'A', rationale: 'r', revisable: 'yes',
+      made_by: 'agent',
+      superseded_by: null,
+    });
+    insertDecision({
+      id: 'D002', when_context: 'M001/S01', scope: 'performance',
+      decision: 'decision B', choice: 'B', rationale: 'r', revisable: 'yes',
+      made_by: 'agent',
+      superseded_by: null,
+    });
 
-  const perf = queryDecisions({ scope: 'performance' });
-  assertEq(perf.length, 1, 'scope filter performance returns 1');
-  assertEq(perf[0]?.id, 'D002', 'scope filter returns D002');
+    const arch = queryDecisions({ scope: 'architecture' });
+    assert.strictEqual(arch.length, 1, 'scope filter architecture returns 1');
+    assert.strictEqual(arch[0]?.id, 'D001', 'scope filter returns D001');
 
-  const none = queryDecisions({ scope: 'nonexistent' });
-  assertEq(none.length, 0, 'scope filter nonexistent returns 0');
+    const perf = queryDecisions({ scope: 'performance' });
+    assert.strictEqual(perf.length, 1, 'scope filter performance returns 1');
+    assert.strictEqual(perf[0]?.id, 'D002', 'scope filter returns D002');
 
-  closeDatabase();
-}
+    const none = queryDecisions({ scope: 'nonexistent' });
+    assert.strictEqual(none.length, 0, 'scope filter nonexistent returns 0');
+  });
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // context-store: query requirements
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== context-store: query all active requirements ===');
-{
-  openDatabase(':memory:');
+describe("context-store: query requirements", () => {
+  afterEach(() => closeDatabase());
 
-  insertRequirement({
-    id: 'R001', class: 'functional', status: 'active',
-    description: 'req A', why: 'w', source: 'M001', primary_owner: 'S01',
-    supporting_slices: 'S02', validation: 'v', notes: '', full_content: '',
-    superseded_by: 'R003', // superseded!
-  });
-  insertRequirement({
-    id: 'R002', class: 'non-functional', status: 'active',
-    description: 'req B', why: 'w', source: 'M001', primary_owner: 'S01',
-    supporting_slices: '', validation: 'v', notes: '', full_content: '',
-    superseded_by: null,
-  });
-  insertRequirement({
-    id: 'R003', class: 'functional', status: 'validated',
-    description: 'req C', why: 'w', source: 'M001', primary_owner: 'S02',
-    supporting_slices: 'S01', validation: 'v', notes: '', full_content: '',
-    superseded_by: null,
-  });
+  test("query all active requirements", () => {
+    openDatabase(':memory:');
 
-  const all = queryRequirements();
-  assertEq(all.length, 2, 'query all active requirements returns 2 (superseded excluded)');
-  const ids = all.map(r => r.id);
-  assertTrue(ids.includes('R002'), 'R002 should be active');
-  assertTrue(ids.includes('R003'), 'R003 should be active');
-  assertTrue(!ids.includes('R001'), 'R001 (superseded) should NOT be active');
-
-  closeDatabase();
-}
-
-console.log('\n=== context-store: query requirements by slice ===');
-{
-  openDatabase(':memory:');
-
-  insertRequirement({
-    id: 'R001', class: 'functional', status: 'active',
-    description: 'req A', why: 'w', source: 'M001', primary_owner: 'S01',
-    supporting_slices: '', validation: 'v', notes: '', full_content: '',
-    superseded_by: null,
-  });
-  insertRequirement({
-    id: 'R002', class: 'functional', status: 'active',
-    description: 'req B', why: 'w', source: 'M001', primary_owner: 'S02',
-    supporting_slices: 'S01', validation: 'v', notes: '', full_content: '',
-    superseded_by: null,
-  });
-  insertRequirement({
-    id: 'R003', class: 'functional', status: 'active',
-    description: 'req C', why: 'w', source: 'M001', primary_owner: 'S03',
-    supporting_slices: '', validation: 'v', notes: '', full_content: '',
-    superseded_by: null,
-  });
+    insertRequirement({
+      id: 'R001', class: 'functional', status: 'active',
+      description: 'req A', why: 'w', source: 'M001', primary_owner: 'S01',
+      supporting_slices: 'S02', validation: 'v', notes: '', full_content: '',
+      superseded_by: 'R003', // superseded!
+    });
+    insertRequirement({
+      id: 'R002', class: 'non-functional', status: 'active',
+      description: 'req B', why: 'w', source: 'M001', primary_owner: 'S01',
+      supporting_slices: '', validation: 'v', notes: '', full_content: '',
+      superseded_by: null,
+    });
+    insertRequirement({
+      id: 'R003', class: 'functional', status: 'validated',
+      description: 'req C', why: 'w', source: 'M001', primary_owner: 'S02',
+      supporting_slices: 'S01', validation: 'v', notes: '', full_content: '',
+      superseded_by: null,
+    });
 
-  const s01 = queryRequirements({ sliceId: 'S01' });
-  assertEq(s01.length, 2, 'slice filter S01 returns 2 (primary + supporting)');
-  const s01ids = s01.map(r => r.id).sort();
-  assertEq(s01ids, ['R001', 'R002'], 'S01 owns R001 and supports R002');
+    const all = queryRequirements();
+    assert.strictEqual(all.length, 2, 'query all active requirements returns 2 (superseded excluded)');
+    const ids = all.map(r => r.id);
+    assert.ok(ids.includes('R002'), 'R002 should be active');
+    assert.ok(ids.includes('R003'), 'R003 should be active');
+    assert.ok(!ids.includes('R001'), 'R001 (superseded) should NOT be active');
+  });
 
-  const s03 = queryRequirements({ sliceId: 'S03' });
-  assertEq(s03.length, 1, 'slice filter S03 returns 1');
-  assertEq(s03[0]?.id, 'R003', 'S03 owns R003');
+  test("query requirements by slice", () => {
+    openDatabase(':memory:');
 
-  closeDatabase();
-}
+    insertRequirement({
+      id: 'R001', class: 'functional', status: 'active',
+      description: 'req A', why: 'w', source: 'M001', primary_owner: 'S01',
+      supporting_slices: '', validation: 'v', notes: '', full_content: '',
+      superseded_by: null,
+    });
+    insertRequirement({
+      id: 'R002', class: 'functional', status: 'active',
+      description: 'req B', why: 'w', source: 'M001', primary_owner: 'S02',
+      supporting_slices: 'S01', validation: 'v', notes: '', full_content: '',
+      superseded_by: null,
+    });
+    insertRequirement({
+      id: 'R003', class: 'functional', status: 'active',
+      description: 'req C', why: 'w', source: 'M001', primary_owner: 'S03',
+      supporting_slices: '', validation: 'v', notes: '', full_content: '',
+      superseded_by: null,
+    });
 
-console.log('\n=== context-store: query requirements by status ===');
-{
-  openDatabase(':memory:');
+    const s01 = queryRequirements({ sliceId: 'S01' });
+    assert.strictEqual(s01.length, 2, 'slice filter S01 returns 2 (primary + supporting)');
+    const s01ids = s01.map(r => r.id).sort();
+    assert.deepStrictEqual(s01ids, ['R001', 'R002'], 'S01 owns R001 and supports R002');
 
-  insertRequirement({
-    id: 'R001', class: 'functional', status: 'active',
-    description: 'req A', why: 'w', source: 'M001', primary_owner: 'S01',
-    supporting_slices: '', validation: 'v', notes: '', full_content: '',
-    superseded_by: null,
-  });
-  insertRequirement({
-    id: 'R002', class: 'functional', status: 'validated',
-    description: 'req B', why: 'w', source: 'M001', primary_owner: 'S01',
-    supporting_slices: '', validation: 'v', notes: '', full_content: '',
-    superseded_by: null,
-  });
-  insertRequirement({
-    id: 'R003', class: 'functional', status: 'deferred',
-    description: 'req C', why: 'w', source: 'M001', primary_owner: 'S01',
-    supporting_slices: '', validation: 'v', notes: '', full_content: '',
-    superseded_by: null,
+    const s03 = queryRequirements({ sliceId: 'S03' });
+    assert.strictEqual(s03.length, 1, 'slice filter S03 returns 1');
+    assert.strictEqual(s03[0]?.id, 'R003', 'S03 owns R003');
   });
 
-  const active = queryRequirements({ status: 'active' });
-  assertEq(active.length, 1, 'status filter active returns 1');
-  assertEq(active[0]?.id, 'R001', 'active returns R001');
+  test("query requirements by status", () => {
+    openDatabase(':memory:');
+
+    insertRequirement({
+      id: 'R001', class: 'functional', status: 'active',
+      description: 'req A', why: 'w', source: 'M001', primary_owner: 'S01',
+      supporting_slices: '', validation: 'v', notes: '', full_content: '',
+      superseded_by: null,
+    });
+    insertRequirement({
+      id: 'R002', class: 'functional', status: 'validated',
+      description: 'req B', why: 'w', source: 'M001', primary_owner: 'S01',
+      supporting_slices: '', validation: 'v', notes: '', full_content: '',
+      superseded_by: null,
+    });
+    insertRequirement({
+      id: 'R003', class: 'functional', status: 'deferred',
+      description: 'req C', why: 'w', source: 'M001', primary_owner: 'S01',
+      supporting_slices: '', validation: 'v', notes: '', full_content: '',
+      superseded_by: null,
+    });
 
-  const validated = queryRequirements({ status: 'validated' });
-  assertEq(validated.length, 1, 'status filter validated returns 1');
-  assertEq(validated[0]?.id, 'R002', 'validated returns R002');
+    const active = queryRequirements({ status: 'active' });
+    assert.strictEqual(active.length, 1, 'status filter active returns 1');
+    assert.strictEqual(active[0]?.id, 'R001', 'active returns R001');
 
-  closeDatabase();
-}
+    const validated = queryRequirements({ status: 'validated' });
+    assert.strictEqual(validated.length, 1, 'status filter validated returns 1');
+    assert.strictEqual(validated[0]?.id, 'R002', 'validated returns R002');
+  });
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // context-store: format decisions
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== context-store: formatDecisionsForPrompt ===');
-{
-  const empty = formatDecisionsForPrompt([]);
-  assertEq(empty, '', 'empty input returns empty string');
+describe("context-store: formatDecisionsForPrompt", () => {
+  test("empty input returns empty string", () => {
+    const empty = formatDecisionsForPrompt([]);
+    assert.strictEqual(empty, '', 'empty input returns empty string');
+  });
 
-  const result = formatDecisionsForPrompt([
-    {
-      seq: 1, id: 'D001', when_context: 'M001/S01', scope: 'architecture',
-      decision: 'use SQLite', choice: 'node:sqlite', rationale: 'built-in',
-      revisable: 'yes', made_by: 'agent', superseded_by: null,
-    },
-    {
-      seq: 2, id: 'D002', when_context: 'M001/S02', scope: 'performance',
-      decision: 'use WAL', choice: 'WAL', rationale: 'concurrent',
-      revisable: 'no', made_by: 'human', superseded_by: null,
-    },
-  ]);
-
-  // Should be a markdown table
-  assertMatch(result, /^\| # \| When \| Scope/, 'has table header');
-  assertMatch(result, /\|---\|/, 'has separator row');
-  assertMatch(result, /\| D001 \|/, 'has D001 row');
-  assertMatch(result, /\| D002 \|/, 'has D002 row');
-  const lines = result.split('\n');
-  assertEq(lines.length, 4, 'table has 4 lines (header + separator + 2 rows)');
-}
+  test("formats decisions as markdown table", () => {
+    const result = formatDecisionsForPrompt([
+      {
+        seq: 1, id: 'D001', when_context: 'M001/S01', scope: 'architecture',
+        decision: 'use SQLite', choice: 'node:sqlite', rationale: 'built-in',
+        revisable: 'yes', made_by: 'agent', superseded_by: null,
+      },
+      {
+        seq: 2, id: 'D002', when_context: 'M001/S02', scope: 'performance',
+        decision: 'use WAL', choice: 'WAL', rationale: 'concurrent',
+        revisable: 'no', made_by: 'human', superseded_by: null,
+      },
+    ]);
+
+    // Should be a markdown table
+    assert.match(result, /^\| # \| When \| Scope/, 'has table header');
+    assert.match(result, /\|---\|/, 'has separator row');
+    assert.match(result, /\| D001 \|/, 'has D001 row');
+    assert.match(result, /\| D002 \|/, 'has D002 row');
+    const lines = result.split('\n');
+    assert.strictEqual(lines.length, 4, 'table has 4 lines (header + separator + 2 rows)');
+  });
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // context-store: format requirements
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== context-store: formatRequirementsForPrompt ===');
-{
-  const empty = formatRequirementsForPrompt([]);
-  assertEq(empty, '', 'empty input returns empty string');
+describe("context-store: formatRequirementsForPrompt", () => {
+  test("empty input returns empty string", () => {
+    const empty = formatRequirementsForPrompt([]);
+    assert.strictEqual(empty, '', 'empty input returns empty string');
+  });
 
-  const result = formatRequirementsForPrompt([
-    {
-      id: 'R001', class: 'functional', status: 'active',
-      description: 'System must persist decisions', why: 'agent memory',
-      source: 'M001', primary_owner: 'S01', supporting_slices: 'S02',
-      validation: 'roundtrip test', notes: 'high priority',
-      full_content: '', superseded_by: null,
-    },
-    {
-      id: 'R002', class: 'non-functional', status: 'active',
-      description: 'Sub-5ms query latency', why: 'prompt injection speed',
-      source: 'M001', primary_owner: 'S01', supporting_slices: '',
-      validation: 'timing test', notes: '',
-      full_content: '', superseded_by: null,
-    },
-  ]);
-
-  assertMatch(result, /### R001: System must persist decisions/, 'has R001 section header');
-  assertMatch(result, /### R002: Sub-5ms query latency/, 'has R002 section header');
-  assertMatch(result, /\*\*Class:\*\* functional/, 'has class field');
-  assertMatch(result, /\*\*Status:\*\* active/, 'has status field');
-  assertMatch(result, /\*\*Supporting Slices:\*\* S02/, 'has supporting slices when present');
-  // R002 has no supporting_slices — should not have that line
-  // R002 has no notes — should not have notes line
-  const r002Section = result.split('### R002')[1] || '';
-  assertTrue(!r002Section.includes('**Supporting Slices:**'), 'no supporting slices line when empty');
-  assertTrue(!r002Section.includes('**Notes:**'), 'no notes line when empty');
-}
+  test("formats requirements as markdown sections", () => {
+    const result = formatRequirementsForPrompt([
+      {
+        id: 'R001', class: 'functional', status: 'active',
+        description: 'System must persist decisions', why: 'agent memory',
+        source: 'M001', primary_owner: 'S01', supporting_slices: 'S02',
+        validation: 'roundtrip test', notes: 'high priority',
+        full_content: '', superseded_by: null,
+      },
+      {
+        id: 'R002', class: 'non-functional', status: 'active',
+        description: 'Sub-5ms query latency', why: 'prompt injection speed',
+        source: 'M001', primary_owner: 'S01', supporting_slices: '',
+        validation: 'timing test', notes: '',
+        full_content: '', superseded_by: null,
+      },
+    ]);
+
+    assert.match(result, /### R001: System must persist decisions/, 'has R001 section header');
+    assert.match(result, /### R002: Sub-5ms query latency/, 'has R002 section header');
+    assert.match(result, /\*\*Class:\*\* functional/, 'has class field');
+    assert.match(result, /\*\*Status:\*\* active/, 'has status field');
+    assert.match(result, /\*\*Supporting Slices:\*\* S02/, 'has supporting slices when present');
+    // R002 has no supporting_slices — should not have that line
+    // R002 has no notes — should not have notes line
+    const r002Section = result.split('### R002')[1] || '';
+    assert.ok(!r002Section.includes('**Supporting Slices:**'), 'no supporting slices line when empty');
+    assert.ok(!r002Section.includes('**Notes:**'), 'no notes line when empty');
+  });
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // context-store: sub-5ms timing assertion
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== context-store: sub-5ms query timing ===');
-{
-  openDatabase(':memory:');
-
-  // Insert 50 decisions
-  for (let i = 1; i <= 50; i++) {
-    const id = `D${String(i).padStart(3, '0')}`;
-    insertDecision({
-      id,
-      when_context: `M00${(i % 3) + 1}/S0${(i % 5) + 1}`,
-      scope: i % 2 === 0 ? 'architecture' : 'performance',
-      decision: `decision ${i}`,
-      choice: `choice ${i}`,
-      rationale: `rationale ${i}`,
-      revisable: i % 3 === 0 ? 'no' : 'yes',
-      made_by: 'agent',
-      superseded_by: null,
-    });
-  }
-
-  // Insert 50 requirements
-  for (let i = 1; i <= 50; i++) {
-    const id = `R${String(i).padStart(3, '0')}`;
-    insertRequirement({
-      id,
-      class: i % 2 === 0 ? 'functional' : 'non-functional',
-      status: i % 4 === 0 ? 'validated' : 'active',
-      description: `requirement ${i}`,
-      why: `why ${i}`,
-      source: 'M001',
-      primary_owner: `S0${(i % 5) + 1}`,
-      supporting_slices: i % 3 === 0 ? 'S01, S02' : '',
-      validation: `validation ${i}`,
-      notes: '',
-      full_content: '',
-      superseded_by: null,
-    });
-  }
-
-  // Time the queries — warm up first
-  queryDecisions();
-  queryRequirements();
-
-  const start = performance.now();
-  const decisions = queryDecisions();
-  const requirements = queryRequirements();
-  const elapsed = performance.now() - start;
-
-  assertTrue(decisions.length === 50, `got ${decisions.length} decisions (expected 50)`);
-  assertTrue(requirements.length === 50, `got ${requirements.length} requirements (expected 50)`);
-  assertTrue(elapsed < 5, `query latency ${elapsed.toFixed(2)}ms should be < 5ms`);
-  console.log(`  timing: ${elapsed.toFixed(2)}ms for 50+50 row queries`);
-
-  closeDatabase();
-}
+describe("context-store: sub-5ms query timing", () => {
+  afterEach(() => closeDatabase());
+
+  test("queries complete under 5ms for 50+50 rows", () => {
+    openDatabase(':memory:');
+
+    // Insert 50 decisions
+    for (let i = 1; i <= 50; i++) {
+      const id = `D${String(i).padStart(3, '0')}`;
+      insertDecision({
+        id,
+        when_context: `M00${(i % 3) + 1}/S0${(i % 5) + 1}`,
+        scope: i % 2 === 0 ? 'architecture' : 'performance',
+        decision: `decision ${i}`,
+        choice: `choice ${i}`,
+        rationale: `rationale ${i}`,
+        revisable: i % 3 === 0 ? 'no' : 'yes',
+        made_by: 'agent',
+        superseded_by: null,
+      });
+    }
+
+    // Insert 50 requirements
+    for (let i = 1; i <= 50; i++) {
+      const id = `R${String(i).padStart(3, '0')}`;
+      insertRequirement({
+        id,
+        class: i % 2 === 0 ? 'functional' : 'non-functional',
+        status: i % 4 === 0 ? 'validated' : 'active',
+        description: `requirement ${i}`,
+        why: `why ${i}`,
+        source: 'M001',
+        primary_owner: `S0${(i % 5) + 1}`,
+        supporting_slices: i % 3 === 0 ? 'S01, S02' : '',
+        validation: `validation ${i}`,
+        notes: '',
+        full_content: '',
+        superseded_by: null,
+      });
+    }
+
+    // Time the queries — warm up first
+    queryDecisions();
+    queryRequirements();
+
+    const start = performance.now();
+    const decisions = queryDecisions();
+    const requirements = queryRequirements();
+    const elapsed = performance.now() - start;
+
+    assert.strictEqual(decisions.length, 50, `got ${decisions.length} decisions (expected 50)`);
+    assert.strictEqual(requirements.length, 50, `got ${requirements.length} requirements (expected 50)`);
+    assert.ok(elapsed < 5, `query latency ${elapsed.toFixed(2)}ms should be < 5ms`);
+  });
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // context-store: queryArtifact
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== context-store: queryArtifact returns content for existing path ===');
-{
-  openDatabase(':memory:');
-
-  insertArtifact({
-    path: 'PROJECT.md',
-    artifact_type: 'project',
-    milestone_id: null,
-    slice_id: null,
-    task_id: null,
-    full_content: '# My Project\n\nProject description here.',
-  });
-  insertArtifact({
-    path: '.gsd/milestones/M001/M001-PLAN.md',
-    artifact_type: 'milestone_plan',
-    milestone_id: 'M001',
-    slice_id: null,
-    task_id: null,
-    full_content: '# M001 Plan\n\nMilestone content.',
-  });
+describe("context-store: queryArtifact", () => {
+  afterEach(() => closeDatabase());
 
-  const project = queryArtifact('PROJECT.md');
-  assertEq(project, '# My Project\n\nProject description here.', 'queryArtifact returns full_content for PROJECT.md');
+  test("returns content for existing path", () => {
+    openDatabase(':memory:');
 
-  const plan = queryArtifact('.gsd/milestones/M001/M001-PLAN.md');
-  assertEq(plan, '# M001 Plan\n\nMilestone content.', 'queryArtifact returns full_content for milestone plan');
+    insertArtifact({
+      path: 'PROJECT.md',
+      artifact_type: 'project',
+      milestone_id: null,
+      slice_id: null,
+      task_id: null,
+      full_content: '# My Project\n\nProject description here.',
+    });
+    insertArtifact({
+      path: '.gsd/milestones/M001/M001-PLAN.md',
+      artifact_type: 'milestone_plan',
+      milestone_id: 'M001',
+      slice_id: null,
+      task_id: null,
+      full_content: '# M001 Plan\n\nMilestone content.',
+    });
 
-  closeDatabase();
-}
+    const project = queryArtifact('PROJECT.md');
+    assert.strictEqual(project, '# My Project\n\nProject description here.', 'queryArtifact returns full_content for PROJECT.md');
 
-console.log('\n=== context-store: queryArtifact returns null for missing path ===');
-{
-  openDatabase(':memory:');
+    const plan = queryArtifact('.gsd/milestones/M001/M001-PLAN.md');
+    assert.strictEqual(plan, '# M001 Plan\n\nMilestone content.', 'queryArtifact returns full_content for milestone plan');
+  });
 
-  const missing = queryArtifact('nonexistent.md');
-  assertEq(missing, null, 'queryArtifact returns null for path not in DB');
+  test("returns null for missing path", () => {
+    openDatabase(':memory:');
 
-  closeDatabase();
-}
+    const missing = queryArtifact('nonexistent.md');
+    assert.strictEqual(missing, null, 'queryArtifact returns null for path not in DB');
+  });
 
-console.log('\n=== context-store: queryArtifact returns null when DB unavailable ===');
-{
-  closeDatabase();
-  assertTrue(!isDbAvailable(), 'DB should not be available');
+  test("returns null when DB unavailable", () => {
+    closeDatabase();
+    assert.ok(!isDbAvailable(), 'DB should not be available');
 
-  const result = queryArtifact('PROJECT.md');
-  assertEq(result, null, 'queryArtifact returns null when DB closed');
-}
+    const result = queryArtifact('PROJECT.md');
+    assert.strictEqual(result, null, 'queryArtifact returns null when DB closed');
+  });
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // context-store: queryProject
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== context-store: queryProject returns PROJECT.md content ===');
-{
-  openDatabase(':memory:');
-
-  insertArtifact({
-    path: 'PROJECT.md',
-    artifact_type: 'project',
-    milestone_id: null,
-    slice_id: null,
-    task_id: null,
-    full_content: '# Test Project\n\nThis is the project description.',
-  });
-
-  const content = queryProject();
-  assertEq(content, '# Test Project\n\nThis is the project description.', 'queryProject returns PROJECT.md content');
+describe("context-store: queryProject", () => {
+  afterEach(() => closeDatabase());
 
-  closeDatabase();
-}
+  test("returns PROJECT.md content", () => {
+    openDatabase(':memory:');
 
-console.log('\n=== context-store: queryProject returns null when no PROJECT.md ===');
-{
-  openDatabase(':memory:');
+    insertArtifact({
+      path: 'PROJECT.md',
+      artifact_type: 'project',
+      milestone_id: null,
+      slice_id: null,
+      task_id: null,
+      full_content: '# Test Project\n\nThis is the project description.',
+    });
 
-  const content = queryProject();
-  assertEq(content, null, 'queryProject returns null when PROJECT.md not imported');
+    const content = queryProject();
+    assert.strictEqual(content, '# Test Project\n\nThis is the project description.', 'queryProject returns PROJECT.md content');
+  });
 
-  closeDatabase();
-}
+  test("returns null when no PROJECT.md", () => {
+    openDatabase(':memory:');
 
-console.log('\n=== context-store: queryProject returns null when DB unavailable ===');
-{
-  closeDatabase();
-  assertTrue(!isDbAvailable(), 'DB should not be available');
+    const content = queryProject();
+    assert.strictEqual(content, null, 'queryProject returns null when PROJECT.md not imported');
+  });
 
-  const content = queryProject();
-  assertEq(content, null, 'queryProject returns null when DB closed');
-}
+  test("returns null when DB unavailable", () => {
+    closeDatabase();
+    assert.ok(!isDbAvailable(), 'DB should not be available');
 
-// ─── Final Report ──────────────────────────────────────────────────────────
-report();
+    const content = queryProject();
+    assert.strictEqual(content, null, 'queryProject returns null when DB closed');
+  });
+});