gsd-pi 2.58.0-dev.d63175c → 2.58.0-dev.e002a57

package/src/resources/extensions/gsd/tests/validate-milestone-write-order.test.ts

@@ -6,7 +6,7 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import { handleValidateMilestone } from "../tools/validate-milestone.js";
-import { openDatabase, closeDatabase, _getAdapter, insertMilestone } from "../gsd-db.js";
+import { openDatabase, closeDatabase, _getAdapter, insertMilestone, insertSlice } from "../gsd-db.js";
 import { clearPathCache } from "../paths.js";
 import { clearParseCache } from "../files.js";
 
@@ -45,6 +45,7 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     const dbPath = join(base, ".gsd", "gsd.db");
     openDatabase(dbPath);
     insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001" });
 
     const result = await handleValidateMilestone(VALID_PARAMS, base);
     assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
@@ -71,6 +72,7 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     const dbPath = join(base, ".gsd", "gsd.db");
     openDatabase(dbPath);
     insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001" });
 
     const result = await handleValidateMilestone(
       { ...VALID_PARAMS, verificationClasses: undefined },
@@ -88,6 +90,7 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     const dbPath = join(base, ".gsd", "gsd.db");
     openDatabase(dbPath);
     insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001" });
 
     // Force disk write failure by replacing the milestone directory with a
     // regular file. saveFile() will fail because it cannot write inside a

package/src/resources/extensions/gsd/tests/verdict-parser.test.ts

@@ -0,0 +1,156 @@
+/**
+ * Tests for verdict-parser.ts — extraction, normalization, and schema validation.
+ *
+ * Regression tests for #2960: extractVerdict() must detect verdicts in both
+ * YAML frontmatter and common markdown body patterns (LLM manual writes).
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  extractVerdict,
+  hasVerdict,
+  isAcceptableUatVerdict,
+  isValidMilestoneVerdict,
+} from "../verdict-parser.ts";
+
+// ── extractVerdict ──────────────────────────────────────────────────────────
+
+describe("extractVerdict", () => {
+  it("extracts verdict from YAML frontmatter", () => {
+    const content = "---\nverdict: pass\n---\n\n# Validation";
+    assert.equal(extractVerdict(content), "pass");
+  });
+
+  it("normalizes 'passed' to 'pass' in frontmatter", () => {
+    const content = "---\nverdict: passed\n---\n";
+    assert.equal(extractVerdict(content), "pass");
+  });
+
+  it("extracts case-insensitive verdict from frontmatter", () => {
+    const content = "---\nVerdict: PASS\n---\n";
+    assert.equal(extractVerdict(content), "pass");
+  });
+
+  it("extracts needs-remediation from frontmatter", () => {
+    const content = "---\nverdict: needs-remediation\n---\n";
+    assert.equal(extractVerdict(content), "needs-remediation");
+  });
+
+  it("returns undefined when content has no frontmatter and no markdown verdict", () => {
+    const content = "# Just a heading\n\nSome text without any verdict.";
+    assert.equal(extractVerdict(content), undefined);
+  });
+
+  // ── Regression: #2960 — markdown body verdicts ─────────────────────────
+
+  it("detects **Verdict:** PASS in markdown body (#2960)", () => {
+    const content = [
+      "# M013 — Milestone Validation",
+      "",
+      "**Verdict:** PASS",
+      "",
+      "All slices completed successfully.",
+    ].join("\n");
+    assert.equal(extractVerdict(content), "pass");
+  });
+
+  it("detects **Verdict:** with emoji prefix in markdown body (#2960)", () => {
+    const content = [
+      "# Milestone Validation",
+      "",
+      "**Verdict:** ✅ PASS",
+      "",
+      "Everything looks good.",
+    ].join("\n");
+    assert.equal(extractVerdict(content), "pass");
+  });
+
+  it("detects **Verdict:** needs-remediation in markdown body (#2960)", () => {
+    const content = [
+      "# Milestone Validation",
+      "",
+      "**Verdict:** needs-remediation",
+      "",
+      "Several issues found.",
+    ].join("\n");
+    assert.equal(extractVerdict(content), "needs-remediation");
+  });
+
+  it("normalizes 'passed' to 'pass' in markdown body (#2960)", () => {
+    const content = "# Validation\n\n**Verdict:** Passed\n";
+    assert.equal(extractVerdict(content), "pass");
+  });
+
+  it("detects verdict without colon in bold pattern (#2960)", () => {
+    const content = "# Validation\n\n**Verdict** PASS\n";
+    assert.equal(extractVerdict(content), "pass");
+  });
+
+  it("prefers frontmatter verdict over markdown body", () => {
+    const content = [
+      "---",
+      "verdict: needs-remediation",
+      "---",
+      "",
+      "**Verdict:** PASS",
+    ].join("\n");
+    assert.equal(extractVerdict(content), "needs-remediation");
+  });
+});
+
+// ── hasVerdict ────────────────────────────────────────────────────────────
+
+describe("hasVerdict", () => {
+  it("returns true when verdict field exists", () => {
+    assert.equal(hasVerdict("verdict: pass"), true);
+  });
+
+  it("returns false when no verdict field exists", () => {
+    assert.equal(hasVerdict("# Just a heading"), false);
+  });
+});
+
+// ── isAcceptableUatVerdict ───────────────────────────────────────────────
+
+describe("isAcceptableUatVerdict", () => {
+  it("accepts pass verdict", () => {
+    assert.equal(isAcceptableUatVerdict("pass", undefined), true);
+  });
+
+  it("accepts passed verdict", () => {
+    assert.equal(isAcceptableUatVerdict("passed", undefined), true);
+  });
+
+  it("rejects fail verdict", () => {
+    assert.equal(isAcceptableUatVerdict("fail", undefined), false);
+  });
+
+  it("accepts partial for mixed UAT type", () => {
+    assert.equal(isAcceptableUatVerdict("partial", "mixed"), true);
+  });
+
+  it("rejects partial for artifact-driven UAT type", () => {
+    assert.equal(isAcceptableUatVerdict("partial", "artifact-driven"), false);
+  });
+});
+
+// ── isValidMilestoneVerdict ──────────────────────────────────────────────
+
+describe("isValidMilestoneVerdict", () => {
+  it("accepts pass", () => {
+    assert.equal(isValidMilestoneVerdict("pass"), true);
+  });
+
+  it("accepts needs-attention", () => {
+    assert.equal(isValidMilestoneVerdict("needs-attention"), true);
+  });
+
+  it("accepts needs-remediation", () => {
+    assert.equal(isValidMilestoneVerdict("needs-remediation"), true);
+  });
+
+  it("rejects unknown verdict", () => {
+    assert.equal(isValidMilestoneVerdict("fail"), false);
+  });
+});

package/src/resources/extensions/gsd/tests/verification-operational-gate.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Regression test for #2931: completing-milestone gate should treat
+ * "None required", "N/A", "Not applicable", etc. as equivalent to "none"
+ * and skip the operational verification content check entirely.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { isVerificationNotApplicable } from "../auto-dispatch.ts";
+
+test("isVerificationNotApplicable: bare 'none' is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("none"), true);
+});
+
+test("isVerificationNotApplicable: 'None' (capitalized) is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("None"), true);
+});
+
+test("isVerificationNotApplicable: 'NONE' (uppercase) is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("NONE"), true);
+});
+
+test("isVerificationNotApplicable: 'None required' is not applicable (#2931)", () => {
+  assert.equal(isVerificationNotApplicable("None required"), true);
+});
+
+test("isVerificationNotApplicable: 'None needed' is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("None needed"), true);
+});
+
+test("isVerificationNotApplicable: 'None planned' is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("None planned"), true);
+});
+
+test("isVerificationNotApplicable: 'N/A' is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("N/A"), true);
+});
+
+test("isVerificationNotApplicable: 'n/a' is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("n/a"), true);
+});
+
+test("isVerificationNotApplicable: 'Not applicable' is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("Not applicable"), true);
+});
+
+test("isVerificationNotApplicable: 'Not required' is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("Not required"), true);
+});
+
+test("isVerificationNotApplicable: 'Not needed' is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("Not needed"), true);
+});
+
+test("isVerificationNotApplicable: 'No operational verification needed' is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("No operational verification needed"), true);
+});
+
+test("isVerificationNotApplicable: 'No operational' is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("No operational"), true);
+});
+
+test("isVerificationNotApplicable: empty string is not applicable", () => {
+  assert.equal(isVerificationNotApplicable(""), true);
+});
+
+test("isVerificationNotApplicable: whitespace-only is not applicable", () => {
+  assert.equal(isVerificationNotApplicable("   "), true);
+});
+
+// Positive cases: these SHOULD require verification
+test("isVerificationNotApplicable: 'Run load tests' requires verification", () => {
+  assert.equal(isVerificationNotApplicable("Run load tests"), false);
+});
+
+test("isVerificationNotApplicable: 'Verify API response times under load' requires verification", () => {
+  assert.equal(isVerificationNotApplicable("Verify API response times under load"), false);
+});
+
+test("isVerificationNotApplicable: 'Monitor error rates for 24h' requires verification", () => {
+  assert.equal(isVerificationNotApplicable("Monitor error rates for 24h"), false);
+});

package/src/resources/extensions/gsd/tests/workflow-logger.test.ts

@@ -317,6 +317,54 @@ describe("workflow-logger", () => {
     });
   });
 
+  describe("new log components (db, dispatch)", () => {
+    test("logError with 'db' component stores correct component", () => {
+      logError("db", "failed to copy DB to worktree", { error: "ENOENT" });
+      const entries = peekLogs();
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].severity, "error");
+      assert.equal(entries[0].component, "db");
+      assert.equal(entries[0].message, "failed to copy DB to worktree");
+      assert.deepEqual(entries[0].context, { error: "ENOENT" });
+    });
+
+    test("logError with 'dispatch' component stores correct component", () => {
+      logError("dispatch", "reactive graph derivation failed", { error: "timeout" });
+      const entries = peekLogs();
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].severity, "error");
+      assert.equal(entries[0].component, "dispatch");
+      assert.deepEqual(entries[0].context, { error: "timeout" });
+    });
+
+    test("logWarning with 'reconcile' component for centralized logging path", () => {
+      logWarning("reconcile", "could not acquire sync lock — another reconciliation may be in progress");
+      const entries = peekLogs();
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].severity, "warn");
+      assert.equal(entries[0].component, "reconcile");
+    });
+
+    test("summarizeLogs includes db and dispatch entries", () => {
+      logError("db", "worktree DB reconciliation failed: path contains unsafe characters");
+      logWarning("dispatch", "graph derivation timeout");
+      const summary = summarizeLogs()!;
+      assert.ok(summary.includes("1 error(s)"));
+      assert.ok(summary.includes("1 warning(s)"));
+      assert.ok(summary.includes("unsafe characters"));
+      assert.ok(summary.includes("graph derivation timeout"));
+    });
+
+    test("formatForNotification renders db and dispatch components", () => {
+      logError("db", "copy failed");
+      logWarning("dispatch", "slow derivation");
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.ok(formatted.includes("[db] copy failed"));
+      assert.ok(formatted.includes("[dispatch] slow derivation"));
+    });
+  });
+
   describe("stderr output", () => {
     test("writes WARN prefix to stderr for warnings", (t) => {
       const written: string[] = [];

package/src/resources/extensions/gsd/tests/workflow-manifest.test.ts

@@ -12,6 +12,7 @@ import {
   insertMilestone,
   insertSlice,
   insertTask,
+  _getAdapter,
 } from '../gsd-db.ts';
 import {
   writeManifest,
@@ -165,6 +166,97 @@ test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-
   }
 });
 
+// ─── snapshotState: numeric column coercion (#2962) ─────────────────────
+
+test('workflow-manifest: snapshotState coerces string placeholders in numeric columns to null (#2962)', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    // Set up prerequisite rows
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Task', status: 'complete' });
+
+    // Insert verification_evidence with string placeholders in numeric columns
+    // This simulates what happens after schema migrations or manual inserts
+    const db = _getAdapter()!;
+    db.prepare(
+      `INSERT INTO verification_evidence (task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run('T01', 'S01', 'M001', 'npm test', '-', 'pass', '-', new Date().toISOString());
+
+    // snapshotState should coerce "-" to null for numeric columns
+    const snap = snapshotState();
+    const ev = snap.verification_evidence[0];
+    assert.strictEqual(ev.exit_code, null, 'exit_code "-" should be coerced to null');
+    assert.strictEqual(ev.duration_ms, null, 'duration_ms "-" should be coerced to null');
+
+    // Round-trip through JSON should not throw
+    const json = JSON.stringify(snap, null, 2);
+    const reparsed = JSON.parse(json);
+    assert.strictEqual(reparsed.verification_evidence[0].exit_code, null);
+    assert.strictEqual(reparsed.verification_evidence[0].duration_ms, null);
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('workflow-manifest: snapshotState coerces empty string and N/A in numeric columns (#2962)', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Task', status: 'complete' });
+
+    const db = _getAdapter()!;
+    db.prepare(
+      `INSERT INTO verification_evidence (task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run('T01', 'S01', 'M001', 'npm test', 'N/A', 'pass', '', new Date().toISOString());
+
+    const snap = snapshotState();
+    const ev = snap.verification_evidence[0];
+    assert.strictEqual(ev.exit_code, null, 'exit_code "N/A" should be coerced to null');
+    assert.strictEqual(ev.duration_ms, null, 'duration_ms "" should be coerced to null');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('workflow-manifest: snapshotState coerces string placeholders in sequence columns (#2962)', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001' });
+
+    // Insert a slice with a string sequence via raw SQL
+    const db = _getAdapter()!;
+    db.prepare(
+      `INSERT INTO slices (milestone_id, id, title, status, risk, depends, demo, created_at, sequence)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run('M001', 'S01', 'Test Slice', 'planned', 'low', '[]', '', new Date().toISOString(), '-');
+
+    db.prepare(
+      `INSERT INTO tasks (milestone_id, slice_id, id, title, status, sequence)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+    ).run('M001', 'S01', 'T01', 'Test Task', 'planned', 'N/A');
+
+    const snap = snapshotState();
+    assert.strictEqual(snap.slices[0].sequence, 0, 'slice sequence "-" should be coerced to 0');
+    assert.strictEqual(snap.tasks[0].sequence, 0, 'task sequence "N/A" should be coerced to 0');
+
+    // JSON round-trip must not throw
+    const json = JSON.stringify(snap, null, 2);
+    assert.doesNotThrow(() => JSON.parse(json));
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
 // ─── readManifest: version check ─────────────────────────────────────────
 
 test('workflow-manifest: readManifest throws on unsupported version', () => {

package/src/resources/extensions/gsd/tests/workflow-projections.test.ts

@@ -86,10 +86,12 @@ test('workflow-projections: renderPlanContent falls back to TBD when goal and fu
   assert.ok(content.includes('**Goal:** TBD'));
 });
 
-test('workflow-projections: renderPlanContent falls back to full_summary_md when goal is empty', () => {
+test('workflow-projections: renderPlanContent falls back to TBD when goal is empty (full_summary_md ignored #2945)', () => {
   const slice = makeSlice({ goal: '', full_summary_md: 'Fallback goal text' });
   const content = renderPlanContent(slice, []);
-  assert.ok(content.includes('**Goal:** Fallback goal text'));
+  // #2945: full_summary_md is no longer used as a fallback — it contains
+  // multi-line rendered markdown that corrupts single-line fields.
+  assert.ok(content.includes('**Goal:** TBD'), `expected TBD fallback, got: ${content}`);
 });
 
 test('workflow-projections: renderPlanContent includes ## Tasks section', () => {

package/src/resources/extensions/gsd/tests/worktree-db-respawn-truncation.test.ts

@@ -0,0 +1,140 @@
+/**
+ * worktree-db-respawn-truncation.test.ts — Regression test for #2815.
+ *
+ * Verifies that syncProjectRootToWorktree does NOT delete a non-empty
+ * worktree gsd.db. On worker respawn, gsd-migrate populates the DB
+ * (~1.7MB) before the auto-loop calls syncProjectRootToWorktree. The
+ * sync step must preserve the freshly-migrated DB to avoid truncating
+ * it to 0 bytes and causing "no such table: slices" failures.
+ *
+ * Covers:
+ *   - Non-empty worktree gsd.db preserved after sync (#2815)
+ *   - Empty (0-byte) worktree gsd.db still deleted (#853 preserved)
+ *   - WAL/SHM sidecar files cleaned up when empty DB is deleted
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { syncProjectRootToWorktree } from '../auto-worktree.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+
+
+function createBase(name: string): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-wt-respawn-${name}-`));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+describe('worktree-db-respawn-truncation (#2815)', async () => {
+
+  // ─── 1. Non-empty worktree gsd.db preserved after sync ───────────────
+  console.log('\n=== 1. non-empty worktree gsd.db preserved after sync (#2815) ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      // Set up milestone artifacts in main project root
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+
+      // Simulate a freshly-migrated worktree DB (non-empty, like after gsd-migrate)
+      // Real DBs are ~1.7MB; we use a smaller payload to prove the size check works
+      const fakeDbContent = Buffer.alloc(4096, 0x42); // 4KB non-empty DB
+      writeFileSync(join(wtBase, '.gsd', 'gsd.db'), fakeDbContent);
+
+      const sizeBefore = statSync(join(wtBase, '.gsd', 'gsd.db')).size;
+      assert.ok(sizeBefore > 0, 'gsd.db is non-empty before sync');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      // The non-empty DB must survive the sync
+      assert.ok(
+        existsSync(join(wtBase, '.gsd', 'gsd.db')),
+        '#2815: non-empty gsd.db must not be deleted by sync',
+      );
+      const sizeAfter = statSync(join(wtBase, '.gsd', 'gsd.db')).size;
+      assert.equal(
+        sizeAfter,
+        sizeBefore,
+        '#2815: gsd.db size must be unchanged after sync',
+      );
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 2. Empty (0-byte) worktree gsd.db still deleted ─────────────────
+  console.log('\n=== 2. empty (0-byte) worktree gsd.db still deleted (#853) ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+
+      // Create an empty (0-byte) gsd.db — this is stale/corrupt and should be deleted
+      writeFileSync(join(wtBase, '.gsd', 'gsd.db'), '');
+      assert.ok(existsSync(join(wtBase, '.gsd', 'gsd.db')), 'empty gsd.db exists before sync');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      assert.ok(
+        !existsSync(join(wtBase, '.gsd', 'gsd.db')),
+        '#853: empty gsd.db must still be deleted after sync',
+      );
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 3. Milestone artifacts still synced when DB is preserved ────────
+  console.log('\n=== 3. milestone artifacts still synced even when DB preserved ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+      mkdirSync(join(m001Dir, 'slices', 'S01'), { recursive: true });
+      writeFileSync(join(m001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# Plan');
+
+      // Non-empty DB in worktree
+      writeFileSync(join(wtBase, '.gsd', 'gsd.db'), 'populated-db-data');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      // Artifacts must still be synced
+      assert.ok(
+        existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md')),
+        'milestone artifacts synced even with preserved DB',
+      );
+      assert.ok(
+        existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md')),
+        'slice artifacts synced even with preserved DB',
+      );
+      // DB must still exist
+      assert.ok(
+        existsSync(join(wtBase, '.gsd', 'gsd.db')),
+        '#2815: DB preserved alongside artifact sync',
+      );
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+});