gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

package/src/resources/extensions/gsd/tests/gsd-db-workspace-scope.test.ts

@@ -0,0 +1,226 @@
+// GSD-2 + gsd-db workspace-scoped connection cache tests
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  realpathSync,
+  rmSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+import {
+  openDatabaseByWorkspace,
+  openDatabaseByScope,
+  closeDatabaseByWorkspace,
+  closeAllDatabases,
+  _getDbCache,
+  _getAdapter,
+} from "../gsd-db.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/**
+ * Create a minimal project directory with the artifacts that make
+ * createWorkspace() resolve it as a proper project root (not a bare temp dir).
+ * Returns the realpath-normalised absolute path.
+ */
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-db-ws-scope-")));
+  // hasGsdBootstrapArtifacts checks for .gsd/milestones or .gsd/PREFERENCES.md
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+/**
+ * Create a worktree path inside a project's .gsd/worktrees/<MID>/ layout.
+ * createWorkspace() will detect the /.gsd/worktrees/ segment and resolve the
+ * project root back to `projectDir`.
+ */
+function makeWorktreeDir(projectDir: string, mid: string): string {
+  const worktreeDir = join(projectDir, ".gsd", "worktrees", mid);
+  mkdirSync(worktreeDir, { recursive: true });
+  return worktreeDir;
+}
+
+// ─── Suite: same realpath → same identityKey → same DB instance ──────────────
+
+describe("openDatabaseByWorkspace: same project reuses connection", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    closeAllDatabases();
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("two createWorkspace calls with the same path share identityKey", () => {
+    const ws1 = createWorkspace(projectDir);
+    const ws2 = createWorkspace(projectDir);
+    assert.equal(ws1.identityKey, ws2.identityKey);
+  });
+
+  test("openDatabaseByWorkspace returns the same DB adapter for the same project", () => {
+    const ws1 = createWorkspace(projectDir);
+    const ws2 = createWorkspace(projectDir);
+
+    const ok1 = openDatabaseByWorkspace(ws1);
+    assert.ok(ok1, "first open should succeed");
+    const adapter1 = _getAdapter();
+
+    const ok2 = openDatabaseByWorkspace(ws2);
+    assert.ok(ok2, "second open should succeed");
+    const adapter2 = _getAdapter();
+
+    assert.equal(adapter1, adapter2, "same project → same DB adapter instance");
+    assert.equal(_getDbCache().size, 1, "only one cache entry for same project");
+  });
+});
+
+// ─── Suite: different projects → different DB instances ──────────────────────
+
+describe("openDatabaseByWorkspace: different projects get separate connections", () => {
+  let projectA: string;
+  let projectB: string;
+
+  beforeEach(() => {
+    projectA = makeProjectDir();
+    projectB = makeProjectDir();
+  });
+
+  afterEach(() => {
+    closeAllDatabases();
+    rmSync(projectA, { recursive: true, force: true });
+    rmSync(projectB, { recursive: true, force: true });
+  });
+
+  test("two different projects produce different identityKeys", () => {
+    const wsA = createWorkspace(projectA);
+    const wsB = createWorkspace(projectB);
+    assert.notEqual(wsA.identityKey, wsB.identityKey);
+  });
+
+  test("opening two different projects stores two cache entries", () => {
+    const wsA = createWorkspace(projectA);
+    const wsB = createWorkspace(projectB);
+
+    openDatabaseByWorkspace(wsA);
+    const adapterAfterA = _getAdapter();
+
+    openDatabaseByWorkspace(wsB);
+    const adapterAfterB = _getAdapter();
+
+    assert.notEqual(adapterAfterA, adapterAfterB, "different projects → different adapter instances");
+    assert.equal(_getDbCache().size, 2, "two cache entries for two distinct projects");
+  });
+});
+
+// ─── Suite: sibling worktrees share the same DB instance ─────────────────────
+
+describe("openDatabaseByWorkspace: sibling worktrees share DB connection", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    closeAllDatabases();
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("worktree path resolves to same identityKey as project root", () => {
+    const worktreeDir = makeWorktreeDir(projectDir, "M001");
+    const wsProject = createWorkspace(projectDir);
+    const wsWorktree = createWorkspace(worktreeDir);
+    assert.equal(
+      wsProject.identityKey,
+      wsWorktree.identityKey,
+      "project root and sibling worktree share identityKey",
+    );
+  });
+
+  test("opening via project path and via worktree path yields the same DB adapter", () => {
+    const worktreeDir = makeWorktreeDir(projectDir, "M001");
+    const wsProject = createWorkspace(projectDir);
+    const wsWorktree = createWorkspace(worktreeDir);
+
+    openDatabaseByWorkspace(wsProject);
+    const adapterProject = _getAdapter();
+
+    openDatabaseByWorkspace(wsWorktree);
+    const adapterWorktree = _getAdapter();
+
+    assert.equal(
+      adapterProject,
+      adapterWorktree,
+      "sibling worktree reuses the same DB adapter as the project root",
+    );
+    assert.equal(_getDbCache().size, 1, "only one cache entry for project + sibling worktree");
+  });
+});
+
+// ─── Suite: closing removes only the targeted cache entry ─────────────────────
+
+describe("closeDatabaseByWorkspace: removes only the targeted cache entry", () => {
+  let projectA: string;
+  let projectB: string;
+
+  beforeEach(() => {
+    projectA = makeProjectDir();
+    projectB = makeProjectDir();
+  });
+
+  afterEach(() => {
+    closeAllDatabases();
+    rmSync(projectA, { recursive: true, force: true });
+    rmSync(projectB, { recursive: true, force: true });
+  });
+
+  test("closing workspace A removes only A from the cache", () => {
+    const wsA = createWorkspace(projectA);
+    const wsB = createWorkspace(projectB);
+
+    openDatabaseByWorkspace(wsA);
+    openDatabaseByWorkspace(wsB);
+    assert.equal(_getDbCache().size, 2, "precondition: two cache entries");
+
+    closeDatabaseByWorkspace(wsA);
+
+    assert.equal(_getDbCache().size, 1, "one entry remains after closing A");
+    assert.ok(!_getDbCache().has(wsA.identityKey), "A's entry is gone");
+    assert.ok(_getDbCache().has(wsB.identityKey), "B's entry is still present");
+  });
+
+  test("closing the active workspace via closeDatabaseByWorkspace nulls currentDb", () => {
+    const wsA = createWorkspace(projectA);
+
+    openDatabaseByWorkspace(wsA);
+    assert.ok(_getAdapter() !== null, "precondition: adapter is open");
+
+    // Make wsA the active connection explicitly.
+    openDatabaseByWorkspace(wsA);
+    closeDatabaseByWorkspace(wsA);
+
+    // After closing the active connection, the global adapter should be null.
+    assert.equal(_getAdapter(), null, "currentDb should be null after closing active workspace");
+    assert.equal(_getDbCache().size, 0, "cache should be empty after closing sole entry");
+  });
+
+  test("openDatabaseByScope delegates to workspace correctly", () => {
+    const ws = createWorkspace(projectA);
+    const scope = scopeMilestone(ws, "M001");
+
+    const ok = openDatabaseByScope(scope);
+    assert.ok(ok, "openDatabaseByScope should succeed");
+    assert.ok(_getDbCache().has(ws.identityKey), "cache entry exists after openDatabaseByScope");
+
+    closeDatabaseByWorkspace(ws);
+  });
+});

package/src/resources/extensions/gsd/tests/gsd-root-canonical.test.ts

@@ -0,0 +1,66 @@
+// GSD-2 + gsd-root-canonical: gsdRoot() result is realpath-canonicalized before caching
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+
+import { gsdRoot, _clearGsdRootCache } from "../paths.ts";
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("gsdRoot: returns realpath-canonicalized result", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-root-canon-")));
+    mkdirSync(join(projectDir, ".gsd"), { recursive: true });
+    _clearGsdRootCache();
+  });
+
+  afterEach(() => {
+    _clearGsdRootCache();
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("gsdRoot from a canonical project path returns a realpath-canonicalized result", () => {
+    const result = gsdRoot(projectDir);
+    const canonical = realpathSync(join(projectDir, ".gsd"));
+    assert.equal(result, canonical, "gsdRoot must return the realpath of the .gsd directory");
+  });
+
+  test("gsdRoot via a symlinked project path returns the realpath-canonicalized .gsd", (t) => {
+    // Create a symlink pointing to projectDir
+    const linkPath = join(tmpdir(), `gsd-root-link-${randomUUID()}`);
+    symlinkSync(projectDir, linkPath);
+    t.after(() => {
+      try { rmSync(linkPath); } catch { /* ignore */ }
+    });
+
+    _clearGsdRootCache();
+
+    const result = gsdRoot(linkPath);
+    // The canonical .gsd is under the realpath of projectDir, not the symlink
+    const canonicalGsd = realpathSync(join(projectDir, ".gsd"));
+
+    assert.equal(
+      result,
+      canonicalGsd,
+      `gsdRoot via symlink ("${linkPath}") must return the realpath'd .gsd ("${canonicalGsd}"), not a symlink-based path`,
+    );
+
+    // Also verify that the result does NOT contain the symlink in its path
+    assert.ok(
+      !result.startsWith(linkPath),
+      `gsdRoot result must not start with the symlink path "${linkPath}"`,
+    );
+  });
+});

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

@@ -1,10 +1,13 @@
 /**
- * GSD2 — regression test for #5187: gsdRoot() must refuse to use the global
- * GSD home (~/.gsd) as a project .gsd directory when basePath resolves to
- * $HOME. Paths under ~/.gsd/projects/<hash>/ remain valid.
+ * GSD2 — regression tests for #5187 and git-root anchor guard:
  *
- * Before the fix, gsdRoot(homedir()) returned ~/.gsd silently and downstream
- * writes polluted the user's global state directory. After the fix, it throws.
+ * #5187: gsdRoot() must refuse to use the global GSD home (~/.gsd) as a
+ * project .gsd directory when basePath resolves to $HOME. Paths under
+ * ~/.gsd/projects/<hash>/ remain valid.
+ *
+ * git-root anchor guard: when $HOME is itself a git repo and ~/.gsd exists,
+ * gsdRoot() must NOT return ~/.gsd for a subdir basePath like ~/projects/foo.
+ * It should fall through to step 4 (creation fallback) instead.
  */
 
 import { describe, test, beforeEach, afterEach } from 'node:test';
@@ -12,6 +15,7 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, realpathSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
 
 import { gsdRoot, _clearGsdRootCache } from '../paths.ts';
 
@@ -84,3 +88,62 @@ describe('gsdRoot() refuses ~/.gsd as project state when basePath is $HOME (#518
     }
   });
 });
+
+describe('git-root anchor guard: subdir basePath must not resolve to ~/.gsd', () => {
+  let fakeHome: string;
+  let subDir: string;
+  let savedHome: string | undefined;
+  let savedUserProfile: string | undefined;
+  let savedGsdHome: string | undefined;
+
+  beforeEach(() => {
+    // Create a tmpdir that will act as both $HOME and a git repo root.
+    fakeHome = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-anchor-guard-')));
+    // Init a bare-minimum git repo so git rev-parse --show-toplevel returns fakeHome.
+    spawnSync('git', ['init', fakeHome], { encoding: 'utf-8' });
+    // Create ~/.gsd (the global home that must NOT be used for project subdirs).
+    mkdirSync(join(fakeHome, '.gsd'), { recursive: true });
+    // Create a subdir inside the git repo — this is the project basePath.
+    subDir = join(fakeHome, 'projects', 'foo');
+    mkdirSync(subDir, { recursive: true });
+
+    savedHome = process.env.HOME;
+    savedUserProfile = process.env.USERPROFILE;
+    savedGsdHome = process.env.GSD_HOME;
+
+    process.env.HOME = fakeHome;
+    process.env.USERPROFILE = fakeHome;
+    delete process.env.GSD_HOME;
+
+    _clearGsdRootCache();
+  });
+
+  afterEach(() => {
+    if (savedHome === undefined) delete process.env.HOME;
+    else process.env.HOME = savedHome;
+    if (savedUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = savedUserProfile;
+    if (savedGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = savedGsdHome;
+
+    _clearGsdRootCache();
+    rmSync(fakeHome, { recursive: true, force: true });
+  });
+
+  test('does NOT return ~/.gsd when $HOME is a git repo and basePath is a subdir', () => {
+    // fakeHome IS the git root AND $HOME, so git rev-parse returns fakeHome,
+    // and ~/.gsd (fakeHome/.gsd) exists. The guard must skip that candidate
+    // and fall through to the creation fallback: subDir/.gsd.
+    const result = gsdRoot(subDir);
+    assert.notEqual(
+      result,
+      join(fakeHome, '.gsd'),
+      'gsdRoot must not return ~/.gsd for a subdir basePath',
+    );
+    assert.equal(
+      result,
+      join(subDir, '.gsd'),
+      'gsdRoot should fall through to the creation fallback for a subdir',
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/guided-flow-prompt-consolidation.test.ts

@@ -86,8 +86,8 @@ describe("guided-flow → auto-prompts consolidation (#5183)", () => {
     assert.ok(prompt.includes(TID), "must mention task id");
     assert.ok(prompt.includes(T_TITLE), "must mention task title");
     assert.ok(
-      prompt.includes("gsd_complete_task"),
-      "must instruct calling the canonical gsd_complete_task tool",
+      prompt.includes("gsd_task_complete"),
+      "must instruct calling the canonical gsd_task_complete tool",
     );
     assert.ok(
       prompt.includes(base),
@@ -110,8 +110,8 @@ describe("guided-flow → auto-prompts consolidation (#5183)", () => {
     assert.ok(prompt.includes(SID), "must mention slice id");
     assert.ok(prompt.includes(S_TITLE), "must mention slice title");
     assert.ok(
-      prompt.includes("gsd_complete_slice"),
-      "must instruct calling gsd_complete_slice (was in guided-complete-slice.md)",
+      prompt.includes("gsd_slice_complete"),
+      "must instruct calling gsd_slice_complete (was in guided-complete-slice.md)",
     );
     assert.ok(
       prompt.includes(base),

package/src/resources/extensions/gsd/tests/integration/auto-worktree.test.ts

@@ -160,7 +160,7 @@ describe("auto-worktree lifecycle", () => {
       assert.ok(realWtPath.startsWith(storage), "git registered the symlink-resolved worktree path");
 
       _resetAutoWorktreeOriginalBaseForTests();
-      process.chdir(join(realWtPath, ".gsd", "milestones", "M001"));
+      process.chdir(realWtPath);
 
       assert.ok(isInAutoWorktree(tempDir), "structural detection works without module originalBase");
       const resolved = getAutoWorktreePath(realWtPath, "M001");
@@ -169,7 +169,7 @@ describe("auto-worktree lifecycle", () => {
       assert.equal(existsSync(join(realWtPath, ".gsd", "worktrees", "M001")), false);
 
       enterAutoWorktree(tempDir, "M001");
-      process.chdir(join(realWtPath, ".gsd", "milestones", "M001"));
+      process.chdir(realWtPath);
       assert.deepStrictEqual(
         getActiveAutoWorktreeContext(),
         {
@@ -282,7 +282,7 @@ describe("auto-worktree lifecycle", () => {
     teardownAutoWorktree(tempDir, "M010");
   });
 
-  test("#778: reconcile plan checkboxes on re-attach", async () => {
+  test("#778: re-attach does not reconcile plan checkboxes into a worktree-local .gsd projection", async () => {
     tempDir = createTempRepo();
     const msDir = join(tempDir, ".gsd", "milestones", "M003");
     mkdirSync(msDir, { recursive: true });
@@ -322,23 +322,31 @@ describe("auto-worktree lifecycle", () => {
       "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
     );
 
-    // Create worktree re-attached to existing milestone branch (T02 still [ ] in branch)
+    // Re-attaching the worktree should not reconcile the branch copy from the
+    // project-root plan. The project root stays canonical; the worktree keeps
+    // the milestone branch's tracked file contents until a git operation
+    // changes them.
     const wtPath = createAutoWorktree(tempDir, "M004");
 
     try {
       const wtPlanPath = join(wtPath, planRelPath);
-      assert.ok(existsSync(wtPlanPath), "plan file exists in worktree after re-attach");
+      assert.ok(existsSync(wtPlanPath), "tracked plan file remains present in the worktree branch");
 
       const wtPlan = read(wtPlanPath, "utf-8");
-      assert.ok(wtPlan.includes("- [x] **T02:"), "T02 should be [x] after reconciliation (was [ ] on branch)");
-      assert.ok(wtPlan.includes("- [x] **T01:"), "T01 stays [x]");
-      assert.ok(wtPlan.includes("- [ ] **T03:"), "T03 stays [ ] (not in root either)");
+      assert.ok(wtPlan.includes("- [ ] **T02:"), "worktree branch should retain its unreconciled T02 [ ] state");
+      assert.ok(wtPlan.includes("- [x] **T01:"), "worktree branch should retain T01 [x]");
+      assert.ok(wtPlan.includes("- [ ] **T03:"), "worktree branch should retain T03 [ ]");
+
+      const rootPlan = read(join(tempDir, planRelPath), "utf-8");
+      assert.ok(rootPlan.includes("- [x] **T02:"), "canonical root plan retains the newer T02 [x] state");
+      assert.ok(rootPlan.includes("- [x] **T01:"), "canonical root plan retains T01 [x]");
+      assert.ok(rootPlan.includes("- [ ] **T03:"), "canonical root plan retains T03 [ ]");
     } finally {
       teardownAutoWorktree(tempDir, "M004");
     }
   });
 
-  test("#2791: mcp.json copied into worktree via copyPlanningArtifacts", () => {
+  test("#2791: mcp.json is not copied into worktree on creation after copyPlanningArtifacts removal", () => {
     tempDir = createTempRepo();
     const msDir = join(tempDir, ".gsd", "milestones", "M003");
     mkdirSync(msDir, { recursive: true });
@@ -347,7 +355,8 @@ describe("auto-worktree lifecycle", () => {
     run("git commit -m \"add milestone\"", tempDir);
 
     // Create mcp.json in .gsd/ AFTER the commit (untracked, like real usage).
-    // copyPlanningArtifacts should copy it into the worktree's .gsd/.
+    // Phase C removed copyPlanningArtifacts, so creation should not seed a
+    // second worktree-local copy.
     writeFileSync(
       join(tempDir, ".gsd", "mcp.json"),
       JSON.stringify({ servers: { test: { command: "echo" } } }),
@@ -356,9 +365,10 @@ describe("auto-worktree lifecycle", () => {
     const wtPath = createAutoWorktree(tempDir, "M003");
 
     try {
-      assert.ok(
+      assert.equal(
         existsSync(join(wtPath, ".gsd", "mcp.json")),
-        "mcp.json should be copied into worktree .gsd/ on creation",
+        false,
+        "mcp.json should not be copied into worktree .gsd/ on creation",
       );
     } finally {
       teardownAutoWorktree(tempDir, "M003");

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

@@ -240,17 +240,31 @@ describe('doctor-proactive', async () => {
       cleanups.push(dir);
       mkdirSync(join(dir, ".gsd"), { recursive: true });
 
-      // Write a stale lock
-      writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify({
-        pid: 9999999, startedAt: "2026-03-10T00:00:00Z",
-        unitType: "execute-task", unitId: "M001/S01/T01",
-        unitStartedAt: "2026-03-10T00:01:00Z", completedUnits: 3,
-      }));
+      // Phase C pt 2: stale lock state lives in the workers table now.
+      // Open the DB, insert a fake stale worker row directly (PID 9999999
+      // is functionally guaranteed dead), then close — the doctor will
+      // re-open via its own path.
+      const { openDatabase, _getAdapter } = await import("../../gsd-db.ts");
+      const { randomUUID } = await import("node:crypto");
+      openDatabase(join(dir, ".gsd", "gsd.db"));
+      const db = _getAdapter()!;
+      db.prepare(
+        `INSERT INTO workers (worker_id, host, pid, started_at, version, last_heartbeat_at, status, project_root_realpath)
+         VALUES (:w, 'test-host', 9999999, '2026-03-10T00:00:00Z', 'test', '1970-01-01T00:00:00.000Z', 'active', :root)`,
+      ).run({ ":w": `test-fake-${randomUUID().slice(0, 8)}`, ":root": dir });
+      const { closeDatabase } = await import("../../gsd-db.ts");
+      closeDatabase();
 
-      const result = await preDispatchHealthGate(dir);
-      assert.ok(result.proceed, "gate passes after auto-clearing stale lock");
-      assert.ok(result.fixesApplied.some(f => f.includes("cleared stale auto.lock")), "reports lock cleared");
-      assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "lock file removed");
+      try {
+        const result = await preDispatchHealthGate(dir);
+        assert.ok(result.proceed, "gate passes after auto-clearing stale lock");
+        assert.ok(
+          result.fixesApplied.some(f => f.includes("cleared stale") || f.includes("cleared stale auto.lock")),
+          `reports lock cleared (got: ${result.fixesApplied.join(", ")})`,
+        );
+      } finally {
+        closeDatabase();
+      }
     });
 
     test('health gate: corrupt merge state auto-healed', async () => {

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

@@ -60,20 +60,24 @@ describe('doctor-runtime', async () => {
 
   try {
     // ─── Test 1: Stale crash lock detection & fix ─────────────────────
-    test('stale_crash_lock', async () => {
+    test('stale_crash_lock', async (t) => {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
-      // Write a lock file with a PID that is definitely dead (use PID 1 million+)
-      const lockData = {
-        pid: 9999999,
-        startedAt: "2026-03-10T00:00:00Z",
-        unitType: "execute-task",
-        unitId: "M001/S01/T01",
-        unitStartedAt: "2026-03-10T00:01:00Z",
-        completedUnits: 3,
-      };
-      writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+      // Phase C pt 2: stale lock state lives in the workers table now.
+      // Insert a fake stale worker row directly (PID 9999999 is dead).
+      const { openDatabase, _getAdapter } = await import("../../gsd-db.ts");
+      const gsdDb = await import("../../gsd-db.ts");
+      t.after(() => { gsdDb.closeDatabase(); });
+      const { randomUUID } = await import("node:crypto");
+      openDatabase(join(dir, ".gsd", "gsd.db"));
+      const db = _getAdapter()!;
+      db.prepare(
+        `INSERT INTO workers (worker_id, host, pid, started_at, version, last_heartbeat_at, status, project_root_realpath)
+         VALUES (:w, 'test-host', 9999999, '2026-03-10T00:00:00Z', 'test', '1970-01-01T00:00:00.000Z', 'active', :root)`,
+      ).run({ ":w": `test-fake-${randomUUID().slice(0, 8)}`, ":root": dir });
+      // Leave DB open — runGSDDoctor's readCrashLock relies on the
+      // currently-open DB connection (it does not open one of its own).
 
       const detect = await runGSDDoctor(dir);
       const lockIssues = detect.issues.filter(i => i.code === "stale_crash_lock");
@@ -82,8 +86,15 @@ describe('doctor-runtime', async () => {
       assert.ok(lockIssues[0]?.fixable === true, "stale lock is fixable");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("cleared stale auto.lock")), "fix clears stale lock");
-      assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock removed after fix");
+      assert.ok(
+        fixed.fixesApplied.some(f => f.includes("cleared stale")),
+        `fix clears stale lock (got: ${fixed.fixesApplied.join(", ")})`,
+      );
+
+      // Close DB so subsequent tests in this file (which expect a clean
+      // state) don't see this test's connection lingering.
+      const { closeDatabase } = await import("../../gsd-db.ts");
+      closeDatabase();
     });
 
     // ─── Test 2: No false positive for missing lock ───────────────────
@@ -417,18 +428,19 @@ node_modules/
       const dir = createMinimalProject();
       cleanups.push(dir);
 
-      // Create lock dir + auto.lock with PID 1 (init/launchd — always alive, never our own PID)
+      // Create lock dir + insert a live worker row (PID 1 = init/launchd —
+      // always alive, never our own PID). Phase C pt 2: worker liveness
+      // lives in the workers table. last_heartbeat_at = now → not stale.
       const lockDir = join(dir, ".gsd.lock");
       mkdirSync(lockDir, { recursive: true });
-      const liveLockData = {
-        pid: 1,
-        startedAt: new Date().toISOString(),
-        unitType: "execute-task",
-        unitId: "M001/S01/T01",
-        unitStartedAt: new Date().toISOString(),
-        completedUnits: 1,
-      };
-      writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(liveLockData, null, 2));
+      const { openDatabase, _getAdapter } = await import("../../gsd-db.ts");
+      const { randomUUID } = await import("node:crypto");
+      openDatabase(join(dir, ".gsd", "gsd.db"));
+      const db = _getAdapter()!;
+      db.prepare(
+        `INSERT INTO workers (worker_id, host, pid, started_at, version, last_heartbeat_at, status, project_root_realpath)
+         VALUES (:w, 'test-host', 1, :now, 'test', :now, 'active', :root)`,
+      ).run({ ":w": `test-fake-${randomUUID().slice(0, 8)}`, ":now": new Date().toISOString(), ":root": dir });
 
       const detect = await runGSDDoctor(dir);
       const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");