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

package/src/resources/extensions/gsd/tests/resume-missing-worktree-warning.test.ts

@@ -0,0 +1,209 @@
+// GSD-2 + Regression tests for missing-worktree warning on resume (M4 fix)
+//
+// When paused-session.json records a worktreePath that no longer exists on disk,
+// the resume path must emit a logWarning("session", ...) describing the situation
+// rather than silently falling back to project-root mode.
+//
+// Strategy: drive the exported _warnIfWorktreeMissingForTest seam directly
+// (mirrors the exact conditional used at the two resume sites in auto.ts),
+// and independently verify the scope fallback via createWorkspace/scopeMilestone
+// as in auto-session-scope.test.ts.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  logWarning,
+  peekLogs,
+  _resetLogs,
+  setStderrLoggingEnabled,
+} from "../workflow-logger.ts";
+import { _warnIfWorktreeMissingForTest } from "../auto.ts";
+import { AutoSession } from "../auto/session.ts";
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-resume-warn-test-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+// Mirror the rebuildScope() fallback from auto.ts when worktree is missing.
+function applyProjectRootScope(
+  s: AutoSession,
+  projectDir: string,
+  milestoneId: string,
+): void {
+  const workspace = createWorkspace(projectDir);
+  s.scope = scopeMilestone(workspace, milestoneId);
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("resume: missing worktree warning emission", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    _resetLogs();
+    setStderrLoggingEnabled(false);
+  });
+
+  afterEach(() => {
+    setStderrLoggingEnabled(true);
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("logWarning is called when worktreePath is set but directory is missing", () => {
+    const missingPath = join(projectDir, ".gsd", "worktrees", "M001-nonexistent");
+    // missingPath was never created — existsSync returns false
+
+    const warned = _warnIfWorktreeMissingForTest(missingPath, "M001");
+
+    assert.equal(warned, true, "_warnIfWorktreeMissingForTest should return true when path is missing");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1, "exactly one warning should be emitted");
+    assert.equal(logs[0].severity, "warn");
+    assert.equal(logs[0].component, "session");
+    assert.ok(
+      logs[0].message.includes(missingPath),
+      `warning message should include the missing path; got: ${logs[0].message}`,
+    );
+    assert.ok(
+      logs[0].message.includes("missing"),
+      "warning message should mention 'missing'",
+    );
+  });
+
+  test("logWarning message includes milestone ID", () => {
+    const missingPath = join(projectDir, ".gsd", "worktrees", "M042-gone");
+    _warnIfWorktreeMissingForTest(missingPath, "M042");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1);
+    assert.equal(logs[0].context?.milestoneId, "M042");
+  });
+
+  test("logWarning is NOT called when worktreePath is null", () => {
+    const warned = _warnIfWorktreeMissingForTest(null, "M001");
+
+    assert.equal(warned, false);
+    assert.equal(peekLogs().length, 0, "no warning when worktreePath is null");
+  });
+
+  test("logWarning is NOT called when worktreePath is undefined", () => {
+    const warned = _warnIfWorktreeMissingForTest(undefined, "M001");
+
+    assert.equal(warned, false);
+    assert.equal(peekLogs().length, 0, "no warning when worktreePath is undefined");
+  });
+
+  test("logWarning is NOT called when worktreePath exists on disk", () => {
+    const existingWorktree = join(projectDir, ".gsd", "worktrees", "M001");
+    mkdirSync(existingWorktree, { recursive: true });
+
+    const warned = _warnIfWorktreeMissingForTest(existingWorktree, "M001");
+
+    assert.equal(warned, false, "no warning when path exists");
+    assert.equal(peekLogs().length, 0);
+  });
+
+  test("warning message mentions project-root fallback action", () => {
+    const missingPath = join(projectDir, ".gsd", "worktrees", "M099-deleted");
+    _warnIfWorktreeMissingForTest(missingPath, "M099");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1);
+    assert.ok(
+      logs[0].message.includes("project-root mode"),
+      "warning should mention project-root mode fallback",
+    );
+    assert.ok(
+      logs[0].message.includes("gsd-debug"),
+      "warning should suggest /gsd-debug recovery action",
+    );
+  });
+});
+
+describe("resume: scope fallback to project-root mode when worktree is missing", () => {
+  let s: AutoSession;
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    s = new AutoSession();
+    _resetLogs();
+    setStderrLoggingEnabled(false);
+  });
+
+  afterEach(() => {
+    setStderrLoggingEnabled(true);
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope.workspace.mode is 'project' after fallback from missing worktree", () => {
+    const mid = "M001";
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    // Simulate auto.ts resume path: worktreePath is set but missing → use projectDir
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    // Fallback: use originalBasePath (project root)
+    applyProjectRootScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set after fallback");
+    assert.equal(s.scope.workspace.mode, "project");
+  });
+
+  test("scope.milestoneId is preserved after project-root fallback", () => {
+    const mid = "M002";
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    applyProjectRootScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.milestoneId, mid);
+  });
+
+  test("does not throw when worktree path is missing and scope fallback is applied", () => {
+    const mid = "M003";
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+
+    assert.doesNotThrow(() => {
+      _warnIfWorktreeMissingForTest(missingPath, mid);
+      applyProjectRootScope(s, projectDir, mid);
+    }, "resume with missing worktree must not throw");
+  });
+
+  test("warning is emitted once per missing worktree — no double-emission", () => {
+    const mid = "M004";
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    // Simulating the second call as would happen if the resume-re-entry site
+    // also fires (e.g. pausedSession and freshStartAssessment both carry the path)
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    const logs = peekLogs();
+    // Two calls → two warnings (one per site — consistent with the two sites in auto.ts)
+    assert.equal(logs.length, 2, "each call to the seam emits one warning");
+    assert.equal(logs[0].component, "session");
+    assert.equal(logs[1].component, "session");
+  });
+});

package/src/resources/extensions/gsd/tests/rogue-file-detection.test.ts

@@ -149,7 +149,7 @@ test("rogue detection: DB not available → returns empty array (graceful degrad
   }
 });
 
-test("rogue detection: slice summary on disk, no DB row → auto-remediated (not rogue)", () => {
+test("rogue detection: slice summary on disk, no DB completion → detected as rogue without DB import", () => {
   const basePath = createTmpBase();
   const dbPath = join(basePath, ".gsd", "gsd.db");
   mkdirSync(join(basePath, ".gsd"), { recursive: true });
@@ -160,10 +160,9 @@ test("rogue detection: slice summary on disk, no DB row → auto-remediated (not
     const summaryPath = createSliceSummaryOnDisk(basePath, "M001", "S01");
     assert.ok(existsSync(summaryPath), "Slice summary file should exist on disk");
 
-    // Fix #3633: stale slice DB status is auto-remediated via updateSliceStatus()
-    // instead of being reported as rogue, so rogues array should be empty.
     const rogues = detectRogueFileWrites("complete-slice", "M001/S01", basePath);
-    assert.equal(rogues.length, 0, "Should auto-remediate stale slice, not report as rogue");
+    assert.equal(rogues.length, 1, "Should report stale disk summary instead of mutating DB");
+    assert.equal(rogues[0]?.path, summaryPath);
   } finally {
     closeDatabase();
     rmSync(basePath, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/slice-disk-reconcile.test.ts

@@ -1,10 +1,8 @@
 /**
  * slice-disk-reconcile.test.ts — #2533
  *
- * Slices that exist on disk (in ROADMAP.md) but are missing from the SQLite
- * database cause permanent "No slice eligible — check dependency ordering"
- * blocks. deriveStateFromDb must reconcile disk slices into the DB, just as
- * it already does for milestones (#2416).
+ * DB-authoritative state: slices that exist only in ROADMAP.md are projections
+ * and must not be imported into the SQLite database by deriveStateFromDb().
  *
  * Scenario: M001 has a ROADMAP with S01-S04. S01 and S02 have SUMMARY files
  * (complete on disk). S03 depends on S01. Only S04 is in the DB (depends on
@@ -70,7 +68,7 @@ const ROADMAP_CONTENT = `# M001: Test Milestone
 `;
 
 async function testMissingSlicesCauseBlock(): Promise<void> {
-  console.log("\n--- Test: missing DB slices cause permanent block (pre-fix) ---");
+  console.log("\n--- Test: missing DB slices are not imported from ROADMAP.md ---");
 
   const base = createFixtureBase();
   const dbPath = join(base, ".gsd", "gsd.db");
@@ -96,51 +94,11 @@ async function testMissingSlicesCauseBlock(): Promise<void> {
     invalidateStateCache();
     const state = await deriveStateFromDb(base);
 
-    // After the fix, slices S01-S03 should be reconciled into DB
     const dbSlices = getMilestoneSlices("M001");
-    assertTrue(
-      dbSlices.length === 4,
-      `All 4 roadmap slices should be in DB after reconciliation, got ${dbSlices.length}`,
-    );
-
-    // S01 and S02 should be marked complete (have SUMMARY files)
-    const s01 = dbSlices.find(s => s.id === "S01");
-    assertTrue(s01 !== undefined, "S01 should exist in DB after reconciliation");
-    if (s01) {
-      assertEq(s01.status, "complete", "S01 should be 'complete' (has SUMMARY on disk)");
-    }
-
-    const s02 = dbSlices.find(s => s.id === "S02");
-    assertTrue(s02 !== undefined, "S02 should exist in DB after reconciliation");
-    if (s02) {
-      assertEq(s02.status, "complete", "S02 should be 'complete' (has SUMMARY on disk)");
-    }
-
-    // S03 should be pending (no SUMMARY)
-    const s03 = dbSlices.find(s => s.id === "S03");
-    assertTrue(s03 !== undefined, "S03 should exist in DB after reconciliation");
-    if (s03) {
-      assertEq(s03.status, "pending", "S03 should be 'pending' (no SUMMARY on disk)");
-    }
-
-    // The state should NOT be blocked — S03 should be eligible (S01 dep satisfied)
-    assertTrue(
-      state.phase !== "blocked",
-      `Phase should not be 'blocked' after reconciliation, got '${state.phase}'`,
-    );
-
-    // Active slice should be S03 (S01 dep met, S03 is first incomplete with satisfied deps)
-    assertTrue(
-      state.activeSlice !== null,
-      "There should be an active slice after reconciliation",
-    );
-    if (state.activeSlice) {
-      assertEq(
-        state.activeSlice.id,
-        "S03",
-        "Active slice should be S03 (its dependency S01 is complete) (#2533)",
-      );
-    }
+    assertEq(dbSlices.length, 1, `Only DB slice S04 should remain, got ${dbSlices.length}`);
+    assertEq(dbSlices[0]?.id, "S04", "Disk-only slices are not inserted");
+    assertEq(state.phase, "blocked", "DB-only S04 remains blocked on missing DB dependency S03");
+    assertEq(state.activeSlice, null, "No active slice is inferred from roadmap-only rows");
   } finally {
     closeDatabase();
     cleanup(base);
@@ -148,7 +106,7 @@ async function testMissingSlicesCauseBlock(): Promise<void> {
 }
 
 async function testSliceReconciliationIdempotent(): Promise<void> {
-  console.log("\n--- Test: slice reconciliation is idempotent ---");
+  console.log("\n--- Test: disk-only slices remain absent on repeated derives ---");
 
   const base = createFixtureBase();
   const dbPath = join(base, ".gsd", "gsd.db");
@@ -178,11 +136,7 @@ async function testSliceReconciliationIdempotent(): Promise<void> {
       assertEq(s01.status, "complete", "S01 status should remain 'complete' (not overwritten)");
     }
 
-    // S02-S04 should have been added
-    assertTrue(
-      dbSlices.length === 4,
-      `Should have 4 slices after reconciliation (existing + new), got ${dbSlices.length}`,
-    );
+    assertEq(dbSlices.length, 1, `Only existing DB slice should remain, got ${dbSlices.length}`);
   } finally {
     closeDatabase();
     cleanup(base);
@@ -218,7 +172,7 @@ async function testNoRoadmapSkipsReconciliation(): Promise<void> {
 }
 
 async function main(): Promise<void> {
-  console.log("\n=== #2533: deriveStateFromDb reconciles disk slices ===");
+  console.log("\n=== deriveStateFromDb does not reconcile disk slices ===");
 
   await testMissingSlicesCauseBlock();
   await testSliceReconciliationIdempotent();

package/src/resources/extensions/gsd/tests/stale-slice-rows.test.ts

@@ -1,10 +1,9 @@
 /**
- * stale-slice-rows.test.ts — #3658
+ * stale-slice-rows.test.ts
  *
- * Verify that state.ts contains slice-level status reconciliation that
- * updates stale DB rows (status "pending") when disk artifacts (SUMMARY)
- * prove the slice is complete. Without this, the dependency resolver builds
- * doneSliceIds from stale DB rows and downstream slices stay blocked.
+ * Verify that state.ts no longer treats slice SUMMARY.md projections as
+ * authority for DB slice status. Slice rows must be updated through DB-backed
+ * completion/import APIs.
  */
 
 import { describe, test } from "node:test";
@@ -16,26 +15,26 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const sourceFile = join(__dirname, "..", "state.ts");
 
-describe("stale slice row reconciliation (#3658)", () => {
+describe("stale slice row DB-authoritative boundary", () => {
   const source = readFileSync(sourceFile, "utf-8");
 
-  test("imports updateSliceStatus from gsd-db", () => {
-    assert.match(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from/);
+  test("does not import updateSliceStatus into state derivation", () => {
+    assert.doesNotMatch(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from/);
   });
 
-  test("checks isStatusDone before reconciling slice rows", () => {
-    assert.match(source, /isStatusDone\(dbSlice\.status\)/);
+  test("does not scan DB slice rows for disk SUMMARY reconciliation", () => {
+    assert.doesNotMatch(source, /dbSlice/);
   });
 
-  test("resolves SUMMARY file to detect completed slices on disk", () => {
-    assert.match(source, /resolveSliceFile\(basePath,\s*mid,\s*dbSlice\.id,\s*["']SUMMARY["']\)/);
+  test("does not resolve slice SUMMARY to mutate DB state", () => {
+    assert.doesNotMatch(source, /resolveSliceFile\(basePath,\s*mid,\s*dbSlice\.id,\s*["']SUMMARY["']\)/);
   });
 
-  test("calls updateSliceStatus to reconcile stale rows", () => {
-    assert.match(source, /updateSliceStatus\(mid,\s*dbSlice\.id,\s*["']complete["']\)/);
+  test("does not call updateSliceStatus from state derivation", () => {
+    assert.doesNotMatch(source, /updateSliceStatus\(/);
   });
 
-  test("references issue #3599 in reconciliation comment", () => {
-    assert.match(source, /#3599/);
+  test("documents markdown projections as non-authoritative", () => {
+    assert.match(source, /Markdown files are projections only/);
   });
 });

package/src/resources/extensions/gsd/tests/state-corruption-2945.test.ts

@@ -69,6 +69,7 @@ function makeMilestoneRow(overrides: Partial<MilestoneRow> = {}): MilestoneRow {
     definition_of_done: [],
     requirement_coverage: "",
     boundary_map_markdown: "",
+    sequence: 0,
     ...overrides,
   };
 }

package/src/resources/extensions/gsd/tests/state-machine-full-walkthrough.test.ts

@@ -858,11 +858,11 @@ describe("state-machine-full-walkthrough", () => {
   });
 
   // ═══════════════════════════════════════════════════════════════════════════
-  // RECONCILIATION
+  // DB-AUTHORITATIVE DERIVATION
   // ═══════════════════════════════════════════════════════════════════════════
 
-  describe("Reconciliation", () => {
-    test("DB: task with SUMMARY on disk but DB says pending → reconciliation fixes status (#2514)", async () => {
+  describe("DB-authoritative derivation", () => {
+    test("DB: task with SUMMARY on disk but DB says pending → DB remains authoritative", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -875,19 +875,19 @@ describe("state-machine-full-walkthrough", () => {
       writeRoadmap(base, "M001", standardRoadmap());
       writePlan(base, "M001", "S01", standardPlan());
 
-      // Write SUMMARY files on disk for both tasks (simulating session disconnect)
+      // Write SUMMARY files on disk for both tasks. These are projections and
+      // must not complete pending DB tasks during runtime derivation.
       writeTaskSummary(base, "M001", "S01", "T01");
       writeTaskSummary(base, "M001", "S01", "T02");
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // Reconciliation should detect SUMMARY→DB mismatch and update
-      // All tasks done → summarizing (not executing)
-      assert.equal(state.phase, "summarizing", "reconciliation should advance past pending tasks");
+      assert.equal(state.phase, "executing", "disk SUMMARY projections must not complete DB tasks");
+      assert.equal(state.activeTask?.id, "T01", "first pending DB task remains active");
     });
 
-    test("empty DB with disk milestones → disk-to-DB sync (#2631)", async () => {
+    test("empty DB with disk milestones → no runtime disk-to-DB sync", async () => {
       const base = createFixtureBase();
       writeContext(base, "M001", "# M001: Test\n\nContext.");
 
@@ -899,11 +899,10 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveState(base);
 
-      // After deriveState, DB should have the disk milestone
+      // Runtime derivation must not import disk milestones into the DB.
       const after = getAllMilestones();
-      assert.ok(after.length > 0, "DB should have milestones after reconciliation");
-      assert.equal(after[0]!.id, "M001");
-      assert.ok(state.activeMilestone !== null);
+      assert.equal(after.length, 0, "DB should remain empty without explicit migration");
+      assert.equal(state.activeMilestone, null, "disk milestone is ignored while DB is authoritative");
     });
 
     test("ghost milestone (empty dir) → NOT in registry", async () => {
@@ -1063,7 +1062,7 @@ describe("state-machine-full-walkthrough", () => {
   // ═══════════════════════════════════════════════════════════════════════════
 
   describe("Recovery: DB has slice but no task rows (partial migration)", () => {
-    test("DB tasks empty but PLAN on disk has tasks → reconciles to executing", async () => {
+    test("DB tasks empty but PLAN on disk has tasks → stays planning", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -1078,15 +1077,13 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // FIX (#3600): plan-file tasks are now reconciled into the DB,
-      // so the phase correctly advances to executing instead of planning.
-      assert.equal(state.phase, "executing",
-        "reconciled plan-file tasks → executing (not stuck in planning)");
+      assert.equal(state.phase, "planning",
+        "PLAN.md projection must not import DB tasks during runtime derivation");
     });
   });
 
   describe("Failure: partial SUMMARY reconciliation", () => {
-    test("only one task has SUMMARY, other still pending → executing next task", async () => {
+    test("only one task has SUMMARY, other still pending → executing first DB-pending task", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -1104,9 +1101,8 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // T01 reconciled to complete, T02 still pending → executing T02
       assert.equal(state.phase, "executing");
-      assert.equal(state.activeTask?.id, "T02", "should advance to next pending task");
+      assert.equal(state.activeTask?.id, "T01", "disk SUMMARY must not advance past pending DB task");
     });
   });
 
@@ -1255,7 +1251,7 @@ describe("state-machine-full-walkthrough", () => {
   });
 
   describe("Failure: missing task plan files in DB path", () => {
-    test("DB has tasks but no T##-PLAN.md files → planning phase", async () => {
+    test("DB has tasks but no T##-PLAN.md files → executing phase", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -1273,8 +1269,8 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      assert.equal(state.phase, "planning",
-        "missing T##-PLAN.md files should keep state in planning");
+      assert.equal(state.phase, "executing",
+        "DB tasks are authoritative even when task plan projections are missing");
     });
   });
 
@@ -1591,7 +1587,7 @@ describe("state-machine-full-walkthrough", () => {
   });
 
   describe("Failure: multiple reconciliation in single derivation", () => {
-    test("DB has 3 stale tasks, all with SUMMARY on disk → all reconciled in one pass", async () => {
+    test("DB has 3 stale tasks, all with SUMMARY on disk → first DB-pending task remains active", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -1641,9 +1637,9 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // All 3 should be reconciled in one pass → summarizing
-      assert.equal(state.phase, "summarizing",
-        "all 3 stale tasks should be reconciled to complete in one derivation");
+      assert.equal(state.phase, "executing",
+        "disk SUMMARY projections must not reconcile DB task state");
+      assert.equal(state.activeTask?.id, "T01", "first non-closed DB task remains active");
     });
   });
 });

package/src/resources/extensions/gsd/tests/steer-worktree-path.test.ts

@@ -1,6 +1,6 @@
 // GSD Extension - Steer Worktree Path Resolution Test
-// Regression test for #3476: /gsd steer must write overrides to the worktree .gsd/,
-// not the project root .gsd/, when a worktree is active.
+// Worktrees share the canonical project .gsd state root. /gsd steer writes
+// overrides to that canonical root even when invoked with a worktree path.
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
@@ -27,32 +27,31 @@ describe("steer worktree path resolution (#3476)", () => {
     rmSync(projectRoot, { recursive: true, force: true });
   });
 
-  test("appendOverride writes to worktree .gsd/ when worktree path is used", async () => {
+  test("appendOverride writes to canonical project .gsd/ when worktree path is used", async () => {
     await appendOverride(worktreePath, "Use Postgres instead of SQLite", "M001/S01/T01");
 
-    // Override should be in the worktree .gsd/
+    // Override should be in the canonical project .gsd/
     const wtOverrides = join(worktreePath, ".gsd", "OVERRIDES.md");
-    assert.ok(existsSync(wtOverrides), "override file exists in worktree .gsd/");
+    const rootOverrides = join(projectRoot, ".gsd", "OVERRIDES.md");
+    assert.ok(!existsSync(wtOverrides), "no override file in worktree-local .gsd/");
+    assert.ok(existsSync(rootOverrides), "override file exists in project root .gsd/");
 
-    const content = readFileSync(wtOverrides, "utf-8");
+    const content = readFileSync(rootOverrides, "utf-8");
     assert.ok(content.includes("Use Postgres instead of SQLite"), "override content is correct");
-
-    // Override should NOT be in the project root .gsd/
-    const rootOverrides = join(projectRoot, ".gsd", "OVERRIDES.md");
-    assert.ok(!existsSync(rootOverrides), "no override file in project root .gsd/");
   });
 
-  test("loadActiveOverrides reads from worktree .gsd/ when worktree path is used", async () => {
+  test("loadActiveOverrides reads canonical project .gsd/ when worktree path is used", async () => {
     await appendOverride(worktreePath, "Switch to JWT auth", "M001/S02/T01");
 
-    // Loading from worktree should find the override
+    // Loading from worktree resolves to the canonical project state root.
     const wtOverrides = await loadActiveOverrides(worktreePath);
     assert.equal(wtOverrides.length, 1, "one active override in worktree");
     assert.equal(wtOverrides[0].change, "Switch to JWT auth");
 
-    // Loading from project root should find nothing
+    // Loading from project root sees the same canonical override.
     const rootOverrides = await loadActiveOverrides(projectRoot);
-    assert.equal(rootOverrides.length, 0, "no overrides in project root");
+    assert.equal(rootOverrides.length, 1, "same override visible from project root");
+    assert.equal(rootOverrides[0].change, "Switch to JWT auth");
   });
 
   test("appendOverride falls back to project root when no worktree exists", async () => {

package/src/resources/extensions/gsd/tests/stop-auto-remote.test.ts

@@ -135,7 +135,7 @@ test("stopAutoRemote sends SIGTERM to a live process and returns found:true", {
 
 // ─── Lock path: original project root vs worktree ────────────────────────
 
-test("lock file should be discoverable at project root, not worktree path", () => {
+test("lock file should be discoverable from project root and worktree path", () => {
   const projectRoot = makeTmpBase();
   const worktreePath = join(projectRoot, ".gsd", "worktrees", "M001");
   mkdirSync(join(worktreePath, ".gsd"), { recursive: true });
@@ -149,9 +149,10 @@ test("lock file should be discoverable at project root, not worktree path", () =
     assert.ok(lock, "lock should be found at project root");
     assert.equal(lock!.unitType, "execute-task");
 
-    // Worktree path should NOT have a lock
+    // Worktree path resolves to the same canonical project .gsd lock.
     const worktreeLock = readCrashLock(worktreePath);
-    assert.equal(worktreeLock, null, "lock should NOT exist at worktree path");
+    assert.ok(worktreeLock, "lock should be discoverable via worktree path");
+    assert.equal(worktreeLock!.unitType, "execute-task");
   } finally {
     cleanup(projectRoot);
   }