@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

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

@@ -0,0 +1,207 @@
+// gsd-pi — DB engine failure-branch log coverage.
+//
+// `checkpointDatabase` / `closeDatabase` / `vacuumDatabase` in db/engine.ts are
+// the highest-frequency runtime paths (called every turn and at closeout).
+// Each wraps its destructive PRAGMA in a try/catch that emits a `db` warning so
+// a failed checkpoint/vacuum/close never breaks orchestration but is still
+// observable. The existing gsd-db tests only assert the *happy* path (WAL gets
+// truncated); no test exercises any of these catch branches, so a regression
+// that drops or misroutes the warning would pass silently.
+//
+// This file pins the log output for the three checkpoint/vacuum/close failure
+// branches by stubbing the live adapter's `exec`/`close` to throw on demand.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { chmodSync as fsChmodSync, mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { checkpointDatabase, closeDatabase, openDatabase, vacuumDatabase, _getAdapter } from "../gsd-db.ts";
+import { backupDatabaseSnapshot, readTransaction } from "../db/engine.ts";
+import {
+  drainLogs,
+  peekLogs,
+  setStderrLoggingEnabled,
+  _resetLogs,
+  type LogEntry,
+} from "../workflow-logger.ts";
+import type { DbAdapter } from "../db-adapter.ts";
+
+function makeBase(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-db-engine-logs-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+/** Capture log entries emitted while running fn. Stderr is suppressed. */
+function captureLogs<T>(fn: () => T): { result: T; logs: LogEntry[] } {
+  const previous = setStderrLoggingEnabled(false);
+  _resetLogs();
+  try {
+    const result = fn();
+    return { result, logs: drainLogs() };
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
+  }
+}
+
+/**
+ * Wrap the live adapter's `exec` so it throws for SQL matching `needle`,
+ * delegating everything else to the original. Returns a restore function.
+ */
+function breakExecOn(adapter: DbAdapter, needle: string): () => void {
+  const origExec = adapter.exec.bind(adapter);
+  adapter.exec = (sql: string): void => {
+    if (sql.includes(needle)) throw new Error(`forced failure for: ${needle}`);
+    return origExec(sql);
+  };
+  return () => {
+    adapter.exec = origExec;
+  };
+}
+
+test("checkpointDatabase logs a `db` warning when the WAL checkpoint throws", () => {
+  const base = makeBase();
+  assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+  try {
+    const adapter = _getAdapter();
+    assert.ok(adapter, "an adapter must be open");
+    const restore = breakExecOn(adapter!, "wal_checkpoint");
+
+    const { logs } = captureLogs(() => checkpointDatabase());
+    restore();
+
+    const dbWarn = logs.find((e) => e.component === "db" && e.severity === "warn");
+    assert.ok(dbWarn, "a db warning must be logged on checkpoint failure");
+    assert.match(dbWarn!.message, /WAL checkpoint failed/u);
+    assert.match(dbWarn!.message, /forced failure for: wal_checkpoint/u);
+    // checkpointDatabase must not rethrow — orchestration continues.
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("vacuumDatabase logs a `db` warning when VACUUM throws", () => {
+  const base = makeBase();
+  assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+  try {
+    const adapter = _getAdapter();
+    assert.ok(adapter);
+    const restore = breakExecOn(adapter!, "VACUUM");
+
+    const { logs } = captureLogs(() => vacuumDatabase());
+    restore();
+
+    const dbWarn = logs.find((e) => e.component === "db" && e.severity === "warn");
+    assert.ok(dbWarn, "a db warning must be logged on VACUUM failure");
+    assert.match(dbWarn!.message, /VACUUM failed/u);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("closeDatabase logs `db` warnings when WAL checkpoint and close throw on teardown", () => {
+  const base = makeBase();
+  assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+  const adapter = _getAdapter();
+  assert.ok(adapter);
+  // Break both the WAL checkpoint and the final close. The incremental_vacuum
+  // pragma is left intact so we can assert the checkpoint/close warnings land
+  // without the teardown itself exploding mid-way.
+  const restoreExec = breakExecOn(adapter!, "wal_checkpoint");
+  const origClose = adapter!.close.bind(adapter!);
+  adapter!.close = (): void => {
+    throw new Error("forced close failure");
+  };
+
+  const { logs } = captureLogs(() => closeDatabase());
+  restoreExec();
+  adapter!.close = origClose;
+
+  try {
+    const messages = logs.filter((e) => e.component === "db").map((e) => e.message);
+    assert.ok(
+      messages.some((m) => /WAL checkpoint failed/u.test(m)),
+      "WAL checkpoint failure must be logged during close",
+    );
+    assert.ok(
+      messages.some((m) => /database close failed/u.test(m)),
+      "close failure must be logged during close",
+    );
+    // closeDatabase must fully reset engine state even when teardown steps throw.
+    assert.equal(_getAdapter(), null, "engine must release the adapter after a broken close");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("checkpointDatabase and vacuumDatabase are no-ops (and log nothing) when no DB is open", () => {
+  _resetLogs();
+  const previous = setStderrLoggingEnabled(false);
+  try {
+    checkpointDatabase();
+    vacuumDatabase();
+    assert.equal(peekLogs().length, 0, "no-db paths must not emit any logs");
+  } finally {
+    setStderrLoggingEnabled(previous);
+    _resetLogs();
+  }
+});
+
+test("readTransaction logs a db error when ROLLBACK fails after a read error (split-brain signal)", () => {
+  const base = makeBase();
+  assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+  const adapter = _getAdapter();
+  assert.ok(adapter);
+  // Make ROLLBACK throw so the read-failure path invokes the rollback-error
+  // callback (engine.ts:768-775), which logs the split-brain error.
+  const restore = breakExecOn(adapter!, "ROLLBACK");
+
+  const { logs } = captureLogs(() => {
+    assert.throws(
+      () => readTransaction(() => {
+        throw new Error("read body failed");
+      }),
+      /read body failed/u,
+      "the original read error must still propagate",
+    );
+  });
+  restore();
+  closeDatabase();
+  try {
+    const err = logs.find((e) => e.component === "db" && e.severity === "error");
+    assert.ok(err, "a db error must be logged when ROLLBACK fails");
+    assert.equal(err!.message, "snapshotState ROLLBACK failed");
+    assert.match(err!.context?.error ?? "", /forced failure for: ROLLBACK/u);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("backupDatabaseSnapshot logs a db warning when the snapshot copy fails", () => {
+  const base = makeBase();
+  const dbPath = join(base, ".gsd", "gsd.db");
+  assert.equal(openDatabase(dbPath), true);
+  // Make the snapshot destination's parent dir read-only so the copy step
+  // inside backupDatabaseSnapshot (mkdirSync(backups) + copyFileSync) fails —
+  // exercising the outer catch (engine.ts:726-728). The DB handle stays open,
+  // so currentPath is set and the read-only parent only blocks the new copy.
+  fsChmodSync(join(base, ".gsd"), 0o555);
+
+  const { result, logs } = captureLogs(() => backupDatabaseSnapshot("test-label"));
+  closeDatabase();
+  try {
+    assert.equal(result, null, "a failed snapshot must return null");
+    const warn = logs.find((e) => e.component === "db" && e.severity === "warn");
+    assert.ok(warn, "a db warning must be logged on snapshot failure");
+    assert.match(warn!.message, /database snapshot failed/u);
+  } finally {
+    fsChmodSync(join(base, ".gsd"), 0o755);
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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

@@ -1,6 +1,8 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import fs from 'node:fs';
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { syncBuiltinESMExports } from 'node:module';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
@@ -254,6 +256,29 @@ describe('derive-state-db', async () => {
     }
   });
 
+  test('derive-state-db: opens existing project DB before querying milestones', async (t) => {
+    const base = createFixtureBase();
+    t.after(() => {
+      closeDatabase();
+      cleanup(base);
+    });
+
+    const dbPath = join(base, '.gsd', 'gsd.db');
+    assert.equal(openDatabase(dbPath), true);
+    insertMilestone({ id: 'M001', title: 'Cold DB Milestone', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Ready Slice', status: 'active', risk: 'low', depends: [] });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Ready Task', status: 'pending' });
+    closeDatabase();
+    assert.equal(isDbAvailable(), false);
+
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, 'M001');
+    assert.equal(state.activeSlice?.id, 'S01');
+    assert.equal(state.activeTask?.id, 'T01');
+    assert.notEqual(state.nextAction, 'No milestones found. Run /gsd to create one.');
+  });
+
   // ─── Test 4: Partial DB content does not fill gaps from disk ──────────
   test('derive-state-db: partial DB does not fill requirements from disk', async () => {
     const base = createFixtureBase();
@@ -1239,6 +1264,43 @@ describe('derive-state-db', async () => {
     }
   });
 
+  test('derive-state-db: missing context resolves milestone directory once', async () => {
+    const base = createFixtureBase();
+    const phaseDir = join(realpathSync.native(base), '.gsd', 'phases', '01-m001');
+    let phaseDirExistsChecks = 0;
+    const mutableFs = fs as { existsSync: typeof fs.existsSync };
+    const originalExistsSync = fs.existsSync;
+    mutableFs.existsSync = ((path) => {
+      if (String(path) === phaseDir) phaseDirExistsChecks += 1;
+      return originalExistsSync(path);
+    }) as typeof fs.existsSync;
+    syncBuiltinESMExports();
+
+    try {
+      mkdirSync(phaseDir, { recursive: true });
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'queued' });
+
+      invalidateStateCache();
+      const dbState = await deriveStateFromDb(base);
+
+      assert.equal(dbState.activeMilestone?.id, 'M001', 'single-resolve: queued milestone becomes active');
+      assert.equal(
+        phaseDirExistsChecks,
+        3,
+        'single-resolve: one directory resolve plus two artifact probes re-check the milestone directory via resolveFile',
+      );
+
+      closeDatabase();
+    } finally {
+      mutableFs.existsSync = originalExistsSync;
+      syncBuiltinESMExports();
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
   // ─── Regression: disk-only milestones synced into DB (#2416) ─────────
   test('derive-state-db: disk-only milestone auto-synced into DB (#2416)', async () => {
     const base = createFixtureBase();

package/src/resources/extensions/gsd/tests/derive-state-helpers.test.ts

@@ -20,6 +20,7 @@ import {
   insertRequirement,
   insertSlice,
   insertTask,
+  getAllMilestones,
   setMilestoneQueueOrder,
   transaction,
   updateTaskStatus,
@@ -445,11 +446,10 @@ describe('derive-state-helpers', () => {
     }
   });
 
-  // ─── Queue order: DB sequence is authoritative ─────────────────────
-  test('deriveStateFromDb ignores QUEUE-ORDER.json and uses DB sequence', async () => {
+  // ─── Queue order: explicit file order repairs stale DB sequence ─────
+  test('deriveStateFromDb syncs QUEUE-ORDER.json into DB sequence', async () => {
     const base = createFixtureBase();
     try {
-      // QUEUE-ORDER.json is a projection and should not drive DB derivation.
       const queueOrder = JSON.stringify({ order: ['M003', 'M001', 'M002'], updatedAt: new Date().toISOString() });
       writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), queueOrder);
       writeFile(base, 'milestones/M001/M001-CONTEXT.md', '# M001\n\nContext.');
@@ -466,8 +466,52 @@ describe('derive-state-helpers', () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      assert.equal(state.activeMilestone?.id, 'M002', 'queue-order: DB sequence chooses M002');
-      assert.equal(state.registry[0]?.id, 'M002', 'queue-order: registry[0] follows DB sequence');
+      assert.equal(state.activeMilestone?.id, 'M003', 'queue-order: QUEUE-ORDER.json chooses M003');
+      assert.equal(state.registry[0]?.id, 'M003', 'queue-order: registry[0] follows QUEUE-ORDER.json');
+      assert.deepEqual(getAllMilestones().map(m => m.id), ['M003', 'M001', 'M002'], 'queue-order: DB sequence is repaired');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  // ─── Queue order: milestone absent from file gets explicit sequence (idempotency) ─
+  test('deriveStateFromDb sync is idempotent when a milestone is omitted from QUEUE-ORDER.json', async () => {
+    const base = createFixtureBase();
+    try {
+      // QUEUE-ORDER.json lists only M002 and M001; M003 is absent.
+      const queueOrder = JSON.stringify({ order: ['M002', 'M001'], updatedAt: new Date().toISOString() });
+      writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), queueOrder);
+      writeFile(base, 'milestones/M001/M001-CONTEXT.md', '# M001\n\nContext.');
+      writeFile(base, 'milestones/M002/M002-CONTEXT.md', '# M002\n\nContext.');
+      writeFile(base, 'milestones/M003/M003-CONTEXT.md', '# M003\n\nContext.');
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'active' });
+      insertMilestone({ id: 'M002', title: 'Second', status: 'active' });
+      insertMilestone({ id: 'M003', title: 'Third', status: 'active' });
+      // DB starts with natural order M001→M002→M003 (stale vs the file's M002→M001).
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      // After sync, M002 leads (per file), M003 is appended at the end.
+      assert.equal(state.activeMilestone?.id, 'M002', 'omitted-milestone: QUEUE-ORDER.json chooses M002 as active');
+      assert.deepEqual(
+        getAllMilestones().map(m => m.id),
+        ['M002', 'M001', 'M003'],
+        'omitted-milestone: DB sequence is M002, M001, M003 with M003 appended',
+      );
+
+      // Second derive must not re-write the DB (idempotency guard holds).
+      invalidateStateCache();
+      const state2 = await deriveStateFromDb(base);
+      assert.equal(state2.activeMilestone?.id, 'M002', 'omitted-milestone: second derive still picks M002');
+      assert.deepEqual(
+        getAllMilestones().map(m => m.id),
+        ['M002', 'M001', 'M003'],
+        'omitted-milestone: DB sequence unchanged on second call',
+      );
     } finally {
       closeDatabase();
       cleanup(base);

package/src/resources/extensions/gsd/tests/discuss-cold-start-db-open.test.ts

@@ -1,16 +1,13 @@
 /**
  * Behavioural regression test for #5837.
  *
- * /gsd discuss silently exited on cold-start because showDiscuss() derived
- * workflow state before opening the DB. On a cold-start session the DB file
- * exists on disk but is not open in-process, so deriveState() takes the
- * "DB unavailable" branch, reports no active milestone, and showDiscuss()
- * exits as if the project had no milestones.
+ * /gsd discuss and /gsd auto can cold-start with a DB file on disk but no
+ * in-process connection yet. State derivation must open that existing DB
+ * before it decides whether DB-backed state is available.
  *
- * The fix moves `ensureDbOpen(basePath)` ahead of `deriveState()`. This test
- * pins that ordering contract at the behavioural level: with a milestone
- * living only in the DB, deriveState() surfaces nothing until the DB is
- * opened, and surfaces the milestone once ensureDbOpen() has run.
+ * This test pins that behavioural contract: with a milestone living only in
+ * the DB, deriveState() surfaces it even when the process begins with no DB
+ * handle open.
  */
 
 import { describe, test, afterEach } from "node:test";
@@ -19,7 +16,6 @@ import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { ensureDbOpen } from "../bootstrap/dynamic-tools.ts";
 import { openDatabase, closeDatabase, isDbAvailable, insertMilestone } from "../gsd-db.ts";
 import { deriveState, invalidateStateCache } from "../state.ts";
 
@@ -29,7 +25,7 @@ afterEach(() => {
 });
 
 describe("discuss cold-start DB ordering (#5837)", () => {
-  test("deriveState only surfaces a DB-resident milestone after ensureDbOpen runs", async () => {
+  test("deriveState opens an existing DB before reading a DB-resident milestone", async () => {
     const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-discuss-cold-")));
     try {
       mkdirSync(join(base, ".gsd"), { recursive: true });
@@ -42,26 +38,13 @@ describe("discuss cold-start DB ordering (#5837)", () => {
       closeDatabase();
       invalidateStateCache();
 
-      // Before ensureDbOpen(): showDiscuss's pre-fix ordering. The DB is not
-      // open, so state derivation cannot see the milestone — the silent exit.
       const coldState = await deriveState(base);
       assert.equal(
-        coldState.activeMilestone,
-        null,
-        "without an open DB, deriveState must not surface the milestone — this is the cold-start silent-exit bug",
-      );
-      assert.equal(isDbAvailable(), false, "DB must still be closed before ensureDbOpen");
-
-      // The fix: ensureDbOpen(basePath) runs before deriveState.
-      assert.equal(await ensureDbOpen(base), true, "ensureDbOpen must open the cold-start DB");
-      invalidateStateCache();
-
-      const warmState = await deriveState(base);
-      assert.equal(
-        warmState.activeMilestone?.id,
+        coldState.activeMilestone?.id,
         "M001",
-        "after ensureDbOpen, deriveState must surface the DB-resident milestone so /gsd discuss does not silently exit",
+        "cold-start deriveState must open and read the existing workflow DB",
       );
+      assert.equal(isDbAvailable(), true, "deriveState must leave the existing DB open for downstream reads");
     } finally {
       if (isDbAvailable()) closeDatabase();
       invalidateStateCache();

package/src/resources/extensions/gsd/tests/dispatch-complete-milestone-guard.test.ts

@@ -7,7 +7,7 @@
 
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
@@ -16,6 +16,7 @@ import { DISPATCH_RULES, resolveDispatch, type DispatchContext } from "../auto-d
 import { AutoSession } from "../auto/session.ts";
 import {
   closeDatabase,
+  getLatestAssessmentByScope,
   getPendingGates,
   insertAssessment,
   insertGateRow,
@@ -99,6 +100,23 @@ describe("completing-milestone dispatch guard (#4324)", () => {
     assert.equal(result?.unitId, "M001");
   });
 
+  test("records pass-through validation before completing-milestone dispatch when validation is absent (#823)", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete" });
+
+    const result = await rule.match(buildDispatchCtx(base));
+
+    assert.equal(result?.action, "dispatch");
+    assert.equal(result?.unitType, "complete-milestone");
+    const validation = getLatestAssessmentByScope("M001", "milestone-validation");
+    assert.equal(validation?.status, "pass");
+    const validationPath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+    assert.equal(existsSync(validationPath), true);
+    assert.match(readFileSync(validationPath, "utf-8"), /skip_validation_reason: closeout-recovery/);
+  });
+
   test("resolveDispatch stops complete-milestone when unit is exhausted in-session (#5662)", async () => {
     base = makeBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
@@ -303,6 +321,7 @@ describe("complete phase dispatch guard (#5683)", () => {
     assert.equal(result?.level, "warning");
     assert.match(result?.reason ?? "", /closeout-consistency-blocked/);
     assert.match(result?.reason ?? "", /latest milestone validation is "absent"/);
+    assert.match(result?.reason ?? "", /\/gsd validate-milestone M001/);
   });
 });
 

package/src/resources/extensions/gsd/tests/dispatch-db-degradation-logs.test.ts

@@ -0,0 +1,98 @@
+// gsd-pi — Dispatch DB-degradation log coverage.
+//
+// `hasMilestonePassedDiscuss` (auto-dispatch.ts:397) queries the slices table to
+// decide whether a milestone has progressed past discuss. When the DB is
+// available but the query throws (corrupt schema, dropped table, locked DB),
+// the catch (auto-dispatch.ts:407) logs a `dispatch` warning and falls back to
+// the filesystem. That warning is the operator's only signal that dispatch
+// silently degraded to filesystem heuristics; no test asserted it. This file
+// triggers it by opening a DB, seeding a milestone, then dropping the slices
+// table so getMilestoneSlices() throws inside the rule's DB branch.
+//
+// Companion to dispatch-logs.test.ts (registry fallback :1834).
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolveDispatch, DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+  _getAdapter,
+} from "../gsd-db.ts";
+import {
+  drainLogs,
+  setStderrLoggingEnabled,
+  _resetLogs,
+  type LogEntry,
+} from "../workflow-logger.ts";
+import { convertDispatchRules, initRegistry, getRegistry, resetRegistry } from "../rule-registry.ts";
+
+function makeExecutingState(): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Degraded" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "executing",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+  } as GSDState;
+}
+
+test("hasMilestonePassedDiscuss logs a dispatch warning when the DB slices query throws", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-dispatch-db-degrade-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+
+  // Snapshot + (re)initialize the registry so resolveDispatch uses the inline
+  // rule set, then restore the prior state afterwards.
+  let previousExists = false;
+  try { getRegistry(); previousExists = true; } catch { previousExists = false; }
+  initRegistry(convertDispatchRules(DISPATCH_RULES));
+
+  const previousStderr = setStderrLoggingEnabled(false);
+  let logs: LogEntry[] = [];
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Degraded", status: "active" });
+    // Break the slices table so getMilestoneSlices("M001") throws inside the
+    // DB branch of hasMilestonePassedDispatch → :407 warning.
+    _getAdapter()!.exec("DROP TABLE slices");
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Degraded",
+      state: makeExecutingState(),
+      prefs: undefined,
+    };
+
+    // resolveDispatch must not throw — the rule catches the DB error and falls
+    // back to the filesystem. We assert only that the degradation warning lands.
+    await resolveDispatch(ctx);
+    logs = drainLogs();
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previousStderr);
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+    // Restore registry state for subsequent tests.
+    initRegistry(convertDispatchRules(DISPATCH_RULES));
+    if (!previousExists) resetRegistry();
+    void t;
+  }
+
+  const warn = logs.find((e) => e.component === "dispatch" && e.severity === "warn");
+  assert.ok(warn, "a dispatch warning must be logged when the slices query fails");
+  assert.match(
+    warn!.message,
+    /discuss-progress DB check failed for M001, falling back to filesystem/u,
+    "warning must name the milestone and the filesystem fallback",
+  );
+});