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

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/discuss-routing-fixes.test.ts

@@ -39,7 +39,11 @@ function makeDiscussPi() {
     tmp,
     pi: {
       getActiveTools: () => ["gsd_summary_save", "bash"],
+      emitAdjustToolSet: async () => undefined,
+      emitBeforeModelSelect: async () => undefined,
+      setModel: async () => true,
       setActiveTools: () => {},
+      setThinkingLevel: () => {},
       sendMessage: (message: { content?: unknown }) => {
         sent.push(message);
       },
@@ -53,6 +57,7 @@ function makeDiscussPi() {
 }
 
 function makeDiscussCtx(notifications: Array<{ message: string; level?: string }> = []) {
+  const model = { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" };
   return {
     hasUI: true,
     sessionManager: {
@@ -65,8 +70,13 @@ function makeDiscussCtx(notifications: Array<{ message: string; level?: string }
       setStatus: () => {},
     },
     waitForIdle: async () => {},
-    model: undefined,
-    modelRegistry: { getProviderAuthMode: () => undefined },
+    model,
+    modelRegistry: {
+      getAvailable: () => [model],
+      getAll: () => [model],
+      getProviderAuthMode: () => "apiKey",
+      isProviderRequestReady: () => true,
+    },
   };
 }
 

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

@@ -7,14 +7,23 @@
 
 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";
 
 import { DISPATCH_RULES, resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
 import { AutoSession } from "../auto/session.ts";
-import { closeDatabase, insertAssessment, insertGateRow, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import {
+  closeDatabase,
+  getLatestAssessmentByScope,
+  getPendingGates,
+  insertAssessment,
+  insertGateRow,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-complete-dispatch-"));
@@ -91,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"));
@@ -243,7 +269,7 @@ describe("complete phase dispatch guard (#5683)", () => {
     assert.equal(result?.reason, "All milestones complete.");
   });
 
-  test("blocks terminal stop when closed milestone still has pending gates", async () => {
+  test("closes stale pending gates from milestone validation before terminal stop", async () => {
     base = makeBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
@@ -268,10 +294,34 @@ describe("complete phase dispatch guard (#5683)", () => {
 
     const result = await rule.match(ctx);
 
+    assert.equal(result?.action, "stop");
+    assert.equal(result?.reason, "All milestones complete.");
+    assert.deepEqual(getPendingGates("M001", "S01"), []);
+  });
+
+  test("blocks terminal stop when pending gates have no closeout evidence", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete" });
+    insertGateRow({
+      milestoneId: "M001",
+      sliceId: "S01",
+      gateId: "Q3",
+      scope: "slice",
+      status: "pending",
+    });
+
+    const ctx = buildDispatchCtx(base);
+    ctx.state.phase = "complete";
+
+    const result = await rule.match(ctx);
+
     assert.equal(result?.action, "stop");
     assert.equal(result?.level, "warning");
     assert.match(result?.reason ?? "", /closeout-consistency-blocked/);
-    assert.match(result?.reason ?? "", /quality gate Q3 is still pending/);
+    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",
+  );
+});