gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/tests/prompt-step-ordering.test.ts

@@ -1,146 +1,91 @@
 /**
- * Regression test for #3696 — prompt step ordering and runtime fixes
+ * Regression tests for #3696 — prompt step ordering and compact hook behavior.
  *
- * 1. complete-milestone.md: gsd_requirement_update (step 9) before
- *    gsd_complete_milestone, and completion remains the final durable write
- * 2. complete-slice.md: uses gsd_requirement_update
- * 3. register-extension.ts: _gsdEpipeGuard logs instead of re-throwing
- * 4. register-hooks.ts: session_before_compact only checks isAutoActive
+ * These tests assert rendered prompts and registered hook behavior instead of
+ * reading source files as text.
  */
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { extractSourceRegion } from "./test-helpers.ts";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { _setAutoActiveForTest } from '../auto.ts';
+import { buildCompleteMilestonePrompt, buildCompleteSlicePrompt } from '../auto-prompts.ts';
+import { registerHooks } from '../bootstrap/register-hooks.ts';
 
-const completeMilestoneMd = readFileSync(
-  join(__dirname, '..', 'prompts', 'complete-milestone.md'),
-  'utf-8',
-);
-const completeSliceMd = readFileSync(
-  join(__dirname, '..', 'prompts', 'complete-slice.md'),
-  'utf-8',
-);
-const registerExtSrc = readFileSync(
-  join(__dirname, '..', 'bootstrap', 'register-extension.ts'),
-  'utf-8',
-);
-const registerHooksSrc = readFileSync(
-  join(__dirname, '..', 'bootstrap', 'register-hooks.ts'),
-  'utf-8',
-);
+function makePromptBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-prompt-order-'));
+  const msDir = join(base, '.gsd', 'milestones', 'M001');
+  const sliceDir = join(msDir, 'slices', 'S01');
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(
+    join(msDir, 'M001-ROADMAP.md'),
+    '# Roadmap\n\n## Slices\n\n- [x] **S01: Done** `risk:low` `depends:[]`\n',
+  );
+  writeFileSync(join(sliceDir, 'S01-PLAN.md'), '# S01 Plan\n\n## Tasks\n\n- T01\n');
+  writeFileSync(join(sliceDir, 'S01-SUMMARY.md'), '# S01 Summary\n\nDone.\n');
+  return base;
+}
 
-describe('prompt step ordering (#3696)', () => {
-  test('gsd_requirement_update step appears before gsd_complete_milestone step', () => {
-    // Search for the numbered step definitions, not early "Do NOT call" warnings
-    const reqUpdateMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_requirement_update/m);
-    const completeMilestoneMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_complete_milestone/m);
-    assert.ok(reqUpdateMatch, 'gsd_requirement_update should appear in a numbered step');
-    assert.ok(completeMilestoneMatch, 'gsd_complete_milestone should appear in a numbered step');
-    const reqUpdateIdx = completeMilestoneMd.indexOf(reqUpdateMatch![0]);
-    const completeMilestoneIdx = completeMilestoneMd.indexOf(completeMilestoneMatch![0]);
-    assert.ok(
-      reqUpdateIdx < completeMilestoneIdx,
-      'gsd_requirement_update step must come before gsd_complete_milestone step',
-    );
-  });
-
-  test('project and learnings writes appear before gsd_complete_milestone', () => {
-    const projectMatch = completeMilestoneMd.match(/^\d+\.\s.*PROJECT\.md/m);
-    const learningsMatch = completeMilestoneMd.match(/^\d+\.\s.*Extract structured learnings/m);
-    const completeMilestoneMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_complete_milestone/m);
-    assert.ok(projectMatch, 'PROJECT.md update should appear in a numbered step');
-    assert.ok(learningsMatch, 'learnings extraction should appear in a numbered step');
-    assert.ok(completeMilestoneMatch, 'gsd_complete_milestone should appear in a numbered step');
-
-    const projectIdx = completeMilestoneMd.indexOf(projectMatch![0]);
-    const learningsIdx = completeMilestoneMd.indexOf(learningsMatch![0]);
-    const completeMilestoneIdx = completeMilestoneMd.indexOf(completeMilestoneMatch![0]);
-    assert.ok(projectIdx < completeMilestoneIdx, 'PROJECT.md update must happen before gsd_complete_milestone');
-    assert.ok(learningsIdx < completeMilestoneIdx, 'learnings extraction must happen before gsd_complete_milestone');
-  });
-
-  test('complete-milestone duplicate guard checks milestone status before durable writes', () => {
-    const guardMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_milestone_status/m);
-    const reqUpdateMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_requirement_update/m);
-    assert.ok(guardMatch, 'complete-milestone must start with a gsd_milestone_status duplicate guard');
-    assert.ok(reqUpdateMatch, 'gsd_requirement_update should appear in a numbered step');
+function numberedStepIndex(prompt: string, needle: RegExp): number {
+  const lines = prompt.split('\n');
+  const idx = lines.findIndex((line) => /^\d+\.\s/.test(line) && needle.test(line));
+  assert.notEqual(idx, -1, `missing numbered step matching ${needle}`);
+  return idx;
+}
 
-    const guardIdx = completeMilestoneMd.indexOf(guardMatch![0]);
-    const reqUpdateIdx = completeMilestoneMd.indexOf(reqUpdateMatch![0]);
-    assert.ok(
-      guardIdx < reqUpdateIdx,
-      'duplicate guard must run before requirement/project/learnings writes',
-    );
-    assert.match(
-      completeMilestoneMd,
-      /status(?:`|\*\*)?\s+(?:is\s+)?(?:`complete`|"complete")/i,
-      'duplicate guard must tell the agent to stop when status is complete',
-    );
-  });
+describe('prompt step ordering (#3696)', () => {
+  test('complete-milestone prompt orders durable writes before gsd_complete_milestone', async () => {
+    const base = makePromptBase();
+    try {
+      const prompt = await buildCompleteMilestonePrompt('M001', 'Milestone', base, 'minimal');
+      const guardIdx = numberedStepIndex(prompt, /gsd_milestone_status/);
+      const requirementIdx = numberedStepIndex(prompt, /gsd_requirement_update/);
+      const projectIdx = numberedStepIndex(prompt, /PROJECT\.md/);
+      const learningsIdx = numberedStepIndex(prompt, /Extract structured learnings/);
+      const completeIdx = numberedStepIndex(prompt, /gsd_complete_milestone/);
 
-  test('complete-slice.md uses gsd_requirement_update', () => {
-    assert.match(completeSliceMd, /gsd_requirement_update/,
-      'complete-slice.md should reference gsd_requirement_update');
+      assert.ok(guardIdx < requirementIdx);
+      assert.ok(requirementIdx < completeIdx);
+      assert.ok(projectIdx < completeIdx);
+      assert.ok(learningsIdx < completeIdx);
+      assert.match(prompt, /status(?:`|\*\*)?\s+(?:is\s+)?(?:`complete`|"complete")/i);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
-});
 
-describe('register-extension _gsdEpipeGuard (#3696)', () => {
-  test('_gsdEpipeGuard exists and does not re-throw', () => {
-    assert.match(registerExtSrc, /_gsdEpipeGuard/,
-      '_gsdEpipeGuard should be defined in register-extension.ts');
-    // After the fix, the handler logs instead of throwing
-    assert.ok(
-      !registerExtSrc.includes('throw err'),
-      '_gsdEpipeGuard should NOT contain "throw err"',
-    );
+  test('complete-slice prompt exposes gsd_requirement_update', async () => {
+    const base = makePromptBase();
+    try {
+      const prompt = await buildCompleteSlicePrompt('M001', 'Milestone', 'S01', 'Done', base, 'minimal');
+      assert.match(prompt, /gsd_requirement_update/);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });
 
 describe('register-hooks session_before_compact (#3696)', () => {
-  test('session_before_compact only checks isAutoActive', () => {
-    // Anchor on the full registration token rather than the bare event name —
-    // prevents matching unrelated substring occurrences.
-    const compactIdx = registerHooksSrc.indexOf('pi.on("session_before_compact"');
-    assert.ok(compactIdx > -1, 'session_before_compact hook should exist');
-    // The first check in the handler should be isAutoActive(), not isAutoPaused().
-    // Bound the region to this single handler — register-hooks.ts contains
-    // multiple pi.on("session_before_compact") handlers and a later handler
-    // legitimately references isAutoPaused.
-    const afterCompact = extractSourceRegion(
-      registerHooksSrc,
-      'pi.on("session_before_compact"',
-      'pi.on("',
-      // NB: endAnchor search starts AFTER the startAnchor, so the next
-      // pi.on("... matches the subsequent handler rather than this one.
-    );
-    assert.match(afterCompact, /isAutoActive\(\)/,
-      'session_before_compact should check isAutoActive()');
-    // Should NOT block compaction when paused
-    assert.ok(
-      !afterCompact.includes('isAutoPaused()'),
-      'session_before_compact should not check isAutoPaused',
-    );
-  });
-
-  test('session_before_compact does not gate checkpointing to executing phase (#4258)', () => {
-    const compactIdx = registerHooksSrc.indexOf('session_before_compact');
-    assert.ok(compactIdx > -1, 'session_before_compact hook should exist');
+  test('registered hook cancels compaction only while auto-mode is active', async () => {
+    const handlers = new Map<string, Function>();
+    registerHooks({
+      on(event: string, handler: Function) {
+        handlers.set(event, handler);
+      },
+    } as any, []);
 
-    const preCheckpointSection = registerHooksSrc.slice(
-      compactIdx,
-      registerHooksSrc.indexOf('const sliceDir', compactIdx),
-    );
+    const compact = handlers.get('session_before_compact');
+    assert.ok(compact, 'session_before_compact hook should be registered');
 
-    const normalized = preCheckpointSection.replace(/\/\/.*$/gm, '');
-    assert.ok(
-      !/if\s*\(\s*state\.phase\s*!==\s*['"]executing['"]\s*\)\s*\{?\s*return\b/.test(normalized),
-      'session_before_compact should not early-return on non-executing phases',
-    );
+    _setAutoActiveForTest(true);
+    try {
+      const result = await compact({}, { cwd: mkdtempSync(join(tmpdir(), 'gsd-compact-active-')), ui: { notify() {}, setWidget() {} } });
+      assert.deepEqual(result, { cancel: true });
+    } finally {
+      _setAutoActiveForTest(false);
+    }
   });
 });

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -7,20 +7,17 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 import { classifyError, isTransient, isTransientNetworkError } from "../error-classifier.ts";
 import { pauseAutoForProviderError } from "../provider-error-pause.ts";
 import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.ts";
-import { MAX_TRANSIENT_AUTO_RESUMES } from "../bootstrap/agent-end-recovery.ts";
+import { MAX_TRANSIENT_AUTO_RESUMES, resetTransientRetryState } from "../bootstrap/agent-end-recovery.ts";
+import { _buildCancelledUnitStopReason } from "../auto/phases.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
 // barrel to avoid pulling the full AgentSession / @gsd/pi-ai dep graph into
 // this unit test (see #4837).
 import { RETRYABLE_ERROR_RE } from "../../../../../packages/pi-coding-agent/src/core/retryable-error-regex.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import { streamOpenAICodexResponses } from "../../../../../packages/pi-ai/src/providers/openai-codex-responses.ts";
 
 // ── classifyError ────────────────────────────────────────────────────────────
 
@@ -518,172 +515,73 @@ test("resumeAutoAfterProviderDelay resets provider retry state without clearing
   ]);
 });
 
-// ── Escalating backoff for transient errors (#1166) ─────────────────────────
-
-test("agent-end-recovery.ts tracks consecutive transient errors for escalating backoff", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-
-  assert.ok(
-    src.includes("consecutiveTransientCount"),
-    "agent-end-recovery.ts must track consecutiveTransientCount for escalating backoff (#1166)",
-  );
-  assert.ok(
-    src.includes("MAX_TRANSIENT_AUTO_RESUMES"),
-    "agent-end-recovery.ts must define MAX_TRANSIENT_AUTO_RESUMES to cap infinite retries (#1166)",
-  );
-});
-
-test("agent-end-recovery.ts resets retry state before resolveAgentEnd on success", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-
-  // After successful agent_end, resetRetryState must be called before resolveAgentEnd.
-  assert.ok(
-    /resetRetryState[\s\S]{0,250}resolveAgentEnd/.test(src),
-    "resetRetryState must be called before resolveAgentEnd on the success path (#1166)",
-  );
-});
-
-test("agent-end-recovery.ts applies escalating delay for repeated transient errors", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
+// ── Provider recovery behavior (#1166 / #2813 / #4373) ─────────────────────
 
-  // Must contain the exponential backoff formula (may span multiple lines)
-  assert.ok(
-    src.includes("2 ** Math.max(0, retryState.consecutiveTransientCount"),
-    "agent-end-recovery.ts must escalate retryAfterMs exponentially for consecutive transient errors (#1166)",
-  );
+test("resetTransientRetryState is callable by resume recovery", () => {
+  resetTransientRetryState();
+  assert.equal(classifyError("stream_exhausted_without_result").kind, "connection");
 });
 
-test("agent-end-recovery.ts resumes transient provider pauses through startAuto instead of a hidden prompt", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-
-  assert.ok(
-    src.includes("resumeAutoAfterProviderDelay"),
-    "agent-end-recovery.ts must resume paused auto-mode through resumeAutoAfterProviderDelay (#2813)",
-  );
-  assert.ok(
-    !src.includes('Continue execution — provider error recovery delay elapsed.'),
-    "transient provider resume must not rely on a hidden continue prompt (#2813)",
-  );
-});
-
-test("agent-end-recovery.ts does not defer rate-limit errors to core retry handler before fallback (#4373)", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-  assert.ok(
-    src.includes('if (isTransient(cls) && cls.kind !== "rate-limit")'),
-    "rate-limit errors must bypass transient core-retry deferral so fallback can execute (#4373)",
-  );
-});
-
-test("agent-end-recovery.ts updates dashboard dispatched model after fallback switch", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-  assert.ok(
-    src.includes("setCurrentDispatchedModelId"),
-    "agent-end-recovery.ts should update currentDispatchedModelId when recovery switches model",
-  );
-});
-
-// ── Codex error extraction (#1166) ──────────────────────────────────────────
-
-test("openai-codex-responses.ts extracts nested error fields", () => {
-  const codexSource = readFileSync(
-    join(__dirname, "../../../../../packages/pi-ai/src/providers/openai-codex-responses.ts"),
-    "utf-8",
-  );
-
-  // Must access event.error.message (nested), not just event.message (top-level)
-  assert.ok(
-    codexSource.includes("errorObj?.message"),
-    "mapCodexEvents must extract message from nested event.error object (#1166)",
-  );
-  assert.ok(
-    codexSource.includes("errorObj?.type"),
-    "mapCodexEvents must extract type from nested event.error object (#1166)",
-  );
-});
-
-// ── Fix 1: resetTransientRetryState resets module-level singleton ────────────
-
-test("resetTransientRetryState is exported from agent-end-recovery.ts", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-  assert.ok(
-    src.includes("export function resetTransientRetryState"),
-    "agent-end-recovery.ts must export resetTransientRetryState for provider-error-resume.ts",
+test("cancelled unit stop reason differentiates session startup failures", () => {
+  assert.deepEqual(
+    _buildCancelledUnitStopReason("plan-slice", "S01", {
+      category: "session-failed",
+      message: "Session creation timed out",
+    }),
+    {
+      notifyMessage: "Session creation failed for plan-slice S01: Session creation timed out. Stopping auto-mode.",
+      stopReason: "Session creation failed: Session creation timed out",
+      loopReason: "session-failed",
+    },
   );
-});
-
-// ── Fix 2: Session creation timeout treated as transient in phases.ts ───────
-
-test("phases.ts handles timeout session-creation failures with pause instead of stopAuto", () => {
-  const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
 
-  // The cancelled + isTransient session-start path must pause, not hard-stop
-  assert.ok(
-    src.includes('errorCategory === "timeout"'),
-    "phases.ts must check errorCategory === 'timeout' on transient cancelled unitResults",
-  );
-  assert.ok(
-    src.includes('errorCategory === "session-failed"'),
-    "phases.ts must also check errorCategory === 'session-failed' on transient cancelled unitResults",
-  );
-  // Must call pauseAuto or pauseAutoForProviderError (not stopAuto) for timeout cancellations
-  assert.ok(
-    /errorCategory === "timeout"[\s\S]{0,1800}pauseAuto/.test(src),
-    "phases.ts must call pauseAuto for session-timeout failures (not stopAuto or continue)",
-  );
-  assert.ok(
-    /errorCategory === "session-failed"[\s\S]{0,700}pauseAuto/.test(src),
-    "phases.ts must call pauseAuto for transient session-start failures (not stopAuto or continue)",
-  );
-  // Must NOT use action: "continue" for transient cancellations (causes infinite loops)
-  assert.ok(
-    !/isTransient[\s\S]{0,500}action:\s*"continue"/.test(src),
-    "phases.ts must NOT return action:continue for cancelled units — use break+pause instead",
+  assert.deepEqual(
+    _buildCancelledUnitStopReason("execute-task", "T01", {
+      category: "aborted",
+      message: "Request aborted by user",
+    }),
+    {
+      notifyMessage: "Unit execute-task T01 aborted after dispatch: Request aborted by user. Stopping auto-mode.",
+      stopReason: "Unit aborted: Request aborted by user",
+      loopReason: "unit-aborted",
+    },
   );
 });
 
-// ── Fix 2b: Session creation timeout schedules auto-resume timer ─────────────
+test("openai-codex response stream surfaces nested error type and message", async () => {
+  const originalFetch = globalThis.fetch;
+  const tokenPayload = Buffer.from(JSON.stringify({
+    "https://api.openai.com/auth": { chatgpt_account_id: "acct-test" },
+  })).toString("base64");
+  const apiKey = `header.${tokenPayload}.signature`;
+  globalThis.fetch = (async () => new Response(
+    'data: {"type":"error","error":{"type":"server_error","code":"server_error","message":"upstream failed"}}\n\n',
+    { status: 200, headers: { "content-type": "text/event-stream" } },
+  )) as typeof fetch;
 
-test("phases.ts schedules auto-resume timer for session creation timeouts", () => {
-  const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
-
-  // Must use pauseAutoForProviderError (not bare pauseAuto) for session-timeout
-  assert.ok(
-    src.includes("pauseAutoForProviderError"),
-    "phases.ts must use pauseAutoForProviderError for session-timeout auto-resume",
-  );
-  // Must schedule resume via resumeAutoAfterProviderDelay
-  assert.ok(
-    src.includes("resumeAutoAfterProviderDelay"),
-    "phases.ts must schedule resume via resumeAutoAfterProviderDelay",
-  );
-  // Must track consecutive session timeouts
-  assert.ok(
-    src.includes("consecutiveSessionTimeouts"),
-    "phases.ts must track consecutive session timeouts for escalating backoff",
-  );
-  // Must cap session timeout auto-resumes
-  assert.ok(
-    /MAX_SESSION_TIMEOUT_AUTO_RESUMES\s*=\s*\d+/.test(src),
-    "phases.ts must cap session timeout auto-resumes",
-  );
-});
+  try {
+    const stream = streamOpenAICodexResponses(
+      {
+        provider: "openai-codex-responses",
+        id: "gpt-5.1-codex",
+        baseUrl: "https://codex.example.test",
+      } as any,
+      { messages: [], systemPrompt: "", tools: [] } as any,
+      { apiKey } as any,
+    );
 
-test("phases.ts differentiates session creation timeout from unit hard timeout", () => {
-  const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
-  assert.ok(
-    src.includes("Session creation timed out"),
-    "phases.ts must check for 'Session creation timed out' message to differentiate from unit hard timeout",
-  );
-});
+    const events = [];
+    for await (const event of stream) {
+      events.push(event);
+    }
 
-test("phases.ts resets session timeout counter on successful unit completion", () => {
-  const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
-  const resetIdx = src.indexOf("consecutiveSessionTimeouts = 0");
-  const closeoutIdx = src.indexOf("closeoutUnit");
-  assert.ok(
-    resetIdx !== -1 && closeoutIdx !== -1 && resetIdx < closeoutIdx,
-    "consecutiveSessionTimeouts must reset before closeoutUnit (on success path)",
-  );
+    const errorEvent = events.find((event) => event.type === "error");
+    assert.ok(errorEvent, "stream should emit an error event");
+    assert.equal(errorEvent.error.errorMessage, "Codex server_error: upstream failed");
+    assert.equal(classifyError(errorEvent.error.errorMessage).kind, "server");
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
 });
 
 // ── Fix 3: MAX_TRANSIENT_AUTO_RESUMES raised to 8 ───────────────────────────

package/src/resources/extensions/gsd/tests/query-tools-db-open.test.ts

@@ -6,42 +6,46 @@
  * The fix imports ensureDbOpen from dynamic-tools and calls it before
  * querying the DB.
  *
- * This structural test verifies the ensureDbOpen import and usage exist
- * in query-tools.ts.
+ * This behavior test registers the query tool and executes it against a
+ * temp workspace where the DB must be opened on demand.
  */
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const source = readFileSync(join(__dirname, '..', 'bootstrap', 'query-tools.ts'), 'utf-8');
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { closeDatabase, insertMilestone, openDatabase } from '../gsd-db.ts';
+import { registerQueryTools } from '../bootstrap/query-tools.ts';
 
 describe('query-tools ensureDbOpen usage (#3672)', () => {
-  test('imports ensureDbOpen from dynamic-tools', () => {
-    assert.match(source, /ensureDbOpen.*import\(|import.*ensureDbOpen/,
-      'query-tools should import ensureDbOpen');
-  });
+  test('gsd_milestone_status opens the workspace DB before querying', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-query-tools-'));
+    const dbPath = join(base, '.gsd', 'gsd.db');
+    const tools: Record<string, any> = {};
+    const originalCwd = process.cwd();
+    try {
+      mkdirSync(join(base, '.gsd'), { recursive: true });
+      openDatabase(dbPath);
+      insertMilestone({ id: 'M001', title: 'Query me', status: 'active' });
+      closeDatabase();
 
-  test('calls ensureDbOpen() before DB queries', () => {
-    assert.match(source, /await ensureDbOpen\([^)]*\)/,
-      'query-tools should call await ensureDbOpen(...)');
-  });
-
-  test('no longer imports isDbAvailable in the execute path', () => {
-    // The old code imported isDbAvailable and checked it; the fix removed that
-    // The execute function should not destructure isDbAvailable from gsd-db
-    const executeBlock = source.slice(source.indexOf('async execute('));
-    assert.doesNotMatch(executeBlock, /isDbAvailable,/,
-      'execute path should not destructure isDbAvailable (replaced by ensureDbOpen)');
-  });
+      registerQueryTools({ registerTool(tool: any) { tools[tool.name] = tool; } } as any);
+      process.chdir(base);
+      const result = await tools.gsd_milestone_status.execute(
+        'call-1',
+        { milestoneId: 'M001' },
+        undefined,
+        undefined,
+        undefined,
+      );
 
-  test('uses dbAvailable result from ensureDbOpen', () => {
-    assert.match(source, /dbAvailable\s*=\s*await ensureDbOpen\([^)]*\)/,
-      'should store ensureDbOpen result in dbAvailable');
+      assert.notEqual(result.details?.error, 'db_unavailable');
+      assert.equal(result.details?.milestoneId ?? result.details?.milestone?.id, 'M001');
+    } finally {
+      process.chdir(originalCwd);
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });