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

package/src/resources/extensions/gsd/tests/crash-recovery.test.ts

@@ -18,39 +18,96 @@ import {
   hasResumableDerivedState,
   isBootstrapCrashLock,
   readPausedSessionMetadata,
+  PAUSED_SESSION_KV_KEY,
 } from "../interrupted-session.ts";
-import { gsdRoot } from "../paths.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 { insertSlice, insertTask } from "../gsd-db.ts";
+import { setRuntimeKv } from "../db/runtime-kv.ts";
+import { normalizeRealPath } from "../paths.ts";
 import type { GSDState } from "../types.ts";
 import { _synthesizePausedSessionRecoveryForTest } from "../auto.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
   mkdirSync(join(base, ".gsd"), { recursive: true });
+  // Phase C pt 2: lock and paused-session live in the DB now. Open it
+  // for every test base so the helpers below can write through.
+  openDatabase(join(base, ".gsd", "gsd.db"));
   return base;
 }
 
 function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* */ }
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
+/**
+ * Phase C pt 2 fixture: insert a stale worker row + dispatch + session_file
+ * directly via SQL so it appears as a crashed PEER process, not as the
+ * current test process. assessInterruptedSession filters out
+ * `rawLock.pid === process.pid` to avoid classifying its own process as
+ * a previous crash; using PID 999999999 (functionally guaranteed dead)
+ * bypasses that guard exactly the way the old file-based writeTestLock
+ * did with the same PID.
+ */
 function writeTestLock(
   base: string,
   unitType: string,
   unitId: string,
   sessionFile?: string,
 ): void {
-  writeFileSync(
-    join(gsdRoot(base), "auto.lock"),
-    JSON.stringify({
-      pid: 999999999,
-      startedAt: new Date().toISOString(),
-      unitType,
-      unitId,
-      unitStartedAt: new Date().toISOString(),
-      sessionFile,
-    }, null, 2),
-    "utf-8",
-  );
+  const projectRoot = normalizeRealPath(base);
+  const workerId = `test-fake-${randomUUID().slice(0, 8)}`;
+  const fakePid = 999999999;
+  const stalePast = "1970-01-01T00:00:00.000Z";
+  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', :pid, :started_at, 'test',
+      :stale, 'active', :project_root
+    )`,
+  ).run({
+    ":w": workerId,
+    ":pid": fakePid,
+    ":started_at": new Date().toISOString(),
+    ":stale": stalePast,
+    ":project_root": projectRoot,
+  });
+
+  // Ensure milestones referenced by the unitId exist so the dispatch
+  // FK is satisfied. Parse "M###/S##" or "M###" or "starting" / etc.
+  const midMatch = unitId.match(/^(M\d+)/);
+  if (midMatch && unitType !== "starting") {
+    const mid = midMatch[1];
+    try { insertMilestone({ id: mid, title: `Test ${mid}`, status: "active" }); }
+    catch { /* may already exist */ }
+    try {
+      const lease = claimMilestoneLease(workerId, mid);
+      recordDispatchClaim({
+        traceId: randomUUID(),
+        workerId,
+        milestoneLeaseToken: lease.ok ? lease.token : 0,
+        milestoneId: mid,
+        unitType,
+        unitId,
+      });
+    } catch { /* ignore — best-effort */ }
+  }
+
+  if (sessionFile) {
+    setRuntimeKv("worker", workerId, "session_file", sessionFile);
+  }
 }
 
 function writeRoadmap(base: string, checked = false): void {
@@ -82,6 +139,25 @@ function writeRoadmap(base: string, checked = false): void {
     ].join("\n"),
     "utf-8",
   );
+  // Phase C pt 2: makeTmpBase() opens the DB so writeTestLock can write
+  // the workers row. deriveState then goes DB-first; mirror the markdown
+  // fixture into the DB so the assessment sees the same milestone state.
+  // Use direct upsert SQL so calling writeRoadmap twice (e.g. once for
+  // base + once for a paused worktree) actually flips the status.
+  const status = checked ? "complete" : "active";
+  const adapter = _getAdapter();
+  if (adapter) {
+    adapter.prepare(
+      `INSERT INTO milestones (id, title, status, created_at)
+       VALUES (:id, :title, :status, :now)
+       ON CONFLICT(id) DO UPDATE SET status = excluded.status, title = excluded.title`,
+    ).run({ ":id": "M001", ":title": "Test Milestone", ":status": status, ":now": new Date().toISOString() });
+    adapter.prepare(
+      `INSERT INTO slices (milestone_id, id, title, status, created_at)
+       VALUES (:mid, :sid, :title, :status, :now)
+       ON CONFLICT(milestone_id, id) DO UPDATE SET status = excluded.status, title = excluded.title`,
+    ).run({ ":mid": "M001", ":sid": "S01", ":title": "Test slice", ":status": status, ":now": new Date().toISOString() });
+  }
 }
 
 function writeCompleteSliceArtifacts(base: string): void {
@@ -105,13 +181,16 @@ function writePausedSession(
   unitType?: string,
   unitId?: string,
 ): void {
-  const runtimeDir = join(base, ".gsd", "runtime");
-  mkdirSync(runtimeDir, { recursive: true });
-  writeFileSync(
-    join(runtimeDir, "paused-session.json"),
-    JSON.stringify({ milestoneId, originalBasePath: base, stepMode, worktreePath, unitType, unitId }, null, 2),
-    "utf-8",
-  );
+  // Phase C pt 2: paused-session.json migrated to runtime_kv
+  // (global scope, key PAUSED_SESSION_KV_KEY).
+  setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, {
+    milestoneId,
+    originalBasePath: base,
+    stepMode,
+    worktreePath,
+    unitType,
+    unitId,
+  });
 }
 
 function writeActivityLog(base: string, entries: Record<string, unknown>[]): void {
@@ -231,14 +310,12 @@ test("readPausedSessionMetadata preserves unitType and unitId through round-trip
 test("readPausedSessionMetadata handles legacy metadata without unitType/unitId", () => {
   const base = makeTmpBase();
   try {
-    // Write metadata without unitType/unitId (simulates older version)
-    const runtimeDir = join(base, ".gsd", "runtime");
-    mkdirSync(runtimeDir, { recursive: true });
-    writeFileSync(
-      join(runtimeDir, "paused-session.json"),
-      JSON.stringify({ milestoneId: "M001", originalBasePath: base }),
-      "utf-8",
-    );
+    // Phase C pt 2: write directly to runtime_kv (simulates older payload
+    // missing the now-canonical unitType/unitId fields).
+    setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, {
+      milestoneId: "M001",
+      originalBasePath: base,
+    });
     const meta = readPausedSessionMetadata(base);
     assert.equal(meta?.milestoneId, "M001");
     assert.equal(meta?.unitType, undefined);
@@ -251,23 +328,23 @@ test("readPausedSessionMetadata handles legacy metadata without unitType/unitId"
 test("readPausedSessionMetadata drops stale discuss-milestone pseudo PROJECT metadata", () => {
   const base = makeTmpBase();
   try {
-    const runtimeDir = join(base, ".gsd", "runtime");
-    const pausedPath = join(runtimeDir, "paused-session.json");
-    mkdirSync(runtimeDir, { recursive: true });
-    writeFileSync(
-      pausedPath,
-      JSON.stringify({
-        milestoneId: null,
-        originalBasePath: base,
-        unitType: "discuss-milestone",
-        unitId: "PROJECT",
-      }, null, 2),
-      "utf-8",
-    );
+    // Phase C pt 2: write directly to runtime_kv (the file location is gone)
+    setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, {
+      milestoneId: null,
+      originalBasePath: base,
+      unitType: "discuss-milestone",
+      unitId: "PROJECT",
+    });
 
     const meta = readPausedSessionMetadata(base);
     assert.equal(meta, null);
-    assert.equal(existsSync(pausedPath), false);
+    // Confirm the row was deleted by readPausedSessionMetadata's
+    // isStalePseudoMilestonePause branch.
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT 1 FROM runtime_kv WHERE scope = 'global' AND scope_id = '' AND key = :k`,
+    ).get({ ":k": PAUSED_SESSION_KV_KEY });
+    assert.equal(row, undefined);
   } finally {
     cleanup(base);
   }
@@ -276,23 +353,20 @@ test("readPausedSessionMetadata drops stale discuss-milestone pseudo PROJECT met
 test("readPausedSessionMetadata drops stale deep setup pseudo-unit metadata", () => {
   const base = makeTmpBase();
   try {
-    const runtimeDir = join(base, ".gsd", "runtime");
-    const pausedPath = join(runtimeDir, "paused-session.json");
-    mkdirSync(runtimeDir, { recursive: true });
-    writeFileSync(
-      pausedPath,
-      JSON.stringify({
-        milestoneId: "WORKFLOW-PREFS",
-        originalBasePath: base,
-        unitType: "workflow-preferences",
-        unitId: "WORKFLOW-PREFS",
-      }, null, 2),
-      "utf-8",
-    );
+    setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, {
+      milestoneId: "WORKFLOW-PREFS",
+      originalBasePath: base,
+      unitType: "workflow-preferences",
+      unitId: "WORKFLOW-PREFS",
+    });
 
     const meta = readPausedSessionMetadata(base);
     assert.equal(meta, null);
-    assert.equal(existsSync(pausedPath), false);
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT 1 FROM runtime_kv WHERE scope = 'global' AND scope_id = '' AND key = :k`,
+    ).get({ ":k": PAUSED_SESSION_KV_KEY });
+    assert.equal(row, undefined);
   } finally {
     cleanup(base);
   }
@@ -504,10 +578,29 @@ test("assessInterruptedSession treats bootstrap crash as stale without paused me
 // ─── writeLock / readCrashLock ────────────────────────────────────────────
 
 test("writeLock creates lock file and readCrashLock reads it", (t) => {
+  // Phase C pt 2: lock state is reconstructed from workers + unit_dispatches
+  // + runtime_kv. The fresh worker is not stale yet — we register, dispatch,
+  // write the session_file, then expire the heartbeat to simulate a crash.
   const base = makeTmpBase();
   t.after(() => cleanup(base));
 
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+  recordDispatchClaim({
+    traceId: "t1", workerId, milestoneLeaseToken: lease.token,
+    milestoneId: "M001", unitType: "execute-task", unitId: "M001/S01/T01",
+  });
   writeLock(base, "execute-task", "M001/S01/T01", "/tmp/session.jsonl");
+
+  // Force stale so readCrashLock surfaces it.
+  _getAdapter()!.prepare(
+    `UPDATE workers SET last_heartbeat_at = '1970-01-01T00:00:00.000Z' WHERE worker_id = :w`,
+  ).run({ ":w": workerId });
+
   const lock = readCrashLock(base);
   assert.ok(lock, "lock should exist");
   assert.equal(lock!.unitType, "execute-task");
@@ -527,13 +620,30 @@ test("readCrashLock returns null when no lock exists", (t) => {
 // ─── clearLock ────────────────────────────────────────────────────────────
 
 test("clearLock removes existing lock file", (t) => {
+  // Phase C pt 2: clearLock now drops the session_file runtime_kv row
+  // for the LIVE worker (not the stale one). The "lock state" itself
+  // (pid, unitType, etc.) lives in workers + unit_dispatches; those are
+  // managed by markWorkerStopping (called from stopAuto, not here).
   const base = makeTmpBase();
   t.after(() => cleanup(base));
 
-  writeLock(base, "plan-slice", "M001/S01");
-  assert.ok(readCrashLock(base), "lock should exist before clear");
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+
+  writeLock(base, "plan-slice", "M001/S01", "/tmp/session.jsonl");
+  // Confirm the session_file row landed for the live worker.
+  const adapter = _getAdapter()!;
+  const before = adapter.prepare(
+    `SELECT 1 FROM runtime_kv WHERE scope = 'worker' AND scope_id = :w AND key = 'session_file'`,
+  ).get({ ":w": workerId });
+  assert.ok(before, "session_file row exists before clear");
+
   clearLock(base);
-  assert.equal(readCrashLock(base), null, "lock should be gone after clear");
+
+  const after = adapter.prepare(
+    `SELECT 1 FROM runtime_kv WHERE scope = 'worker' AND scope_id = :w AND key = 'session_file'`,
+  ).get({ ":w": workerId });
+  assert.equal(after, undefined, "session_file row gone after clearLock");
 });
 
 test("clearLock is safe when no lock exists", (t) => {

package/src/resources/extensions/gsd/tests/detect-stuck-respects-retry.test.ts

@@ -0,0 +1,173 @@
+// gsd-2 + Stuck-detector retry coupling regression (Phase B / codex MEDIUM B3)
+//
+// Rule 2b previously tripped on 3 same-unit appearances regardless of
+// retry budget. With unit_dispatches.attempt_n + next_run_at driving in-DB
+// backoff, a unit that fails 3× under retry would trip the stuck-detector
+// before its retry budget exhausted. This test verifies suppression while
+// the retry window is open and re-engagement once the window passes or
+// budget exhausts.
+
+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 } from "../db/milestone-leases.ts";
+import {
+  recordDispatchClaim,
+  markFailed,
+  getLatestForUnit,
+} from "../db/unit-dispatches.ts";
+import { detectStuck } from "../auto/detect-stuck.ts";
+import type { WindowEntry } from "../auto/types.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-detect-stuck-retry-"));
+  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 */ }
+}
+
+function windowOf(...keys: string[]): WindowEntry[] {
+  return keys.map((key) => ({ key }));
+}
+
+test("rule 2b trips with no DB context (legacy behavior preserved)", () => {
+  // No DB open — getLatestForUnit returns null, suppression cannot fire,
+  // pre-Phase-B behavior is intact.
+  const result = detectStuck(
+    windowOf(
+      "plan-slice:M001/S01",
+      "other-unit",
+      "plan-slice:M001/S01",
+      "third-unit",
+      "plan-slice:M001/S01",
+    ),
+  );
+  assert.ok(result, "stuck signal returned");
+  assert.equal(result!.stuck, true);
+});
+
+test("rule 2b SUPPRESSED while retry budget remains and next_run_at is in the future", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const w = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(w, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  // Record a failed dispatch with attempt_n=1, max_attempts=3, retry_after
+  // pushing next_run_at into the future.
+  const claim = recordDispatchClaim({
+    traceId: "t1", workerId: w, milestoneLeaseToken: lease.token,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "plan-slice:M001/S01",
+    attemptN: 1, maxAttempts: 3,
+  });
+  assert.equal(claim.ok, true);
+  if (!claim.ok) return;
+  markFailed(claim.dispatchId, { errorSummary: "transient", retryAfterMs: 60_000 });
+
+  const latest = getLatestForUnit("plan-slice:M001/S01")!;
+  assert.equal(latest.attempt_n, 1);
+  assert.ok(latest.next_run_at);
+
+  const result = detectStuck(
+    windowOf(
+      "plan-slice:M001/S01",
+      "other-unit",
+      "plan-slice:M001/S01",
+      "third-unit",
+      "plan-slice:M001/S01",
+    ),
+  );
+  assert.equal(result, null, "rule 2b suppressed while retry window is active");
+});
+
+test("rule 2b RE-ENGAGES once attempt_n reaches max_attempts", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const w = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(w, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  // Burn through attempts up to the cap — last attempt = max_attempts.
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    const claim = recordDispatchClaim({
+      traceId: `t${attempt}`, workerId: w, milestoneLeaseToken: lease.token,
+      milestoneId: "M001", unitType: "plan-slice", unitId: "plan-slice:M001/S01",
+      attemptN: attempt, maxAttempts: 3,
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "transient", retryAfterMs: 60_000 });
+  }
+
+  const latest = getLatestForUnit("plan-slice:M001/S01")!;
+  assert.equal(latest.attempt_n, 3);
+  assert.equal(latest.max_attempts, 3);
+
+  const result = detectStuck(
+    windowOf(
+      "plan-slice:M001/S01",
+      "other-unit",
+      "plan-slice:M001/S01",
+      "third-unit",
+      "plan-slice:M001/S01",
+    ),
+  );
+  assert.ok(result, "stuck signal returned once retry budget is exhausted");
+});
+
+test("rule 2b RE-ENGAGES once next_run_at is in the past", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const w = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(w, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  const claim = recordDispatchClaim({
+    traceId: "t", workerId: w, milestoneLeaseToken: lease.token,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "plan-slice:M001/S01",
+    attemptN: 1, maxAttempts: 3,
+  });
+  assert.equal(claim.ok, true);
+  if (!claim.ok) return;
+  markFailed(claim.dispatchId, { errorSummary: "transient", retryAfterMs: 60_000 });
+
+  // Force next_run_at into the past — retry window has already lapsed.
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE unit_dispatches SET next_run_at = '1970-01-01T00:00:00.000Z' WHERE id = :id`,
+  ).run({ ":id": claim.dispatchId });
+
+  const result = detectStuck(
+    windowOf(
+      "plan-slice:M001/S01",
+      "other-unit",
+      "plan-slice:M001/S01",
+      "third-unit",
+      "plan-slice:M001/S01",
+    ),
+  );
+  assert.ok(result, "stuck re-engages once retry window has passed");
+});

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 () => {