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

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");

package/src/resources/extensions/gsd/tests/integration/workspace-collapse-integration.test.ts

@@ -141,21 +141,20 @@ describe("workspace-collapse integration: Test 2 — abort teardown clears stale
     rmSync(repoDir, { recursive: true, force: true });
   });
 
-  test("STATE.md, auto.lock, and M001-META.json are removed by teardownAutoWorktree", () => {
+  test("STATE.md and M001-META.json are removed by teardownAutoWorktree", () => {
+    // Phase C pt 2: auto.lock no longer exists as a file — it migrated
+    // to the workers + unit_dispatches tables.
     const gsdDir = join(repoDir, ".gsd");
     const milestonesDir = join(gsdDir, "milestones", "M001");
     mkdirSync(milestonesDir, { recursive: true });
 
     const stateMd = join(gsdDir, "STATE.md");
-    const autoLock = join(gsdDir, "auto.lock");
     const metaJson = join(milestonesDir, "M001-META.json");
 
     writeFileSync(stateMd, "# State\nactive\n");
-    writeFileSync(autoLock, JSON.stringify({ pid: process.pid, unitType: "plan-milestone", unitId: "M001" }));
     writeFileSync(metaJson, JSON.stringify({ milestoneId: "M001" }));
 
     assert.ok(existsSync(stateMd), "STATE.md exists before teardown");
-    assert.ok(existsSync(autoLock), "auto.lock exists before teardown");
     assert.ok(existsSync(metaJson), "M001-META.json exists before teardown");
 
     // teardownAutoWorktree clears state files before the git step; git removal
@@ -167,7 +166,6 @@ describe("workspace-collapse integration: Test 2 — abort teardown clears stale
     }
 
     assert.ok(!existsSync(stateMd), "STATE.md removed by teardownAutoWorktree (regression: A5)");
-    assert.ok(!existsSync(autoLock), "auto.lock removed by teardownAutoWorktree (regression: A5)");
     assert.ok(!existsSync(metaJson), "M001-META.json removed by teardownAutoWorktree (regression: A5)");
   });
 });

package/src/resources/extensions/gsd/tests/interrupted-session-auto.test.ts

@@ -6,6 +6,21 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import { assessInterruptedSession } from "../interrupted-session.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  _getAdapter,
+} from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import { recordDispatchClaim } from "../db/unit-dispatches.ts";
+import { setRuntimeKv } from "../db/runtime-kv.ts";
+import {
+  PAUSED_SESSION_KV_KEY,
+  type PausedSessionMetadata,
+} from "../interrupted-session.ts";
+import { normalizeRealPath } from "../paths.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-auto-interrupted-${randomUUID()}`);
@@ -14,9 +29,61 @@ function makeTmpBase(): string {
 }
 
 function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* */ }
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
+function openFixtureDb(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+}
+
+function expireWorker(workerId: string): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE workers SET last_heartbeat_at = '1970-01-01T00:00:00.000Z' WHERE worker_id = :worker_id`,
+  ).run({ ":worker_id": workerId });
+}
+
+function writeLock(base: string, unitType: string, unitId: string): void {
+  openFixtureDb(base);
+  insertMilestone({
+    id: "M001",
+    title: "Test Milestone",
+    status: unitType === "complete-slice" ? "complete" : "active",
+  });
+  const workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true);
+  if (lease.ok) {
+    const [, sliceId = null, taskId = null] = unitId.split("/");
+    const claimed = recordDispatchClaim({
+      traceId: `trace-${randomUUID().slice(0, 8)}`,
+      workerId,
+      milestoneLeaseToken: lease.token,
+      milestoneId: "M001",
+      sliceId,
+      taskId,
+      unitType,
+      unitId,
+    });
+    assert.equal(claimed.ok, true);
+  }
+  _getAdapter()!
+    .prepare(`UPDATE workers SET pid = 99999 WHERE worker_id = :worker_id`)
+    .run({ ":worker_id": workerId });
+  expireWorker(workerId);
+}
+
+function writePausedSession(base: string, milestoneId = "M001", stepMode = false): void {
+  openFixtureDb(base);
+  const meta: PausedSessionMetadata = {
+    milestoneId,
+    originalBasePath: base,
+    stepMode,
+  };
+  setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, meta);
+}
+
 function writeRoadmap(base: string, checked = false): void {
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
   mkdirSync(join(milestoneDir, "slices", "S01", "tasks"), { recursive: true });
@@ -51,42 +118,22 @@ function writeRoadmap(base: string, checked = false): void {
 function writeCompleteArtifacts(base: string): void {
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
   const sliceDir = join(milestoneDir, "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
   mkdirSync(sliceDir, { recursive: true });
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01: Test Slice\n\n## Tasks\n- [x] **T01: Do thing** `est:10m`\n", "utf-8");
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# Task Summary\nDone.\n", "utf-8");
   writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# Summary\nDone.\n", "utf-8");
   writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\nPassed.\n", "utf-8");
   writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\nDone.\n", "utf-8");
 }
 
-function writeLock(base: string, unitType: string, unitId: string): void {
-  writeFileSync(
-    join(base, ".gsd", "auto.lock"),
-    JSON.stringify({
-      pid: 999999999,
-      startedAt: new Date().toISOString(),
-      unitType,
-      unitId,
-      unitStartedAt: new Date().toISOString(),
-    }, null, 2),
-    "utf-8",
-  );
-}
-
-function writePausedSession(base: string, milestoneId = "M001", stepMode = false): void {
-  const runtimeDir = join(base, ".gsd", "runtime");
-  mkdirSync(runtimeDir, { recursive: true });
-  writeFileSync(
-    join(runtimeDir, "paused-session.json"),
-    JSON.stringify({ milestoneId, originalBasePath: base, stepMode }, null, 2),
-    "utf-8",
-  );
-}
-
 test("direct /gsd auto stale complete repo yields stale classification with no recovery payload", async () => {
   const base = makeTmpBase();
   try {
     writeRoadmap(base, true);
     writeCompleteArtifacts(base);
-    writeLock(base, "execute-task", "M001/S01/T01");
+    writeLock(base, "complete-slice", "M001/S01");
 
     const assessment = await assessInterruptedSession(base);
     assert.equal(assessment.classification, "stale");

package/src/resources/extensions/gsd/tests/interrupted-session-ui.test.ts

@@ -6,6 +6,21 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import { assessInterruptedSession } from "../interrupted-session.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  _getAdapter,
+} from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import { recordDispatchClaim } from "../db/unit-dispatches.ts";
+import { setRuntimeKv } from "../db/runtime-kv.ts";
+import {
+  PAUSED_SESSION_KV_KEY,
+  type PausedSessionMetadata,
+} from "../interrupted-session.ts";
+import { normalizeRealPath } from "../paths.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-smart-entry-${randomUUID()}`);
@@ -14,9 +29,61 @@ function makeTmpBase(): string {
 }
 
 function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* */ }
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
+function openFixtureDb(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+}
+
+function expireWorker(workerId: string): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE workers SET last_heartbeat_at = '1970-01-01T00:00:00.000Z' WHERE worker_id = :worker_id`,
+  ).run({ ":worker_id": workerId });
+}
+
+function writePausedSession(base: string, milestoneId = "M001", stepMode = false): void {
+  openFixtureDb(base);
+  const meta: PausedSessionMetadata = {
+    milestoneId,
+    originalBasePath: base,
+    stepMode,
+  };
+  setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, meta);
+}
+
+function writeLock(base: string, unitType: string, unitId: string): void {
+  openFixtureDb(base);
+  insertMilestone({
+    id: "M001",
+    title: "Test Milestone",
+    status: unitType === "complete-slice" ? "complete" : "active",
+  });
+  const workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true);
+  if (lease.ok) {
+    const [, sliceId = null, taskId = null] = unitId.split("/");
+    const claimed = recordDispatchClaim({
+      traceId: `trace-${randomUUID().slice(0, 8)}`,
+      workerId,
+      milestoneLeaseToken: lease.token,
+      milestoneId: "M001",
+      sliceId,
+      taskId,
+      unitType,
+      unitId,
+    });
+    assert.equal(claimed.ok, true);
+  }
+  _getAdapter()!
+    .prepare(`UPDATE workers SET pid = 99999 WHERE worker_id = :worker_id`)
+    .run({ ":worker_id": workerId });
+  expireWorker(workerId);
+}
+
 function writeRoadmap(base: string, checked = false): void {
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
   mkdirSync(join(milestoneDir, "slices", "S01", "tasks"), { recursive: true });
@@ -51,42 +118,22 @@ function writeRoadmap(base: string, checked = false): void {
 function writeCompleteArtifacts(base: string): void {
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
   const sliceDir = join(milestoneDir, "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
   mkdirSync(sliceDir, { recursive: true });
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01: Test Slice\n\n## Tasks\n- [x] **T01: Do thing** `est:10m`\n", "utf-8");
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# Task Summary\nDone.\n", "utf-8");
   writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# Summary\nDone.\n", "utf-8");
   writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\nPassed.\n", "utf-8");
   writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\nDone.\n", "utf-8");
 }
 
-function writePausedSession(base: string, milestoneId = "M001", stepMode = false): void {
-  const runtimeDir = join(base, ".gsd", "runtime");
-  mkdirSync(runtimeDir, { recursive: true });
-  writeFileSync(
-    join(runtimeDir, "paused-session.json"),
-    JSON.stringify({ milestoneId, originalBasePath: base, stepMode }, null, 2),
-    "utf-8",
-  );
-}
-
-function writeLock(base: string, unitType: string, unitId: string): void {
-  writeFileSync(
-    join(base, ".gsd", "auto.lock"),
-    JSON.stringify({
-      pid: 999999999,
-      startedAt: new Date().toISOString(),
-      unitType,
-      unitId,
-      unitStartedAt: new Date().toISOString(),
-    }, null, 2),
-    "utf-8",
-  );
-}
-
 test("guided-flow stale complete scenario classifies as stale so the resume prompt can be suppressed", async () => {
   const base = makeTmpBase();
   try {
     writeRoadmap(base, true);
     writeCompleteArtifacts(base);
-    writeLock(base, "execute-task", "M001/S01/T01");
+    writeLock(base, "complete-slice", "M001/S01");
 
     const assessment = await assessInterruptedSession(base);
     assert.equal(assessment.classification, "stale");

package/src/resources/extensions/gsd/tests/memory-pressure-stuck-state.test.ts

@@ -40,23 +40,26 @@ describe("stuck detection persistence (#3704)", () => {
     assert.match(loopSource, /function saveStuckState/);
   });
 
+  // Phase C: API changed from (basePath) to (session) — recentUnits is
+  // now reconstructed from unit_dispatches and stuckRecoveryAttempts
+  // persists in runtime_kv (worker scope).
   test("loopState initialized from persisted state", () => {
-    assert.match(loopSource, /loadStuckState\(s\.basePath\)/);
+    assert.match(loopSource, /loadStuckState\(s\)/);
   });
 
   test("stuck state saved after each iteration", () => {
-    assert.match(loopSource, /saveStuckState\(s\.basePath,\s*loopState\)/);
+    assert.match(loopSource, /saveStuckState\(s,\s*loopState\)/);
   });
 
-  test("stuck state file path uses runtime directory", () => {
-    assert.match(loopSource, /stuck-state\.json/);
-  });
+  // Phase C: stuck-state.json file IO deleted; persistence moved to
+  // unit_dispatches (recentUnits) + runtime_kv (stuckRecoveryAttempts).
+  // The stuck-state-via-db.test.ts suite covers the round-trip.
 
   test("saveStuckState called in standard dev path as well as custom engine path (#4382)", () => {
     // Count all call-sites of saveStuckState (excluding the function definition itself).
     // After the fix, both the custom-engine path and the standard dev path must each
     // call saveStuckState so stuckRecoveryAttempts survives session restarts.
-    const callMatches = loopSource.match(/saveStuckState\(s\.basePath,\s*loopState\)/g) ?? [];
+    const callMatches = loopSource.match(/saveStuckState\(s,\s*loopState\)/g) ?? [];
     assert.ok(
       callMatches.length >= 2,
       `saveStuckState must be called in both the custom-engine path and the standard dev path ` +

package/src/resources/extensions/gsd/tests/milestone-leases.test.ts

@@ -0,0 +1,152 @@
+// gsd-2 + Milestone leases tests (Phase B coordination — fencing semantics)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  _getAdapter,
+} from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import {
+  claimMilestoneLease,
+  releaseMilestoneLease,
+  refreshMilestoneLease,
+  getMilestoneLease,
+} from "../db/milestone-leases.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-leases-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("first claim returns ok=true with token=1", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+  const w1 = registerAutoWorker({ projectRootRealpath: base });
+  const claim = claimMilestoneLease(w1, "M001");
+  assert.equal(claim.ok, true);
+  if (claim.ok) {
+    assert.equal(claim.token, 1, "fresh claim starts fencing token at 1");
+  }
+
+  const row = getMilestoneLease("M001");
+  assert.ok(row);
+  assert.equal(row!.worker_id, w1);
+  assert.equal(row!.fencing_token, 1);
+  assert.equal(row!.status, "held");
+});
+
+test("second claim by different worker is rejected while lease is held", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+  const w1 = registerAutoWorker({ projectRootRealpath: base });
+  const w2 = registerAutoWorker({ projectRootRealpath: base });
+  const first = claimMilestoneLease(w1, "M001");
+  assert.equal(first.ok, true);
+
+  const second = claimMilestoneLease(w2, "M001");
+  assert.equal(second.ok, false);
+  if (!second.ok) {
+    assert.equal(second.error, "held_by");
+    assert.equal(second.byWorker, w1);
+  }
+});
+
+test("releaseMilestoneLease frees the lease for takeover", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+  const w1 = registerAutoWorker({ projectRootRealpath: base });
+  const w2 = registerAutoWorker({ projectRootRealpath: base });
+  const first = claimMilestoneLease(w1, "M001");
+  assert.equal(first.ok, true);
+
+  if (first.ok) {
+    const released = releaseMilestoneLease(w1, "M001", first.token);
+    assert.equal(released, true);
+  }
+
+  // After release, w2 may take over with monotonically larger token
+  const second = claimMilestoneLease(w2, "M001");
+  assert.equal(second.ok, true);
+  if (second.ok) {
+    assert.equal(second.token, 2, "takeover increments fencing token monotonically");
+  }
+});
+
+test("expired lease (TTL passed) allows takeover with token+1", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+  const w1 = registerAutoWorker({ projectRootRealpath: base });
+  const w2 = registerAutoWorker({ projectRootRealpath: base });
+  const first = claimMilestoneLease(w1, "M001");
+  assert.equal(first.ok, true);
+
+  // Force expiration by patching the row's expires_at into the past.
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE milestone_leases SET expires_at = '1970-01-01T00:00:00.000Z' WHERE milestone_id = 'M001'`,
+  ).run();
+
+  const takeover = claimMilestoneLease(w2, "M001");
+  assert.equal(takeover.ok, true);
+  if (takeover.ok) {
+    assert.equal(takeover.token, 2);
+  }
+  const row = getMilestoneLease("M001");
+  assert.equal(row!.worker_id, w2);
+  assert.equal(row!.fencing_token, 2);
+});
+
+test("refreshMilestoneLease only succeeds with the matching fencing token", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+  const w1 = registerAutoWorker({ projectRootRealpath: base });
+  const claim = claimMilestoneLease(w1, "M001");
+  assert.equal(claim.ok, true);
+  if (!claim.ok) return;
+
+  // Correct token refreshes
+  assert.equal(refreshMilestoneLease(w1, "M001", claim.token), true);
+
+  // Stale token (e.g. claim.token - 1) refuses
+  assert.equal(refreshMilestoneLease(w1, "M001", claim.token - 1), false);
+});
+
+test("claimMilestoneLease rethrows foreign-key failures instead of treating them as lease contention", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+  assert.throws(
+    () => claimMilestoneLease("missing-worker", "M001"),
+    /FOREIGN KEY constraint failed/,
+  );
+});

package/src/resources/extensions/gsd/tests/parallel-milestone-isolation.test.ts

@@ -0,0 +1,106 @@
+// gsd-2 + Parallel-worker isolation regression (Phase B coordination)
+//
+// Two simulated workers attempt to claim leases on the same project. The
+// lease infrastructure must guarantee:
+//   - On the same milestone: only one wins; the loser sees held_by error
+//   - On different milestones: both succeed independently
+//
+// This is the integration check that ties registerAutoWorker +
+// claimMilestoneLease + recordDispatchClaim together end-to-end.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+} from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import { recordDispatchClaim } from "../db/unit-dispatches.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-parallel-iso-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("two workers contesting the same milestone: only one wins the lease", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Contested", status: "active" });
+
+  const w1 = registerAutoWorker({ projectRootRealpath: base });
+  const w2 = registerAutoWorker({ projectRootRealpath: base });
+
+  const r1 = claimMilestoneLease(w1, "M001");
+  const r2 = claimMilestoneLease(w2, "M001");
+
+  assert.equal(r1.ok, true, "first claim wins");
+  assert.equal(r2.ok, false, "second claim is rejected");
+  if (!r2.ok) {
+    assert.equal(r2.error, "held_by");
+    assert.equal(r2.byWorker, w1);
+  }
+});
+
+test("two workers on different milestones can both proceed independently", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "First", status: "active" });
+  insertMilestone({ id: "M002", title: "Second", status: "active" });
+
+  const w1 = registerAutoWorker({ projectRootRealpath: base });
+  const w2 = registerAutoWorker({ projectRootRealpath: base });
+
+  const r1 = claimMilestoneLease(w1, "M001");
+  const r2 = claimMilestoneLease(w2, "M002");
+
+  assert.equal(r1.ok, true);
+  assert.equal(r2.ok, true);
+  if (r1.ok && r2.ok) {
+    assert.equal(r1.token, 1);
+    assert.equal(r2.token, 1);
+  }
+});
+
+test("dispatch ledger ties unit_id uniqueness to active status", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+
+  const w1 = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(w1, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  // The same lease holder attempts to claim the same unit twice.
+  // The partial unique index on unit_dispatches.unit_id WHERE status IN
+  // ('claimed','running') must serialize the writes even before the unit transitions.
+  const claim1 = recordDispatchClaim({
+    traceId: "t1", workerId: w1, milestoneLeaseToken: lease.token,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "M001/S01",
+  });
+  const claim2 = recordDispatchClaim({
+    traceId: "t2", workerId: w1, milestoneLeaseToken: lease.token,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "M001/S01",
+  });
+
+  assert.equal(claim1.ok, true);
+  assert.equal(claim2.ok, false);
+  if (!claim2.ok) {
+    assert.equal(claim2.error, "already_active");
+  }
+});