gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

package/src/resources/extensions/gsd/tests/rogue-file-detection.test.ts

@@ -0,0 +1,296 @@
+/**
+ * Rogue file detection tests — verifies that detectRogueFileWrites()
+ * correctly identifies summary files written directly to disk without
+ * a corresponding DB completion record.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { detectRogueFileWrites } from "../auto-post-unit.ts";
+import { openDatabase, closeDatabase, isDbAvailable, insertMilestone, insertSlice, insertTask, updateSliceStatus, upsertMilestonePlanning } from "../gsd-db.ts";
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function createTmpBase(): string {
+  return realpathSync(mkdtempSync(join(tmpdir(), "gsd-rogue-test-")));
+}
+
+/**
+ * Create a minimal .gsd/ directory structure with a task summary file.
+ */
+function createTaskSummaryOnDisk(basePath: string, mid: string, sid: string, tid: string): string {
+  const tasksDir = join(basePath, ".gsd", "milestones", mid, "slices", sid, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  const summaryFile = join(tasksDir, `${tid}-SUMMARY.md`);
+  writeFileSync(summaryFile, `---\nid: ${tid}\nparent: ${sid}\nmilestone: ${mid}\n---\n# ${tid}: Test\n`, "utf-8");
+  return summaryFile;
+}
+
+/**
+ * Create a minimal .gsd/ directory structure with a slice summary file.
+ */
+function createSliceSummaryOnDisk(basePath: string, mid: string, sid: string): string {
+  const sliceDir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(sliceDir, { recursive: true });
+  const summaryFile = join(sliceDir, `${sid}-SUMMARY.md`);
+  writeFileSync(summaryFile, `---\nid: ${sid}\nmilestone: ${mid}\n---\n# ${sid}: Test Slice\n`, "utf-8");
+  return summaryFile;
+}
+
+function createRoadmapOnDisk(basePath: string, mid: string): string {
+  const milestoneDir = join(basePath, ".gsd", "milestones", mid);
+  mkdirSync(milestoneDir, { recursive: true });
+  const roadmapFile = join(milestoneDir, `${mid}-ROADMAP.md`);
+  writeFileSync(roadmapFile, `# ${mid}: Test Roadmap\n`, "utf-8");
+  return roadmapFile;
+}
+
+function createSlicePlanOnDisk(basePath: string, mid: string, sid: string): string {
+  const sliceDir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(sliceDir, { recursive: true });
+  const planFile = join(sliceDir, `${sid}-PLAN.md`);
+  writeFileSync(planFile, `# ${sid}: Test Plan\n`, "utf-8");
+  return planFile;
+}
+
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+test("rogue detection: task summary on disk, no DB row → detected as rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+    assert.ok(isDbAvailable(), "DB should be available");
+
+    const summaryPath = createTaskSummaryOnDisk(basePath, "M001", "S01", "T01");
+    assert.ok(existsSync(summaryPath), "Summary file should exist on disk");
+
+    const rogues = detectRogueFileWrites("execute-task", "M001/S01/T01", basePath);
+    assert.equal(rogues.length, 1, "Should detect one rogue file");
+    assert.equal(rogues[0].path, summaryPath);
+    assert.equal(rogues[0].unitType, "execute-task");
+    assert.equal(rogues[0].unitId, "M001/S01/T01");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: task summary on disk, DB row with status 'complete' → NOT rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    createTaskSummaryOnDisk(basePath, "M001", "S01", "T01");
+
+    // Insert parent milestone and slice first (foreign key constraints)
+    insertMilestone({ id: "M001" });
+    insertSlice({ milestoneId: "M001", id: "S01" });
+
+    // Insert a completed task row into the DB (INSERT OR REPLACE)
+    insertTask({
+      milestoneId: "M001",
+      sliceId: "S01",
+      id: "T01",
+      title: "Test Task",
+      status: "complete",
+      oneLiner: "Test",
+    });
+
+    const rogues = detectRogueFileWrites("execute-task", "M001/S01/T01", basePath);
+    assert.equal(rogues.length, 0, "Should NOT detect rogue when DB row is complete");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: no summary file on disk → NOT rogue regardless of DB state", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    // Don't create any summary file on disk
+    const rogues = detectRogueFileWrites("execute-task", "M001/S01/T01", basePath);
+    assert.equal(rogues.length, 0, "Should NOT detect rogue when no file on disk");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: DB not available → returns empty array (graceful degradation)", () => {
+  const basePath = createTmpBase();
+
+  try {
+    closeDatabase();
+    assert.ok(!isDbAvailable(), "DB should not be available");
+
+    // Create a file on disk even though DB is closed
+    createTaskSummaryOnDisk(basePath, "M001", "S01", "T01");
+
+    const rogues = detectRogueFileWrites("execute-task", "M001/S01/T01", basePath);
+    assert.equal(rogues.length, 0, "Should return empty array when DB unavailable");
+  } finally {
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: slice summary on disk, no DB row → detected as rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    const summaryPath = createSliceSummaryOnDisk(basePath, "M001", "S01");
+    assert.ok(existsSync(summaryPath), "Slice summary file should exist on disk");
+
+    const rogues = detectRogueFileWrites("complete-slice", "M001/S01", basePath);
+    assert.equal(rogues.length, 1, "Should detect one rogue slice file");
+    assert.equal(rogues[0].path, summaryPath);
+    assert.equal(rogues[0].unitType, "complete-slice");
+    assert.equal(rogues[0].unitId, "M001/S01");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: slice summary on disk, DB row with status 'complete' → NOT rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    createSliceSummaryOnDisk(basePath, "M001", "S01");
+
+    // Insert parent milestone first (foreign key constraint)
+    insertMilestone({ id: "M001" });
+
+    // Insert a slice row, then update to complete
+    insertSlice({
+      milestoneId: "M001",
+      id: "S01",
+      title: "Test Slice",
+      status: "complete",
+    });
+    updateSliceStatus("M001", "S01", "complete", new Date().toISOString());
+
+    const rogues = detectRogueFileWrites("complete-slice", "M001/S01", basePath);
+    assert.equal(rogues.length, 0, "Should NOT detect rogue when slice DB row is complete");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: plan milestone roadmap on disk, no milestone planning row → detected as rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    const roadmapPath = createRoadmapOnDisk(basePath, "M001");
+    assert.ok(existsSync(roadmapPath), "Roadmap file should exist on disk");
+
+    const rogues = detectRogueFileWrites("plan-milestone", "M001", basePath);
+    assert.equal(rogues.length, 1, "Should detect one rogue roadmap file");
+    assert.equal(rogues[0].path, roadmapPath);
+    assert.equal(rogues[0].unitType, "plan-milestone");
+    assert.equal(rogues[0].unitId, "M001");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: plan milestone roadmap on disk, DB milestone planning row exists → NOT rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    createRoadmapOnDisk(basePath, "M001");
+    insertMilestone({ id: "M001", title: "Planned Milestone" });
+    upsertMilestonePlanning("M001", {
+      vision: "Real planning state",
+      requirementCoverage: "R001 → S01",
+      boundaryMapMarkdown: "- planner → db",
+    });
+
+    const rogues = detectRogueFileWrites("plan-milestone", "M001", basePath);
+    assert.equal(rogues.length, 0, "Should NOT detect rogue when milestone planning state exists");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: slice plan on disk, no slice planning row → detected as rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    const planPath = createSlicePlanOnDisk(basePath, "M001", "S01");
+    assert.ok(existsSync(planPath), "Slice plan file should exist on disk");
+
+    const rogues = detectRogueFileWrites("plan-slice", "M001/S01", basePath);
+    assert.equal(rogues.length, 1, "Should detect one rogue slice plan file");
+    assert.equal(rogues[0].path, planPath);
+    assert.equal(rogues[0].unitType, "plan-slice");
+    assert.equal(rogues[0].unitId, "M001/S01");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: slice plan on disk, DB slice planning row exists → NOT rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    createSlicePlanOnDisk(basePath, "M001", "S01");
+    insertMilestone({ id: "M001" });
+    insertSlice({
+      milestoneId: "M001",
+      id: "S01",
+      title: "Planned Slice",
+      status: "pending",
+      demo: "Observable plan",
+    });
+
+    const rogues = detectRogueFileWrites("plan-slice", "M001/S01", basePath);
+    assert.equal(rogues.length, 0, "Should NOT detect rogue when slice planning state exists");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/schema-v9-sequence.test.ts

@@ -0,0 +1,176 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getMilestoneSlices,
+  getSliceTasks,
+  getActiveSliceFromDb,
+  getActiveTaskFromDb,
+} from '../gsd-db.ts';
+
+function makeTmp(): string {
+  return mkdtempSync(join(tmpdir(), 'gsd-v9-'));
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test('schema v9: migration adds sequence column to slices and tasks', () => {
+  const base = makeTmp();
+  const dbPath = join(base, 'gsd.db');
+  openDatabase(dbPath);
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    // If sequence column doesn't exist, these would throw
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice 1', sequence: 5 });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Task 1', sequence: 3 });
+
+    const slices = getMilestoneSlices('M001');
+    assert.equal(slices.length, 1);
+    assert.equal(slices[0]!.sequence, 5);
+
+    const tasks = getSliceTasks('M001', 'S01');
+    assert.equal(tasks.length, 1);
+    assert.equal(tasks[0]!.sequence, 3);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: getMilestoneSlices returns slices ordered by sequence then id', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+
+    // Insert in reverse lexicographic order with sequence overriding id order
+    insertSlice({ id: 'S03', milestoneId: 'M001', title: 'Third by id, first by seq', sequence: 1 });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First by id, third by seq', sequence: 3 });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second by id, second by seq', sequence: 2 });
+
+    const slices = getMilestoneSlices('M001');
+    assert.equal(slices.length, 3);
+    assert.equal(slices[0]!.id, 'S03', 'sequence=1 should be first');
+    assert.equal(slices[1]!.id, 'S02', 'sequence=2 should be second');
+    assert.equal(slices[2]!.id, 'S01', 'sequence=3 should be third');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: getSliceTasks returns tasks ordered by sequence then id', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice' });
+
+    // Insert tasks with sequence overriding id order
+    insertTask({ id: 'T03', sliceId: 'S01', milestoneId: 'M001', title: 'Third by id', sequence: 1 });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'First by id', sequence: 3 });
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Second by id', sequence: 2 });
+
+    const tasks = getSliceTasks('M001', 'S01');
+    assert.equal(tasks.length, 3);
+    assert.equal(tasks[0]!.id, 'T03', 'sequence=1 should be first');
+    assert.equal(tasks[1]!.id, 'T02', 'sequence=2 should be second');
+    assert.equal(tasks[2]!.id, 'T01', 'sequence=3 should be third');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: default sequence (0) falls back to id-based ordering', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+
+    // All slices with default sequence=0 should sort by id
+    insertSlice({ id: 'S03', milestoneId: 'M001', title: 'Third' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second' });
+
+    const slices = getMilestoneSlices('M001');
+    assert.equal(slices[0]!.id, 'S01', 'default seq=0: should sort by id');
+    assert.equal(slices[1]!.id, 'S02');
+    assert.equal(slices[2]!.id, 'S03');
+
+    // Same for tasks
+    insertSlice({ id: 'S04', milestoneId: 'M001', title: 'Container' });
+    insertTask({ id: 'T02', sliceId: 'S04', milestoneId: 'M001', title: 'B' });
+    insertTask({ id: 'T01', sliceId: 'S04', milestoneId: 'M001', title: 'A' });
+    insertTask({ id: 'T03', sliceId: 'S04', milestoneId: 'M001', title: 'C' });
+
+    const tasks = getSliceTasks('M001', 'S04');
+    assert.equal(tasks[0]!.id, 'T01');
+    assert.equal(tasks[1]!.id, 'T02');
+    assert.equal(tasks[2]!.id, 'T03');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: getActiveSliceFromDb respects sequence ordering', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+
+    // S02 has lower sequence so should be active first despite higher id than S01
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Higher seq', status: 'pending', sequence: 5 });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Lower seq', status: 'pending', sequence: 2 });
+
+    const active = getActiveSliceFromDb('M001');
+    assert.ok(active);
+    assert.equal(active!.id, 'S02', 'lower sequence should be active first');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: getActiveTaskFromDb respects sequence ordering', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice' });
+
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Higher seq', status: 'pending', sequence: 10 });
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Lower seq', status: 'pending', sequence: 1 });
+
+    const active = getActiveTaskFromDb('M001', 'S01');
+    assert.ok(active);
+    assert.equal(active!.id, 'T02', 'lower sequence should be active first');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: sequence field defaults to 0 when not provided', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'No seq' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'No seq' });
+
+    const slices = getMilestoneSlices('M001');
+    assert.equal(slices[0]!.sequence, 0, 'slice sequence defaults to 0');
+
+    const tasks = getSliceTasks('M001', 'S01');
+    assert.equal(tasks[0]!.sequence, 0, 'task sequence defaults to 0');
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/shared-wal.test.ts

@@ -0,0 +1,216 @@
+// shared-wal.test.ts — Tests for shared WAL DB path resolution and concurrent writes.
+// Verifies: resolveProjectRootDbPath() for worktree/root paths, WAL concurrent writes.
+
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { join, sep } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { resolveProjectRootDbPath } from '../bootstrap/dynamic-tools.ts';
+import {
+  openDatabase,
+  closeDatabase,
+  transaction,
+  insertMilestone,
+  getAllMilestones,
+  _getAdapter,
+} from '../gsd-db.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+function createTmpDir(suffix: string): string {
+  return mkdtempSync(join(tmpdir(), `gsd-wal-${suffix}-`));
+}
+
+function cleanup(dir: string): void {
+  rmSync(dir, { recursive: true, force: true });
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────
+
+async function main() {
+  // ─── Test (a): resolveProjectRootDbPath returns project root DB for worktree path ───
+  console.log('\n=== shared-wal: resolve worktree path to project root DB ===');
+  {
+    const projectRoot = '/home/user/myproject';
+    const worktreePath = join(projectRoot, '.gsd', 'worktrees', 'M001');
+    const result = resolveProjectRootDbPath(worktreePath);
+    assertEq(result, join(projectRoot, '.gsd', 'gsd.db'),
+      'worktree path resolves to project root DB');
+  }
+
+  // ─── Test (b): resolveProjectRootDbPath returns same base for project root ────
+  console.log('\n=== shared-wal: resolve project root path ===');
+  {
+    const projectRoot = '/home/user/myproject';
+    const result = resolveProjectRootDbPath(projectRoot);
+    assertEq(result, join(projectRoot, '.gsd', 'gsd.db'),
+      'project root path stays at project root DB');
+  }
+
+  // ─── Test (c): resolve nested worktree subdir ──────────────────────────
+  console.log('\n=== shared-wal: resolve nested worktree subdir ===');
+  {
+    const projectRoot = '/home/user/myproject';
+    const nestedPath = join(projectRoot, '.gsd', 'worktrees', 'M002', 'src', 'lib');
+    const result = resolveProjectRootDbPath(nestedPath);
+    assertEq(result, join(projectRoot, '.gsd', 'gsd.db'),
+      'nested worktree subdir resolves to project root DB');
+  }
+
+  // ─── Test (d): resolve with forward slashes (cross-platform) ──────────
+  console.log('\n=== shared-wal: resolve forward-slash path ===');
+  {
+    const result = resolveProjectRootDbPath('/proj/.gsd/worktrees/M001');
+    assertEq(result, join('/proj', '.gsd', 'gsd.db'),
+      'forward-slash worktree path resolves correctly');
+  }
+
+  // ─── Test (e): Concurrent writes — 3 connections to same WAL DB ───────
+  console.log('\n=== shared-wal: concurrent writes via WAL ===');
+  {
+    const tmp = createTmpDir('concurrent');
+    const dbPath = join(tmp, 'test.db');
+    try {
+      // Open with openDatabase to init schema + WAL mode
+      openDatabase(dbPath);
+
+      // Insert milestones from the main connection
+      insertMilestone({
+        id: 'M001', title: 'From conn 1', status: 'active',
+      });
+
+      // Open two additional raw connections via openDatabase in separate calls.
+      // Since openDatabase closes the previous connection and opens a new one,
+      // we simulate concurrent access by using the transaction() wrapper to
+      // verify WAL allows reads while writes are happening.
+
+      // Write M002
+      insertMilestone({
+        id: 'M002', title: 'From conn 2', status: 'active',
+      });
+
+      // Write M003
+      insertMilestone({
+        id: 'M003', title: 'From conn 3', status: 'active',
+      });
+
+      // Verify all 3 milestones are visible
+      const all = getAllMilestones();
+      assertEq(all.length, 3, 'concurrent: all 3 milestones visible');
+      const ids = all.map(m => m.id).sort();
+      assertEq(ids, ['M001', 'M002', 'M003'], 'concurrent: correct IDs');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(tmp);
+    }
+  }
+
+  // ─── Test (f): WAL concurrent — multiple raw connections to file DB ────
+  console.log('\n=== shared-wal: true concurrent connections via raw SQLite ===');
+  {
+    const tmp = createTmpDir('rawconc');
+    const dbPath = join(tmp, 'concurrent.db');
+    try {
+      // Open first connection and init schema
+      openDatabase(dbPath);
+      closeDatabase();
+
+      // To test true concurrent access, we open 3 separate raw connections
+      // using the same provider. The openDatabase/closeDatabase cycle proves
+      // WAL mode persists and multiple sequential openers see each other's writes.
+
+      // Connection 1: write M001
+      openDatabase(dbPath);
+      insertMilestone({ id: 'M001', title: 'Writer 1', status: 'active' });
+      closeDatabase();
+
+      // Connection 2: write M002, verify sees M001
+      openDatabase(dbPath);
+      const afterConn2Before = getAllMilestones();
+      assertTrue(afterConn2Before.some(m => m.id === 'M001'),
+        'rawconc: conn2 sees M001 from conn1');
+      insertMilestone({ id: 'M002', title: 'Writer 2', status: 'active' });
+      closeDatabase();
+
+      // Connection 3: write M003, verify sees M001 + M002
+      openDatabase(dbPath);
+      const afterConn3Before = getAllMilestones();
+      assertTrue(afterConn3Before.some(m => m.id === 'M001'),
+        'rawconc: conn3 sees M001');
+      assertTrue(afterConn3Before.some(m => m.id === 'M002'),
+        'rawconc: conn3 sees M002');
+      insertMilestone({ id: 'M003', title: 'Writer 3', status: 'active' });
+
+      // Final read: all 3 visible
+      const finalAll = getAllMilestones();
+      assertEq(finalAll.length, 3, 'rawconc: all 3 milestones visible');
+      assertEq(
+        finalAll.map(m => m.id).sort(),
+        ['M001', 'M002', 'M003'],
+        'rawconc: all IDs present',
+      );
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(tmp);
+    }
+  }
+
+  // ─── Test (g): BUSY retry — transaction wrapper handles contention ─────
+  console.log('\n=== shared-wal: transaction rollback on error ===');
+  {
+    const tmp = createTmpDir('busy');
+    const dbPath = join(tmp, 'busy.db');
+    try {
+      openDatabase(dbPath);
+
+      // Insert a milestone in a transaction
+      transaction(() => {
+        insertMilestone({ id: 'M001', title: 'In txn', status: 'active' });
+      });
+
+      // Verify it committed
+      const all = getAllMilestones();
+      assertEq(all.length, 1, 'busy: M001 committed via transaction');
+
+      // Verify transaction rolls back on error
+      let errorCaught = false;
+      try {
+        transaction(() => {
+          insertMilestone({ id: 'M002', title: 'Will fail', status: 'active' });
+          throw new Error('Simulated failure');
+        });
+      } catch (err) {
+        errorCaught = true;
+        assertTrue(
+          (err as Error).message.includes('Simulated failure'),
+          'busy: error propagated from transaction',
+        );
+      }
+      assertTrue(errorCaught, 'busy: transaction threw on error');
+
+      // M002 should NOT be visible (rolled back)
+      const afterRollback = getAllMilestones();
+      assertEq(afterRollback.length, 1, 'busy: M002 rolled back — still only 1 milestone');
+      assertEq(afterRollback[0]!.id, 'M001', 'busy: only M001 survives');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(tmp);
+    }
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});