gsd-pi 2.71.0-dev.e17e0ce → 2.72.0-dev.3118184

package/src/resources/extensions/gsd/prompts/execute-task.md

@@ -22,6 +22,8 @@ A researcher explored the codebase and a planner decomposed the work — you are
 
 {{slicePlanExcerpt}}
 
+{{gatesToClose}}
+
 ## Backing Source Artifacts
 - Slice plan: `{{planPath}}`
 - Task plan source: `{{taskPlanPath}}`

package/src/resources/extensions/gsd/prompts/system.md

@@ -35,7 +35,7 @@ GSD ships with bundled skills. Load the relevant skill file with the `read` tool
 - Read before edit.
 - Reproduce before fix when possible.
 - Work is not done until the relevant verification has passed.
-- **Never fabricate, simulate, or role-play user responses.** Never generate markers like `[User]`, `[Human]`, `User:`, or similar to represent user input inside your own output. Ask one question round (1-3 questions), then stop and wait for the user's actual response before continuing. If `ask_user_questions` is available, treat its returned response as the only valid structured user input for that round.
+- **Never fabricate, simulate, or role-play user responses.** Never generate markers like `[User]`, `[Human]`, `User:`, or similar to represent user input inside your own output. Prior conversation context may be provided to you inside `<conversation_history>` with `<user_message>` / `<assistant_message>` XML tags — treat those as read-only context and never emit those tags in your response. Ask one question round (1-3 questions), then stop and wait for the user's actual response before continuing. If `ask_user_questions` is available, treat its returned response as the only valid structured user input for that round.
 - Never print, echo, log, or restate secrets or credentials. Report only key names and applied/skipped status.
 - Never ask the user to edit `.env` files or set secrets manually. Use `secure_env_collect`.
 - In enduring files, write current state only unless the file is explicitly historical.

package/src/resources/extensions/gsd/prompts/validate-milestone.md

@@ -18,6 +18,8 @@ All relevant context has been preloaded below — the roadmap, all slice summari
 
 {{inlinedContext}}
 
+{{gatesToEvaluate}}
+
 ## Execution Protocol
 
 ### Step 1 — Dispatch Parallel Reviewers

package/src/resources/extensions/gsd/shortcut-defs.ts

@@ -8,6 +8,8 @@ type GSDShortcutDef = {
   key: "g" | "n" | "p";
   action: string;
   command: string;
+  /** Whether the Ctrl+Shift fallback is registered (false when it conflicts with an app keybinding). */
+  hasFallback: boolean;
 };
 
 export const GSD_SHORTCUTS: Record<GSDShortcutId, GSDShortcutDef> = {
@@ -15,16 +17,19 @@ export const GSD_SHORTCUTS: Record<GSDShortcutId, GSDShortcutDef> = {
     key: "g",
     action: "Open GSD dashboard",
     command: "/gsd status",
+    hasFallback: true,
   },
   notifications: {
     key: "n",
     action: "Open notification history",
     command: "/gsd notifications",
+    hasFallback: true,
   },
   parallel: {
     key: "p",
     action: "Open parallel worker monitor",
     command: "/gsd parallel watch",
+    hasFallback: false, // Ctrl+Shift+P conflicts with cycleModelBackward
   },
 };
 
@@ -41,7 +46,9 @@ export function fallbackShortcutCombo(id: GSDShortcutId): string {
 }
 
 export function shortcutPair(id: GSDShortcutId, formatter: (combo: string) => string = (combo) => combo): string {
-  return `${formatter(primaryShortcutCombo(id))} / ${formatter(fallbackShortcutCombo(id))}`;
+  const primary = formatter(primaryShortcutCombo(id));
+  if (!GSD_SHORTCUTS[id].hasFallback) return primary;
+  return `${primary} / ${formatter(fallbackShortcutCombo(id))}`;
 }
 
 export function formattedShortcutPair(id: GSDShortcutId): string {

package/src/resources/extensions/gsd/state.ts

@@ -57,8 +57,9 @@ import {
   insertMilestone,
   insertSlice,
   insertTask,
+  updateSliceStatus,
   updateTaskStatus,
-  getPendingSliceGateCount,
+  getPendingGateCountForTurn,
   type MilestoneRow,
   type SliceRow,
   type TaskRow,
@@ -358,6 +359,25 @@ function reconcileDiskToDb(basePath: string): MilestoneRow[] {
         depends: s.depends, demo: s.demo,
       });
     }
+
+    // Reconcile stale *existing* slice rows (#3599): a slice row may exist in
+    // the DB with status "pending" even though disk artifacts (SUMMARY) prove
+    // completion — the same class of desync that task-level reconciliation
+    // (further below) already handles.  Without this, the dependency resolver
+    // builds doneSliceIds from stale DB rows and downstream slices stay blocked
+    // forever with "No slice eligible".
+    for (const dbSlice of dbSlices) {
+      if (isStatusDone(dbSlice.status)) continue;
+      const summaryPath = resolveSliceFile(basePath, mid, dbSlice.id, "SUMMARY");
+      if (summaryPath) {
+        try {
+          updateSliceStatus(mid, dbSlice.id, "complete");
+          logWarning("reconcile", `slice ${mid}/${dbSlice.id} status reconciled from "${dbSlice.status}" to "complete" (#3599)`, { mid, sid: dbSlice.id });
+        } catch (e) {
+          logError("reconcile", `failed to update slice ${dbSlice.id}`, { sid: dbSlice.id, error: (e as Error).message });
+        }
+      }
+    }
   }
   return allMilestones;
 }
@@ -864,7 +884,18 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
     }
   }
 
-  const pendingGateCount = getPendingSliceGateCount(activeMilestone.id, activeSlice.id);
+  // ── Quality gate evaluation check ──────────────────────────────────
+  // Pause before execution only when gates owned by the `gate-evaluate`
+  // turn (Q3/Q4) are still pending. Q8 is also `scope:"slice"` but is
+  // owned by `complete-slice`, so it must NOT block the evaluating-gates
+  // phase — otherwise auto-loop stalls forever waiting for a gate that
+  // this turn never evaluates. See gate-registry.ts for the ownership map.
+  // Slices with zero gate rows (pre-feature or simple) skip straight through.
+  const pendingGateCount = getPendingGateCountForTurn(
+    activeMilestone.id,
+    activeSlice.id,
+    "gate-evaluate",
+  );
   if (pendingGateCount > 0) {
     return {
       activeMilestone, activeSlice, activeTask: null,

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -0,0 +1,27 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const autoSource = readFileSync(join(__dirname, "..", "auto.ts"), "utf-8");
+
+test("#3370: cleanupAfterLoopExit preserves paused auto badge after provider pause", () => {
+  const cleanupIdx = autoSource.indexOf("function cleanupAfterLoopExit");
+  assert.ok(cleanupIdx > -1, "auto.ts should define cleanupAfterLoopExit");
+
+  const dispatchIdx = autoSource.indexOf("export async function dispatchHookUnit", cleanupIdx);
+  assert.ok(dispatchIdx > cleanupIdx, "cleanupAfterLoopExit body should be bounded by the next export");
+
+  const cleanupBody = autoSource.slice(cleanupIdx, dispatchIdx);
+  const pausedGuardIdx = cleanupBody.indexOf("if (!s.paused) {");
+  const clearStatusIdx = cleanupBody.indexOf('ctx.ui.setStatus("gsd-auto", undefined);');
+
+  assert.ok(pausedGuardIdx > -1, "loop-exit cleanup must guard UI clearing when auto is paused");
+  assert.ok(clearStatusIdx > pausedGuardIdx, "status clearing must live behind the paused guard");
+  assert.ok(
+    autoSource.includes('ctx?.ui.setStatus("gsd-auto", "paused");'),
+    "pauseAuto must still set the paused badge for transient provider pauses",
+  );
+});

package/src/resources/extensions/gsd/tests/auto-start-model-capture.test.ts

@@ -48,3 +48,17 @@ test("bootstrapAutoSession checks manual session override before preferences", (
     "manual override and preference fallback must be resolved before building startModelSnapshot",
   );
 });
+
+test("bootstrapAutoSession validates preferred model against live registry auth (#unconfigured-models)", () => {
+  // The raw PREFERENCES.md value must be validated against getAvailable()
+  // before being captured as the snapshot, so an unconfigured provider
+  // (no API key / OAuth) can't become autoModeStartModel.
+  const validationIdx = source.indexOf("ctx.modelRegistry.getAvailable()");
+  assert.ok(validationIdx > -1, "auto-start.ts should validate preferred model against getAvailable()");
+
+  const resolveModelIdIdx = source.indexOf("resolveModelId");
+  assert.ok(resolveModelIdIdx > -1, "auto-start.ts should resolve preferred model against the registry");
+
+  const warningIdx = source.indexOf("is not configured; falling back to session default");
+  assert.ok(warningIdx > -1, "auto-start.ts should warn when preferred model is unconfigured");
+});

package/src/resources/extensions/gsd/tests/block-db-writes.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Regression test for #3674 — block direct writes to gsd.db
+ *
+ * When gsd_complete_task was unavailable, agents fell back to shell-based
+ * sqlite3 writes, corrupting the WAL-backed database. The fix extends
+ * write-intercept to block file writes and bash commands targeting gsd.db.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { isBlockedStateFile, isBashWriteToStateFile } from '../write-intercept.ts';
+
+describe('isBlockedStateFile blocks gsd.db paths (#3674)', () => {
+  test('blocks .gsd/gsd.db', () => {
+    assert.ok(isBlockedStateFile('/project/.gsd/gsd.db'));
+  });
+
+  test('blocks .gsd/gsd.db-wal', () => {
+    assert.ok(isBlockedStateFile('/project/.gsd/gsd.db-wal'));
+  });
+
+  test('blocks .gsd/gsd.db-shm', () => {
+    assert.ok(isBlockedStateFile('/project/.gsd/gsd.db-shm'));
+  });
+
+  test('blocks resolved symlink path under .gsd/projects/', () => {
+    assert.ok(isBlockedStateFile('/home/user/.gsd/projects/myproj/gsd.db'));
+  });
+
+  test('still blocks STATE.md', () => {
+    assert.ok(isBlockedStateFile('/project/.gsd/STATE.md'));
+  });
+
+  test('does not block other .gsd files', () => {
+    assert.ok(!isBlockedStateFile('/project/.gsd/DECISIONS.md'));
+  });
+});
+
+describe('isBashWriteToStateFile blocks DB shell commands (#3674)', () => {
+  test('blocks sqlite3 targeting gsd.db', () => {
+    assert.ok(isBashWriteToStateFile('sqlite3 .gsd/gsd.db "INSERT INTO ..."'));
+  });
+
+  test('blocks better-sqlite3 targeting gsd.db', () => {
+    assert.ok(isBashWriteToStateFile('node -e "require(\'better-sqlite3\')(\'.gsd/gsd.db\')"'));
+  });
+
+  test('blocks shell redirect to gsd.db', () => {
+    assert.ok(isBashWriteToStateFile('echo data > .gsd/gsd.db'));
+  });
+
+  test('blocks cp to gsd.db', () => {
+    assert.ok(isBashWriteToStateFile('cp backup.db .gsd/gsd.db'));
+  });
+
+  test('blocks mv to gsd.db', () => {
+    assert.ok(isBashWriteToStateFile('mv temp.db .gsd/gsd.db'));
+  });
+
+  test('does not block reading gsd.db with cat', () => {
+    assert.ok(!isBashWriteToStateFile('cat .gsd/gsd.db'));
+  });
+});

package/src/resources/extensions/gsd/tests/complete-slice-gate-closure.test.ts

@@ -0,0 +1,167 @@
+/**
+ * complete-slice gate closure integration test.
+ *
+ * Pins the fix for the Q8-stall bug: complete-slice must close every gate
+ * owned by the complete-slice turn based on the content of the matching
+ * CompleteSliceParams field. Without this, Q8 stays pending forever and
+ * blocks state derivation on subsequent loops.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  insertGateRow,
+  getGateResults,
+} from "../gsd-db.ts";
+import { handleCompleteSlice } from "../tools/complete-slice.ts";
+import type { CompleteSliceParams } from "../types.ts";
+
+function makeValidSliceParams(overrides: Partial<CompleteSliceParams> = {}): CompleteSliceParams {
+  return {
+    sliceId: "S01",
+    milestoneId: "M001",
+    sliceTitle: "Test Slice",
+    oneLiner: "Implemented test slice",
+    narrative: "Built and tested.",
+    verification: "All tests pass.",
+    deviations: "None.",
+    knownLimitations: "None.",
+    followUps: "None.",
+    keyFiles: ["src/foo.ts"],
+    keyDecisions: [],
+    patternsEstablished: [],
+    observabilitySurfaces: [],
+    provides: [],
+    requirementsSurfaced: [],
+    drillDownPaths: [],
+    affects: [],
+    requirementsAdvanced: [],
+    requirementsValidated: [],
+    requirementsInvalidated: [],
+    filesModified: [],
+    requires: [],
+    uatContent: "## Smoke Test\n\nVerify happy path.",
+    ...overrides,
+  };
+}
+
+describe("complete-slice closes complete-slice-owned gates", () => {
+  let dbPath: string;
+  let basePath: string;
+
+  beforeEach(() => {
+    dbPath = path.join(
+      fs.mkdtempSync(path.join(os.tmpdir(), "gsd-slice-gate-")),
+      "test.db",
+    );
+    openDatabase(dbPath);
+
+    basePath = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-slice-gate-handler-"));
+    const sliceDir = path.join(
+      basePath, ".gsd", "milestones", "M001", "slices", "S01", "tasks",
+    );
+    fs.mkdirSync(sliceDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(basePath, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      [
+        "# M001: Test Milestone",
+        "",
+        "## Slices",
+        "",
+        '- [ ] **S01: Test Slice** `risk:medium` `depends:[]`',
+        "  - After this: basic functionality works",
+      ].join("\n"),
+    );
+
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001" });
+    insertTask({
+      id: "T01", sliceId: "S01", milestoneId: "M001",
+      status: "complete", title: "Task 1",
+    });
+
+    // Seed Q8 as pending — this is what plan-slice does today.
+    insertGateRow({
+      milestoneId: "M001", sliceId: "S01",
+      gateId: "Q8", scope: "slice",
+    });
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    fs.rmSync(path.dirname(dbPath), { recursive: true, force: true });
+    fs.rmSync(basePath, { recursive: true, force: true });
+  });
+
+  test("Q8 closes as 'pass' when operationalReadiness is populated", async () => {
+    const params = makeValidSliceParams({
+      operationalReadiness: [
+        "- Health signal: /health endpoint returns 200",
+        "- Failure signal: error rate alert in observability dashboard",
+        "- Recovery: systemd auto-restart",
+      ].join("\n"),
+    });
+
+    const result = await handleCompleteSlice(params, basePath);
+    assert.ok(!("error" in result), `handler failed: ${(result as any).error}`);
+
+    const gates = getGateResults("M001", "S01", "slice");
+    const q8 = gates.find((g) => g.gate_id === "Q8");
+    assert.ok(q8, "Q8 row must exist after complete-slice");
+    assert.equal(q8.status, "complete");
+    assert.equal(q8.verdict, "pass");
+    assert.ok(
+      q8.findings.includes("Health signal"),
+      "Q8 findings must capture the operationalReadiness content",
+    );
+  });
+
+  test("Q8 closes as 'omitted' when operationalReadiness is empty", async () => {
+    const params = makeValidSliceParams({ operationalReadiness: "" });
+
+    const result = await handleCompleteSlice(params, basePath);
+    assert.ok(!("error" in result), `handler failed: ${(result as any).error}`);
+
+    const gates = getGateResults("M001", "S01", "slice");
+    const q8 = gates.find((g) => g.gate_id === "Q8");
+    assert.ok(q8, "Q8 row must exist after complete-slice");
+    assert.equal(q8.status, "complete");
+    assert.equal(q8.verdict, "omitted");
+  });
+
+  test("Q8 also closes when operationalReadiness is omitted entirely", async () => {
+    // A model that doesn't pass operationalReadiness at all must still
+    // move Q8 out of 'pending' — leaving it pending produces the stall.
+    const params = makeValidSliceParams();
+    const result = await handleCompleteSlice(params, basePath);
+    assert.ok(!("error" in result), `handler failed: ${(result as any).error}`);
+
+    const gates = getGateResults("M001", "S01", "slice");
+    const q8 = gates.find((g) => g.gate_id === "Q8");
+    assert.ok(q8);
+    assert.notEqual(q8.status, "pending", "Q8 must never remain pending after complete-slice");
+    assert.equal(q8.verdict, "omitted");
+  });
+
+  test("summary markdown contains Operational Readiness section", async () => {
+    const params = makeValidSliceParams({
+      operationalReadiness: "- Health signal: /health\n- Failure signal: alert",
+    });
+    const result = await handleCompleteSlice(params, basePath);
+    assert.ok(!("error" in result));
+    if (!("error" in result)) {
+      const summary = fs.readFileSync(result.summaryPath, "utf-8");
+      assert.match(summary, /^## Operational Readiness/m);
+      assert.match(summary, /Health signal: \/health/);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/definition-io.test.ts

@@ -0,0 +1,57 @@
+/**
+ * definition-io.ts — unit tests for readFrozenDefinition.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { readFrozenDefinition } from "../definition-io.ts";
+
+function createTmpDir(): string {
+  return realpathSync(mkdtempSync(join(tmpdir(), "gsd-defio-test-")));
+}
+
+describe("readFrozenDefinition", () => {
+  let runDir: string;
+
+  beforeEach(() => {
+    runDir = createTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(runDir, { recursive: true, force: true });
+  });
+
+  test("parses a valid DEFINITION.yaml", () => {
+    const yaml = [
+      "version: 1",
+      "name: test-workflow",
+      "description: A test workflow",
+      "steps:",
+      "  - id: step-1",
+      "    prompt: do the thing",
+    ].join("\n");
+    writeFileSync(join(runDir, "DEFINITION.yaml"), yaml, "utf-8");
+
+    const def = readFrozenDefinition(runDir);
+    assert.equal(def.version, 1);
+    assert.equal(def.name, "test-workflow");
+    assert.equal(def.description, "A test workflow");
+    assert.equal(def.steps.length, 1);
+    assert.equal(def.steps[0].id, "step-1");
+  });
+
+  test("throws when DEFINITION.yaml is missing", () => {
+    assert.throws(() => readFrozenDefinition(runDir), {
+      code: "ENOENT",
+    });
+  });
+
+  test("throws on malformed YAML", () => {
+    writeFileSync(join(runDir, "DEFINITION.yaml"), ": : : not valid yaml [", "utf-8");
+    assert.throws(() => readFrozenDefinition(runDir));
+  });
+});

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

@@ -172,6 +172,32 @@ test("dispatch guard ignores positionally-earlier reverse dependents for zero-de
   );
 });
 
+test("dispatch guard treats zero-dependency slices as independent when a milestone uses explicit deps (#3998)", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M022"), { recursive: true });
+
+  insertMilestone({ id: "M022", title: "Mixed dependency milestone" });
+  insertSlice({ id: "S02", milestoneId: "M022", title: "Core A", status: "complete", depends: [], sequence: 2 });
+  insertSlice({ id: "S03", milestoneId: "M022", title: "Core B", status: "complete", depends: [], sequence: 3 });
+  insertSlice({ id: "S05", milestoneId: "M022", title: "Blocked integration", status: "pending", depends: ["S02", "S03", "S07"], sequence: 5 });
+  insertSlice({ id: "S06", milestoneId: "M022", title: "Independent zero-dep slice", status: "pending", depends: [], sequence: 6 });
+  insertSlice({ id: "S07", milestoneId: "M022", title: "Late prerequisite", status: "pending", depends: ["S02"], sequence: 7 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M022", "M022-ROADMAP.md"), "# M022\n");
+
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M022/S06/T02"),
+    null,
+  );
+
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M022/S05/T01"),
+    "Cannot dispatch execute-task M022/S05/T01: dependency slice M022/S07 is not complete.",
+  );
+});
+
 test("dispatch guard allows slice with all declared dependencies complete", (t) => {
   const repo = setupRepo();
   t.after(() => teardownRepo(repo));

package/src/resources/extensions/gsd/tests/doctor-heal-fixable-warnings.test.ts

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { isDoctorHealActionable } from "../commands-handlers.js";
+
+test("doctor heal actionable filter keeps fixable warnings and errors", () => {
+  assert.equal(isDoctorHealActionable({ fixable: true, severity: "warning" }), true);
+  assert.equal(isDoctorHealActionable({ fixable: true, severity: "error" }), true);
+});
+
+test("doctor heal actionable filter excludes info and non-fixable issues", () => {
+  assert.equal(isDoctorHealActionable({ fixable: true, severity: "info" }), false);
+  assert.equal(isDoctorHealActionable({ fixable: false, severity: "warning" }), false);
+  assert.equal(isDoctorHealActionable({ fixable: false, severity: "error" }), false);
+});

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

@@ -574,6 +574,42 @@ test("runProviderChecks reports ok for OpenAI via openai-codex auth.json (#2922)
   rmSync(tmpHome, { recursive: true, force: true });
 });
 
+test("runProviderChecks reports ok for claude-code without any API key", () => {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cc-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution:",
+      "    model: claude-sonnet-4-6",
+      "    provider: claude-code",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cc-home-")));
+
+  withEnv({
+    HOME: tmpHome,
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const cc = results.find(r => r.name === "claude-code");
+      assert.ok(cc, "claude-code result should exist");
+      assert.equal(cc!.status, "ok", "claude-code uses CLI auth — must be ok without API keys");
+      assert.ok(cc!.message.includes("CLI auth"), "should indicate CLI auth");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
 test("PROVIDER_ROUTES includes google-gemini-cli as route for google (#2922)", async () => {
   const { readFileSync: readFS } = await import("node:fs");
   const { dirname: dirn, join: joinPath } = await import("node:path");

package/src/resources/extensions/gsd/tests/false-degraded-mode-warning.test.ts

@@ -0,0 +1,104 @@
+/**
+ * false-degraded-mode-warning.test.ts — Regression tests for #3922.
+ *
+ * Before this fix, deriveState() logged a "DB unavailable — degraded mode"
+ * warning even when the DB simply hadn't been opened yet (e.g. during
+ * before_agent_start context injection). The fix introduces wasDbOpenAttempted()
+ * to distinguish "not yet initialized" from "genuinely unavailable."
+ *
+ * Two aspects:
+ * 1. gsd-db: wasDbOpenAttempted() tracks whether openDatabase() was ever called.
+ * 2. state: the degraded-mode warning is gated behind wasDbOpenAttempted().
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  openDatabase,
+  closeDatabase,
+  isDbAvailable,
+  wasDbOpenAttempted,
+} from "../gsd-db.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const stateSource = readFileSync(join(__dirname, "..", "state.ts"), "utf-8");
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 1. gsd-db: wasDbOpenAttempted flag
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe("wasDbOpenAttempted (#3922)", () => {
+
+  test("wasDbOpenAttempted returns true after openDatabase is called", () => {
+    // By this point in the test suite, openDatabase may or may not have been
+    // called by other tests. So we call it explicitly and verify it returns true.
+    openDatabase(":memory:");
+    assert.strictEqual(wasDbOpenAttempted(), true,
+      "wasDbOpenAttempted should be true after openDatabase call");
+    closeDatabase();
+  });
+
+  test("openDatabase sets the flag even if it fails on invalid path", () => {
+    // openDatabase with an unreachable path may fail, but the flag should
+    // still be set because the attempt was made.
+    try { openDatabase("/nonexistent/path/that/will/fail.db"); } catch { /* expected */ }
+    assert.strictEqual(wasDbOpenAttempted(), true,
+      "wasDbOpenAttempted should be true even after a failed open attempt");
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 2. state.ts: degraded-mode warning is gated behind wasDbOpenAttempted
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe("degraded-mode warning guard (#3922)", () => {
+
+  test("state.ts imports wasDbOpenAttempted from gsd-db", () => {
+    assert.ok(
+      stateSource.includes("wasDbOpenAttempted"),
+      "state.ts must import wasDbOpenAttempted to gate the degraded-mode warning",
+    );
+  });
+
+  test("degraded-mode warning is inside a wasDbOpenAttempted() guard", () => {
+    // Find the degraded-mode warning string
+    const warningStr = 'DB unavailable — using filesystem state derivation (degraded mode)';
+    const warningIdx = stateSource.indexOf(warningStr);
+    assert.ok(warningIdx > 0, "degraded-mode warning string must exist in state.ts");
+
+    // The wasDbOpenAttempted() check must appear BEFORE the warning,
+    // within the same else-branch (i.e. within a reasonable distance).
+    // Look backwards from the warning for the guard.
+    const searchWindow = stateSource.slice(Math.max(0, warningIdx - 300), warningIdx);
+    assert.ok(
+      searchWindow.includes("wasDbOpenAttempted()"),
+      "wasDbOpenAttempted() guard must appear shortly before the degraded-mode warning " +
+      "to prevent false warnings when DB has not been initialized yet",
+    );
+  });
+
+  test("warning is NOT emitted unconditionally in the else branch", () => {
+    // The old code had `logWarning(...)` directly in the else branch.
+    // The fix wraps it in `if (wasDbOpenAttempted())`.
+    // Verify the logWarning call is inside a conditional, not bare.
+    const lines = stateSource.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i]!.includes("DB unavailable") && lines[i]!.includes("degraded mode")) {
+        // This line has the warning. Check that the preceding non-empty line
+        // contains an if-condition (wasDbOpenAttempted), not a bare else.
+        let prev = i - 1;
+        while (prev >= 0 && lines[prev]!.trim() === "") prev--;
+        const prevLine = lines[prev]!.trim();
+        assert.ok(
+          prevLine.includes("wasDbOpenAttempted"),
+          `Line ${i + 1} emits degraded-mode warning — preceding line ${prev + 1} must ` +
+          `contain wasDbOpenAttempted guard, but found: "${prevLine}"`,
+        );
+        break;
+      }
+    }
+  });
+});