@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

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",
+  );
+});

package/src/resources/extensions/gsd/tests/dispatch-history.test.ts

@@ -23,6 +23,7 @@ import { recordDispatchClaim, markFailed, markCanceled } from "../db/unit-dispat
 import {
   buildDispatchKey,
   createDispatchHistory,
+  lookupLatestLedgerError,
   normalizeDispatchKey,
   parseDispatchKey,
   STUCK_WINDOW_SIZE,
@@ -157,6 +158,31 @@ test("recordDispatch attaches the latest ledger error on repeats so repeat-error
   assert.match(verdict?.reason ?? "", /Same error repeated/);
 });
 
+test("lookupLatestLedgerError matches the bare unit id, not the compound key", (t) => {
+  const f = makeLedgerFixture(t);
+  const dispatchId = f.claim("execute-task", "M001/S01/T01");
+  markFailed(dispatchId, { errorSummary: "boom: deterministic failure" });
+
+  // The ledger keys rows by the bare unit id with the unit type in its own
+  // column. The shared lookup (also used by dispatch.ts's runDispatch path)
+  // must use the bare id; a compound `unitType/unitId` value misses entirely,
+  // which previously silently dropped repeat-error detection on that path.
+  assert.equal(
+    lookupLatestLedgerError("execute-task", "M001/S01/T01"),
+    "boom: deterministic failure",
+  );
+  assert.equal(
+    lookupLatestLedgerError("execute-task", "execute-task/M001/S01/T01"),
+    undefined,
+    "a compound key must not match the bare-id ledger row",
+  );
+  assert.equal(
+    lookupLatestLedgerError("plan-slice", "M001/S01/T01"),
+    undefined,
+    "a different unit type on the same id must not be attached",
+  );
+});
+
 test("recordDispatch never attaches another unit type's ledger error for the same unit id", (t) => {
   const f = makeLedgerFixture(t);
   const dispatchId = f.claim("plan-slice", "M001/S01");
@@ -262,6 +288,35 @@ test("#482 regression: a re-dispatch loop spanning a session restart is detected
   assert.match(verdict?.reason ?? "", /execute-task:M001\/S01\/T01 derived 3 consecutive times/);
 });
 
+test("rehydrate mirrors recordDispatch error attachment so repeat-error detection fires after the next dispatch", (t) => {
+  const f = makeLedgerFixture(t);
+  // Session 1: two failed dispatches for the same unit, same error summary.
+  for (let i = 0; i < 2; i++) {
+    const id = f.claim("execute-task", "M001/S01/T01");
+    markFailed(id, { errorSummary: "boom: deterministic failure" });
+  }
+
+  // Session 2: fresh history rehydrates from the ledger. Just like the live
+  // recordDispatch path, the first occurrence of a unit skips the ledger
+  // lookup; only repeats carry the error. So rehydration alone does not trip
+  // Rule 1 — keeping the post-restart window no more aggressive than the live
+  // one (Rule 1 has no retry-budget suppression).
+  const restarted = historyFor(f.base);
+  const count = restarted.rehydrate();
+  assert.equal(count, 2);
+  const window = restarted.getRecentWindow();
+  assert.equal(window[0].error, undefined);
+  assert.equal(window[1].error, "boom: deterministic failure");
+  assert.equal(restarted.detectStuck(), null);
+
+  // The next dispatch of the same unit attaches the error again, giving two
+  // consecutive matching errors → Rule 1 fires, exactly as in the live path.
+  restarted.recordDispatch("execute-task", "M001/S01/T01");
+  const verdict = restarted.detectStuck();
+  assert.equal(verdict?.stuck, true);
+  assert.match(verdict?.reason ?? "", /Same error repeated/);
+});
+
 test("rehydrate degrades to an empty window without a scope or ledger", () => {
   const noScope = historyFor(null);
   assert.equal(noScope.rehydrate(), 0);

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

@@ -0,0 +1,103 @@
+// gsd-pi — Dispatch-path log coverage.
+//
+// `resolveDispatch` delegates to the rule registry when one is initialized
+// (auto-dispatch.ts:1818-1835). If `getRegistry()` throws — e.g. the registry
+// was never initialized or was reset — the catch logs a `dispatch` warning
+// ("registry dispatch failed, falling back to inline rules") and falls through
+// to the inline DISPATCH_RULES loop. That warning is the operator's only signal
+// that dispatch silently degraded from registry-driven to inline; no test
+// asserted it. This file pins it.
+//
+// Strategy: resetRegistry() so getRegistry() throws, then call resolveDispatch
+// with a minimal no-DB context. We assert the warning lands and that the
+// function still returns a DispatchAction rather than throwing (resilience).
+
+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 { resolveDispatch, DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import {
+  convertDispatchRules,
+  getRegistry,
+  initRegistry,
+  resetRegistry,
+} from "../rule-registry.ts";
+import {
+  drainLogs,
+  setStderrLoggingEnabled,
+  _resetLogs,
+  type LogEntry,
+} from "../workflow-logger.ts";
+
+/**
+ * Build a minimal DispatchContext that passes resolveDispatch's early guards
+ * without a database:
+ *  - isDbAvailable() is false → the closed-milestone guard is skipped.
+ *  - activeMilestone is null → the activeMid/scope mismatch guards are skipped.
+ * So execution reaches the registry delegation block.
+ */
+function makeMinimalCtx(basePath: string): DispatchContext {
+  return {
+    basePath,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    prefs: undefined,
+    state: {
+      activeMilestone: null,
+      activeSlice: null,
+      activeTask: null,
+      phase: "unhandled",
+      recentDecisions: [],
+      blockers: [],
+      nextAction: "",
+      registry: [],
+    } as unknown as DispatchContext["state"],
+  };
+}
+
+test("resolveDispatch logs a dispatch warning and falls back to inline rules when the registry is uninitialized", async () => {
+  // Snapshot and clear the singleton so getRegistry() throws inside resolveDispatch.
+  let previousExists = false;
+  try {
+    getRegistry();
+    previousExists = true;
+  } catch {
+    previousExists = false;
+  }
+  resetRegistry();
+
+  const base = mkdtempSync(join(tmpdir(), "gsd-dispatch-logs-"));
+  const previousStderr = setStderrLoggingEnabled(false);
+  _resetLogs();
+  let logs: LogEntry[] = [];
+  try {
+    // resolveDispatch must NOT throw — it catches the registry failure, logs,
+    // and falls through to inline DISPATCH_RULES.
+    const action = await resolveDispatch(makeMinimalCtx(base));
+    assert.ok(action, "resolveDispatch must still return a DispatchAction after registry failure");
+    logs = drainLogs();
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previousStderr);
+    rmSync(base, { recursive: true, force: true });
+    // Restore a usable registry for any subsequent test in the process.
+    initRegistry(convertDispatchRules(DISPATCH_RULES));
+    if (!previousExists) resetRegistry();
+  }
+
+  const warn = logs.find((e) => e.component === "dispatch" && e.severity === "warn");
+  assert.ok(warn, "a dispatch warning must be logged when the registry is unavailable");
+  assert.match(
+    warn!.message,
+    /registry dispatch failed, falling back to inline rules/u,
+    "warning must identify the registry fallback reason",
+  );
+  assert.match(
+    warn!.message,
+    /not initialized/u,
+    "warning must carry the underlying getRegistry() error detail",
+  );
+});

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

@@ -0,0 +1,98 @@
+// gsd-pi — Dispatch reactive graph derivation log coverage.
+//
+// The "executing → reactive-execute" rule wraps its graph derivation in a
+// best-effort catch (auto-dispatch.ts:1492-1496) that logs a `dispatch` ERROR
+// "reactive graph derivation failed" and falls through to sequential execution.
+// The catch is otherwise unreachable because every operation it wraps
+// (loadSliceTaskIO, deriveTaskGraph, saveReactiveState) is internally
+// defensive — so we inject a throwing derive function via the sanctioned
+// setReactiveGraphDeriveFnForTest seam (mirroring the :1809 / :637 pattern) to
+// deterministically exercise the failure path.
+
+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,
+  setReactiveGraphDeriveFnForTest,
+  type DispatchContext,
+} from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+import {
+  drainLogs,
+  setStderrLoggingEnabled,
+  _resetLogs,
+  type LogEntry,
+} from "../workflow-logger.ts";
+import { convertDispatchRules, initRegistry, getRegistry, resetRegistry } from "../rule-registry.ts";
+
+function makeExecutingCtx(base: string): DispatchContext {
+  return {
+    basePath: base,
+    mid: "M001",
+    midTitle: "Milestone",
+    state: {
+      phase: "executing",
+      activeMilestone: { id: "M001", title: "Milestone", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      activeTask: { id: "T01", title: "Task" },
+      registry: [],
+      blockers: [],
+    } as unknown as GSDState,
+    // Explicit opt-in keeps the legacy min-ready threshold (2) and ensures the
+    // rule proceeds past the enabled/maxParallel guards into the derivation try.
+    prefs: { reactive_execution: { enabled: true, max_parallel: 2 } } as DispatchContext["prefs"],
+  };
+}
+
+test("reactive rule logs a dispatch error when graph derivation throws (auto-dispatch.ts:1494)", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-reactive-logs-"));
+  // Minimal slice projection so the rule's earlier filesystem guards resolve.
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01\n\n## Tasks\n\n- [ ] **T01: A**\n", "utf-8");
+
+  // Snapshot + initialize the registry so resolveDispatch uses the inline rules.
+  let previousExists = false;
+  try { getRegistry(); previousExists = true; } catch { previousExists = false; }
+  initRegistry(convertDispatchRules(DISPATCH_RULES));
+
+  // Inject a throwing derive fn so the rule's try block (auto-dispatch.ts:1414+)
+  // throws before any defensive operation, hitting the :1494 catch.
+  const restoreDerive = setReactiveGraphDeriveFnForTest(async () => {
+    throw new Error("forced graph derivation failure");
+  });
+
+  const previousStderr = setStderrLoggingEnabled(false);
+  _resetLogs();
+  let logs: LogEntry[] = [];
+  try {
+    // resolveDispatch must NOT throw — the rule catches the derivation failure
+    // and falls through to sequential execution.
+    await resolveDispatch(makeExecutingCtx(base));
+    logs = drainLogs();
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previousStderr);
+    restoreDerive();
+    initRegistry(convertDispatchRules(DISPATCH_RULES));
+    if (!previousExists) resetRegistry();
+    rmSync(base, { recursive: true, force: true });
+    void t;
+  }
+
+  const err = logs.find(
+    (e) => e.component === "dispatch" && e.severity === "error" && /reactive graph derivation failed/u.test(e.message),
+  );
+  assert.ok(
+    err,
+    "a dispatch ERROR must be logged when reactive graph derivation fails (got: " +
+      logs.filter((e) => e.component === "dispatch").map((e) => e.message).join(" | ") + ")",
+  );
+  assert.equal(err!.message, "reactive graph derivation failed");
+  assert.match(err!.context?.error ?? "", /forced graph derivation failure/u);
+});

package/src/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -7,6 +7,10 @@ const require = createRequire(import.meta.url);
 const ROOT = new URL("../../../../../", import.meta.url);
 
 export function resolve(specifier, context, nextResolve) {
+  if (specifier.startsWith('node:')) {
+    return { url: specifier, format: 'builtin', shortCircuit: true };
+  }
+
   // 1. Redirect all workspace package bare imports to source.
   //    CI portability runs don't build any packages/ dist artifacts, so every
   //    @gsd/* specifier (including transitive ones pulled in by pi-coding-agent
@@ -100,6 +104,10 @@ export function resolve(specifier, context, nextResolve) {
 }
 
 export function load(url, context, nextLoad) {
+  if (url.startsWith('node:') || context.format === 'builtin') {
+    return { format: 'builtin', source: '', shortCircuit: true };
+  }
+
   // jiti/CJS may still enter through stale packages/*/dist/index.js — redirect to src.
   if (url.includes('/packages/pi-ai/dist/index.js')) {
     url = url.replace('/dist/index.js', '/src/index.ts');

package/src/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -338,6 +338,7 @@ test("runProviderChecks detects custom provider keys from models.json", () => {
     join(repo, ".gsd", "PREFERENCES.md"),
     [
       "---",
+      "token_profile: burn-max",
       "models:",
       "  execution:",
       "    model: custom-model",
@@ -514,6 +515,7 @@ test("runProviderChecks uses provider-qualified anthropic-vertex model IDs", ()
     join(repo, ".gsd", "PREFERENCES.md"),
     [
       "---",
+      "token_profile: burn-max",
       "models:",
       "  execution: anthropic-vertex/claude-sonnet-4-6",
       "---",
@@ -605,6 +607,7 @@ test("runProviderChecks reports ok for Google via google-gemini-cli auth.json (#
 
   withEnv({
     HOME: tmpHome,
+    PATH: tmpHome,
     GEMINI_API_KEY: undefined,
     GOOGLE_API_KEY: undefined,
   }, () => {
@@ -904,17 +907,16 @@ test("runProviderChecks detects claude.exe in PATH on Windows (#4548)", { skip:
   });
 });
 
-test("PROVIDER_ROUTES includes google-gemini-cli as route for google (#2922)", async () => {
+test("PROVIDER_ROUTES includes google-antigravity and google-gemini-cli as routes for google (#2922)", async () => {
   const { readFileSync: readFS } = await import("node:fs");
   const { dirname: dirn, join: joinPath } = await import("node:path");
   const { fileURLToPath: fileUrl } = await import("node:url");
   const __dir = dirn(fileUrl(import.meta.url));
   const src = readFS(joinPath(__dir, "..", "doctor-providers.ts"), "utf-8");
 
-  // PROVIDER_ROUTES must map google -> [..., "google-gemini-cli"]
   assert.ok(
-    src.includes('"google-gemini-cli"'),
-    'PROVIDER_ROUTES must include "google-gemini-cli" as a route (#2922)',
+    src.includes('google: ["google-antigravity", "google-gemini-cli"]'),
+    'PROVIDER_ROUTES must prefer "google-antigravity" over "google-gemini-cli" for google (#2922)',
   );
 });