gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

package/src/resources/extensions/gsd/tests/auto-thinking-restore.test.ts

@@ -1,39 +1,54 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { extractSourceRegion } from "./test-helpers.ts";
+import { tmpdir } from "node:os";
 
-const autoSrc = readFileSync(join(import.meta.dirname, "..", "auto.ts"), "utf-8");
-const phasesSrc = readFileSync(join(import.meta.dirname, "..", "auto", "phases.ts"), "utf-8");
+import { selectAndApplyModel } from "../auto-model-selection.ts";
 
-test("stopAuto restores original thinking level", () => {
-  assert.ok(
-    autoSrc.includes("if (pi && s.originalThinkingLevel)"),
-    "auto.ts should conditionally restore original thinking level in stopAuto",
+test("selectAndApplyModel restores captured thinking level after model selection", async (t) => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "gsd-thinking-restore-"));
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(base, { recursive: true, force: true });
+  });
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    ["---", "models:", "  planning: anthropic/claude-sonnet-4-6", "---"].join("\n"),
+    "utf-8",
   );
-  assert.ok(
-    autoSrc.includes("pi.setThinkingLevel(s.originalThinkingLevel)"),
-    "auto.ts should call pi.setThinkingLevel with originalThinkingLevel",
-  );
-});
+  process.chdir(base);
 
-test("runUnitPhase threads captured thinking level into selectAndApplyModel", () => {
-  const callIdx = phasesSrc.indexOf("deps.selectAndApplyModel(");
-  assert.ok(callIdx > -1, "phases.ts should call selectAndApplyModel");
-  const callBlock = extractSourceRegion(phasesSrc, "deps.selectAndApplyModel(");
-  assert.ok(
-    callBlock.includes("s.autoModeStartThinkingLevel"),
-    "runUnitPhase should pass autoModeStartThinkingLevel to selectAndApplyModel",
+  const result = await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [{ id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" }] },
+      sessionManager: { getSessionId: () => "thinking-test" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    base,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-sonnet-4-6" },
+    undefined,
+    true,
+    undefined,
+    { effort: "medium" } as any,
   );
-});
 
-test("hook model override preserves captured thinking level", () => {
-  const hookIdx = phasesSrc.indexOf("const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;");
-  assert.ok(hookIdx > -1, "phases.ts should include hook model override handling");
-  const hookBlock = extractSourceRegion(phasesSrc, "const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;");
-  assert.ok(
-    hookBlock.includes("pi.setThinkingLevel(s.autoModeStartThinkingLevel)"),
-    "hook model override should re-apply captured thinking level after setModel",
-  );
+  assert.equal(result.appliedModel?.provider, "anthropic");
+  assert.deepEqual(thinkingLevels, [{ effort: "medium" }]);
 });

package/src/resources/extensions/gsd/tests/auto-warning-noise-regression.test.ts

@@ -23,11 +23,17 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { buildFlatRateContext } from "../auto-model-selection.ts";
-import { extractSourceRegion } from "./test-helpers.ts";
+import { _isSamePath, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import {
+  checkAutoStartAfterDiscuss,
+  clearPendingAutoStart,
+  setPendingAutoStart,
+} from "../guided-flow.ts";
 
 // ─── Bug 2: this-binding regression ─────────────────────────────────────
 
@@ -62,57 +68,39 @@ test("buildFlatRateContext invokes getProviderAuthMode with correct `this`", ()
 
 // ─── Bug 1: isSamePath source check ─────────────────────────────────────
 
-test("isSamePath short-circuits ENOENT before logging a warning", () => {
-  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const src = readFileSync(srcPath, "utf-8");
-
-  const fnIdx = src.indexOf("function isSamePath");
-  assert.ok(fnIdx !== -1, "isSamePath function exists");
-
-  // Grab the function body (enough to cover the catch block).
-  const fnBody = extractSourceRegion(src, "function isSamePath", { fromIdx: fnIdx });
-
-  const catchIdx = fnBody.indexOf("catch");
-  assert.ok(catchIdx !== -1, "isSamePath has a catch block");
-
-  const enoentIdx = fnBody.indexOf("ENOENT", catchIdx);
-  const warnIdx = fnBody.indexOf("logWarning", catchIdx);
-
-  assert.ok(enoentIdx !== -1, "catch block must handle ENOENT explicitly");
-  assert.ok(warnIdx !== -1, "catch block still warns on non-ENOENT errors");
-  assert.ok(
-    enoentIdx < warnIdx,
-    "ENOENT early-return must precede the logWarning call",
-  );
+test("isSamePath returns false for missing paths without throwing", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-same-path-"));
+  try {
+    assert.equal(_isSamePath(join(dir, "missing-a"), join(dir, "missing-b")), false);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+    _resetAutoWorktreeOriginalBaseForTests();
+  }
 });
 
 // ─── Bug 3: guided-flow manifest unlink source check ────────────────────
 
-test("checkAutoStartAfterDiscuss guards DISCUSSION-MANIFEST.json unlink with existsSync", () => {
-  const srcPath = join(import.meta.dirname, "..", "guided-flow.ts");
-  const src = readFileSync(srcPath, "utf-8");
-
-  const fnIdx = src.indexOf("function checkAutoStartAfterDiscuss");
-  assert.ok(fnIdx !== -1, "checkAutoStartAfterDiscuss function exists");
-
-  // Locate the manifest cleanup comment and its surrounding block.
-  const cleanupIdx = src.indexOf(
-    "remove discussion manifest after auto-start",
-    fnIdx,
-  );
-  assert.ok(cleanupIdx !== -1, "manifest cleanup block still exists");
-
-  // Everything from the comment to a short distance below should contain
-  // the existsSync guard before the unlinkSync call.
-  const block = extractSourceRegion(src, "remove discussion manifest after auto-start", { fromIdx: cleanupIdx });
-
-  const existsIdx = block.indexOf("existsSync(manifestPath)");
-  const unlinkIdx = block.indexOf("unlinkSync(manifestPath)");
-
-  assert.ok(existsIdx !== -1, "manifest unlink must be guarded by existsSync");
-  assert.ok(unlinkIdx !== -1, "manifest unlink still happens when file exists");
-  assert.ok(
-    existsIdx < unlinkIdx,
-    "existsSync guard must precede the unlinkSync call",
-  );
+test("checkAutoStartAfterDiscuss completes when discussion manifest is absent", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-discuss-manifest-"));
+  const notifications: Array<{ message: string; level: string }> = [];
+  let scheduled = false;
+  try {
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# Context\n", "utf-8");
+    writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: { ui: { notify: (message: string, level: string) => notifications.push({ message, level }) } } as any,
+      pi: { sendMessage: () => { scheduled = true; } } as any,
+    });
+
+    assert.equal(checkAutoStartAfterDiscuss(), true);
+    assert.equal(scheduled, false);
+    assert.deepEqual(notifications, [{ message: "Milestone M001 ready.", level: "success" }]);
+  } finally {
+    clearPendingAutoStart(base);
+    rmSync(base, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/auto-wrapup-inflight-guard.test.ts

@@ -3,223 +3,169 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
-
-const autoTimersPath = join(import.meta.dirname, "..", "auto-timers.ts");
-const autoTimersSrc = readFileSync(autoTimersPath, "utf-8");
-
-const autoPath = join(import.meta.dirname, "..", "auto.ts");
-const autoSrc = readFileSync(autoPath, "utf-8");
-
-const runUnitPath = join(import.meta.dirname, "..", "auto", "run-unit.ts");
-const runUnitSrc = readFileSync(runUnitPath, "utf-8");
-
-const registerHooksPath = join(import.meta.dirname, "..", "bootstrap", "register-hooks.ts");
-const registerHooksSrc = readFileSync(registerHooksPath, "utf-8");
-
-describe("#3512: gsd-auto-wrapup must not interrupt in-flight tool calls", () => {
-  test("soft timeout wrapup gates triggerTurn on getInFlightToolCount() === 0", () => {
-    // The soft timeout sendMessage must NOT use a hardcoded `triggerTurn: true`.
-    // It must check getInFlightToolCount() before deciding whether to trigger.
-    // Use the section marker comment to isolate the soft timeout block.
-    const startMarker = "── 1. Soft timeout warning";
-    const endMarker = "── 2. Idle watchdog";
-    const softTimeoutSection = autoTimersSrc.slice(
-      autoTimersSrc.indexOf(startMarker),
-      autoTimersSrc.indexOf(endMarker),
-    );
-    assert.ok(
-      softTimeoutSection.length > 0,
-      "Could not locate soft timeout section",
-    );
-
-    // Must reference getInFlightToolCount to gate the trigger
-    assert.ok(
-      softTimeoutSection.includes("getInFlightToolCount"),
-      "Soft timeout wrapup must gate triggerTurn behind getInFlightToolCount() check",
-    );
-
-    // Must NOT have a hardcoded triggerTurn: true
-    assert.ok(
-      !softTimeoutSection.includes("triggerTurn: true"),
-      "Soft timeout wrapup must not use hardcoded triggerTurn: true",
-    );
-  });
-
-  test("context-pressure wrapup gates triggerTurn on getInFlightToolCount() === 0", () => {
-    // The context budget sendMessage must NOT use a hardcoded `triggerTurn: true`.
-    // Use the section marker to isolate the context-pressure block.
-    const startMarker = "── 4. Context-pressure continue-here monitor";
-    const contextSection = autoTimersSrc.slice(
-      autoTimersSrc.indexOf(startMarker),
-    );
-    assert.ok(
-      contextSection.length > 0,
-      "Could not locate context budget section",
-    );
-
-    // Must reference getInFlightToolCount to gate the trigger
-    assert.ok(
-      contextSection.includes("getInFlightToolCount"),
-      "Context budget wrapup must gate triggerTurn behind getInFlightToolCount() check",
-    );
-
-    // Must NOT have a hardcoded triggerTurn: true
-    assert.ok(
-      !contextSection.includes("triggerTurn: true"),
-      "Context budget wrapup must not use hardcoded triggerTurn: true",
-    );
-  });
-});
-
-describe("#4276: pending/skipped tools stay visible to auto-mode hooks", () => {
-  test("tool_call handler marks GSD tools in-flight before execution_start", () => {
-    const startMarker = 'pi.on("tool_call", async (event, ctx) => {';
-    const endMarker = 'pi.on("tool_result", async (event) => {';
-    const toolCallSection = registerHooksSrc.slice(
-      registerHooksSrc.indexOf(startMarker),
-      registerHooksSrc.indexOf(endMarker),
-    );
-
-    assert.ok(toolCallSection.length > 0, "Could not locate tool_call handler section");
-    assert.ok(
-      toolCallSection.includes("markToolStart(event.toolCallId, event.toolName)"),
-      "tool_call handler must mark tools pending before tool_execution_start fires",
-    );
-  });
-
-  test("tool_result handler clears pending tools and records queued-skip errors", () => {
-    const startMarker = 'pi.on("tool_result", async (event) => {';
-    const endMarker = 'pi.on("tool_execution_start", async (event) => {';
-    const toolResultSection = registerHooksSrc.slice(
-      registerHooksSrc.indexOf(startMarker),
-      registerHooksSrc.indexOf(endMarker),
-    );
-
-    assert.ok(toolResultSection.length > 0, "Could not locate tool_result handler section");
-    assert.ok(
-      toolResultSection.includes("markToolEnd(event.toolCallId)"),
-      "tool_result handler must clear pending tool tracking even when execution hooks never fire",
-    );
-    assert.ok(
-      toolResultSection.includes("recordToolInvocationError(event.toolName, errorText)"),
-      "tool_result handler must surface queued-skip errors for GSD tools",
-    );
-  });
-});
-
-describe("#3512: pauseAuto and stopAuto must flush queued follow-up messages", () => {
-  test("stopAuto calls clearQueue()", () => {
-    // stopAuto must flush queued messages to prevent late async_job_result
-    // notifications from triggering extra LLM turns after stop.
-    const stopAutoSection = autoSrc.slice(
-      autoSrc.indexOf("export async function stopAuto("),
-      autoSrc.indexOf("export async function pauseAuto("),
-    );
-    assert.ok(stopAutoSection, "Could not locate stopAuto function");
-    assert.ok(
-      stopAutoSection.includes("clearQueue"),
-      "stopAuto must call clearQueue() to flush queued follow-up messages",
-    );
-  });
-
-  test("pauseAuto calls clearQueue()", () => {
-    // pauseAuto must also flush queued messages — same issue as stopAuto.
-    const pauseAutoSection = autoSrc.slice(
-      autoSrc.indexOf("export async function pauseAuto("),
-    );
-    assert.ok(pauseAutoSection, "Could not locate pauseAuto function");
-    assert.ok(
-      pauseAutoSection.includes("clearQueue"),
-      "pauseAuto must call clearQueue() to flush queued follow-up messages",
-    );
-  });
-
-  test("pauseAuto rebuilds STATE.md before releasing the session lock", () => {
-    // pauseAuto must persist the DB-backed state projection so resume/debugging
-    // does not see a stale STATE.md after a mid-unit interruption.
-    const start = autoSrc.indexOf("export async function pauseAuto(");
-    const end = autoSrc.indexOf("/**\n * Build a WorktreeResolverDeps", start);
-    const pauseAutoSection = autoSrc.slice(start, end);
-    assert.ok(pauseAutoSection.length > 0, "Could not locate pauseAuto function");
-
-    const rebuildIndex = pauseAutoSection.indexOf("await rebuildState(s.basePath)");
-    const releaseIndex = pauseAutoSection.indexOf("releaseSessionLock(lockBase())");
-    assert.ok(
-      rebuildIndex >= 0,
-      "pauseAuto must rebuild STATE.md from DB-backed state before pause completes",
-    );
-    assert.ok(
-      releaseIndex >= 0,
-      "pauseAuto must still release the session lock",
-    );
-    assert.ok(
-      rebuildIndex < releaseIndex,
-      "pauseAuto must rebuild state before releasing the session lock",
-    );
-  });
-
-  test("run-unit.ts still has its existing clearQueue() call (baseline)", () => {
-    // Verify the original clearQueue pattern in run-unit.ts hasn't been removed.
-    assert.ok(
-      runUnitSrc.includes("clearQueue"),
-      "run-unit.ts must retain its clearQueue() call after unit completion",
-    );
-  });
-});
-
-describe("#4365: tool_execution_start hook must pass toolName to markToolStart", () => {
-  test("tool_execution_start handler passes event.toolName to markToolStart", () => {
-    // The tool_execution_start handler must forward toolName so that
-    // hasInteractiveToolInFlight() can correctly identify ask_user_questions
-    // and prevent the idle watchdog from firing during interactive tool calls.
-    const startMarker = 'pi.on("tool_execution_start", async (event) => {';
-    const endMarker = 'pi.on("tool_execution_end", async (event) => {';
-    const toolExecutionStartSection = registerHooksSrc.slice(
-      registerHooksSrc.indexOf(startMarker),
-      registerHooksSrc.indexOf(endMarker),
-    );
-
-    assert.ok(
-      toolExecutionStartSection.length > 0,
-      "Could not locate tool_execution_start handler section",
-    );
-    assert.ok(
-      toolExecutionStartSection.includes("markToolStart(event.toolCallId, event.toolName)"),
-      "tool_execution_start handler must pass event.toolName to markToolStart so hasInteractiveToolInFlight() works correctly",
-    );
+import { tmpdir } from "node:os";
+
+import { autoSession } from "../auto-runtime-state.ts";
+import { dispatchHookUnit } from "../auto.ts";
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { clearDiscussionFlowState, getPendingGate } from "../bootstrap/write-gate.ts";
+
+function makeHookHarness() {
+  const handlers = new Map<string, Array<(event: any, ctx: any) => Promise<any>>>();
+  const pi = {
+    on(name: string, handler: (event: any, ctx: any) => Promise<any>) {
+      const current = handlers.get(name) ?? [];
+      current.push(handler);
+      handlers.set(name, current);
+    },
+  };
+  const ctx = {
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWidget: () => {},
+    },
+    modelRegistry: {
+      setDisabledModelProviders: () => {},
+    },
+    setCompactionThresholdOverride: () => {},
+  };
+  async function emit(name: string, event: any): Promise<any> {
+    for (const handler of handlers.get(name) ?? []) {
+      const result = await handler(event, ctx);
+      if (result?.block) return result;
+    }
+    return undefined;
+  }
+  registerHooks(pi as any, []);
+  return { emit };
+}
+
+describe("hook dispatch session workspace root", () => {
+  test("dispatchHookUnit passes basePath explicitly to newSession", async (t) => {
+    const originalCwd = process.cwd();
+    const basePath = mkdtempSync(join(tmpdir(), "gsd-hook-cwd-"));
+    mkdirSync(join(basePath, ".gsd"), { recursive: true });
+    autoSession.reset();
+    t.after(() => {
+      try {
+        process.chdir(originalCwd);
+      } catch {
+        // best effort cleanup after cwd-sensitive dispatch tests
+      }
+      autoSession.reset();
+      rmSync(basePath, { recursive: true, force: true });
+    });
+
+    let newSessionOptions: unknown;
+    const ctx = {
+      ui: {
+        notify: () => {},
+        setStatus: () => {},
+        setWidget: () => {},
+      },
+      modelRegistry: {
+        getAvailable: () => [],
+      },
+      sessionManager: {
+        getSessionFile: () => join(basePath, "session.jsonl"),
+      },
+      newSession: async (options?: unknown) => {
+        newSessionOptions = options;
+        return { cancelled: false };
+      },
+    };
+    const pi = {
+      sendMessage: () => {},
+      setModel: async () => true,
+    };
+
+    const dispatched = await dispatchHookUnit(
+      ctx as any,
+      pi as any,
+      "review",
+      "execute-task",
+      "M001/S01/T01",
+      "review the completed unit",
+      undefined,
+      basePath,
+    );
+
+    assert.equal(dispatched, true);
+    assert.deepEqual(newSessionOptions, { workspaceRoot: basePath });
   });
 });
 
 describe("deep setup approval questions pause immediately", () => {
-  test("register-hooks sets pending gate during message_update without aborting the stream", () => {
-    const startMarker = 'pi.on("message_update"';
-    const endMarker = 'pi.on("session_shutdown"';
-    const messageUpdateSection = registerHooksSrc.slice(
-      registerHooksSrc.indexOf(startMarker),
-      registerHooksSrc.indexOf(endMarker),
-    );
-
-    assert.ok(
-      messageUpdateSection.length > 0,
-      "Could not locate message_update approval pause handler",
-    );
-    assert.ok(
-      messageUpdateSection.includes("shouldPauseForUserApprovalQuestion"),
-      "message_update must detect approval/question boundaries",
-    );
-    assert.ok(
-      messageUpdateSection.includes("approvalGateIdForUnit") && messageUpdateSection.includes("setPendingGate"),
-      "plain-text approval questions must set the durable write gate",
-    );
-    assert.ok(
-      messageUpdateSection.includes("getDiscussionMilestoneIdFor") && messageUpdateSection.includes('"discuss-milestone"'),
-      "foreground milestone discussion questions must also set the durable write gate",
-    );
-    assert.ok(
-      !messageUpdateSection.includes("ctx.abort()"),
-      "message_update must NOT abort the stream — aborting eats the model's question text on external CLI providers; the pending gate set above blocks subsequent tool calls instead",
-    );
+  test("plain-text approval boundary defers durable gate until same-turn CONTEXT-DRAFT can save", async () => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-deferred-approval-")));
+    const previousCwd = process.cwd();
+    try {
+      mkdirSync(join(base, ".gsd", "milestones", "M003"), { recursive: true });
+      process.chdir(base);
+      clearDiscussionFlowState(base);
+      autoSession.reset();
+      autoSession.basePath = base;
+      autoSession.currentUnit = {
+        type: "discuss-milestone",
+        id: "M003",
+        startedAt: Date.now(),
+      };
+
+      const { emit } = makeHookHarness();
+      await emit("message_update", {
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "Did I capture that correctly? If not, tell me what I missed." }],
+        },
+      });
+
+      assert.equal(
+        getPendingGate(base),
+        null,
+        "approval text should not install the durable pending gate until the assistant turn ends",
+      );
+
+      const draftResult = await emit("tool_call", {
+        toolCallId: "draft-save",
+        toolName: "gsd_summary_save",
+        input: {
+          milestone_id: "M003",
+          artifact_type: "CONTEXT-DRAFT",
+          content: "# M003 Draft\n",
+        },
+      });
+      assert.equal(
+        draftResult?.block,
+        undefined,
+        "same-turn CONTEXT-DRAFT persistence should remain allowed after the approval text streams",
+      );
+
+      const finalContextResult = await emit("tool_call", {
+        toolCallId: "final-context",
+        toolName: "gsd_summary_save",
+        input: {
+          milestone_id: "M003",
+          artifact_type: "CONTEXT",
+          content: "# M003 Context\n",
+        },
+      });
+      assert.equal(finalContextResult?.block, true, "final CONTEXT must still wait for approval");
+      assert.match(finalContextResult.reason, /Approval question "depth_verification_M003_confirm"/);
+
+      await emit("agent_end", { messages: [] });
+      assert.equal(
+        getPendingGate(base),
+        "depth_verification_M003_confirm",
+        "agent_end should activate the durable pending gate for the next turn",
+      );
+    } finally {
+      process.chdir(previousCwd);
+      autoSession.reset();
+      clearDiscussionFlowState(base);
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });

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

@@ -1,40 +1,23 @@
-import { describe, test } from "node:test";
+import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { extractSourceRegion } from "./test-helpers.ts";
+import { tmpdir } from "node:os";
 
-const systemContextSrc = readFileSync(
-  join(import.meta.dirname, "..", "bootstrap", "system-context.ts"),
-  "utf-8",
-);
-const registerHooksSrc = readFileSync(
-  join(import.meta.dirname, "..", "bootstrap", "register-hooks.ts"),
-  "utf-8",
-);
+import { ensureDbOpen } from "../bootstrap/dynamic-tools.ts";
+import { closeDatabase, isDbAvailable } from "../gsd-db.ts";
+
+afterEach(() => {
+  if (isDbAvailable()) closeDatabase();
+});
 
 describe("bootstrap deriveState DB guards (#3844)", () => {
-  test("system-context opens DB before deriveState in resume flows", () => {
-    const helperIdx = systemContextSrc.indexOf("const ensureStateDbOpen = async () => {");
-    const firstDeriveIdx = systemContextSrc.indexOf("const state = await deriveState(basePath);");
-    assert.ok(helperIdx > -1, "system-context should define a DB-open helper for deriveState callers");
-    assert.ok(firstDeriveIdx > -1, "system-context should still derive state for resume flows");
-    assert.ok(helperIdx < firstDeriveIdx, "system-context should prepare DB opening before deriveState resume calls");
-    assert.match(
-      systemContextSrc,
-      /await ensureStateDbOpen\(\);\s*\n\s*const state = await deriveState\(basePath\);/g,
-      "system-context resume flows should open DB before deriveState",
-    );
-  });
+  test("ensureDbOpen creates and opens the project DB when .gsd exists", async (t) => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-ensure-db-")));
+    t.after(() => rmSync(base, { recursive: true, force: true }));
+    mkdirSync(join(base, ".gsd"), { recursive: true });
 
-  test("register-hooks opens DB before deriveState in session_before_compact", () => {
-    const compactIdx = registerHooksSrc.indexOf('pi.on("session_before_compact"');
-    assert.ok(compactIdx > -1, "register-hooks should define session_before_compact");
-    const compactSection = extractSourceRegion(registerHooksSrc, 'pi.on("session_before_compact"');
-    const ensureIdx = compactSection.indexOf("ensureDbOpen(basePath)");
-    const deriveIdx = compactSection.indexOf("deriveGsdState(basePath)");
-    assert.ok(ensureIdx > -1, "session_before_compact should call ensureDbOpen(basePath)");
-    assert.ok(deriveIdx > -1, "session_before_compact should derive state");
-    assert.ok(ensureIdx < deriveIdx, "session_before_compact should open DB before deriveState");
+    assert.equal(await ensureDbOpen(base), true);
+    assert.equal(isDbAvailable(), true);
   });
 });