gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.2ff77b0ce

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/start-auto-detached.test.ts

@@ -41,6 +41,59 @@ test("command entrypoints use startAutoDetached instead of awaiting startAuto (#
   );
 });
 
+test("bare /gsd stays in the foreground smart-entry flow (#5125 regression)", () => {
+  const autoHandlerSrc = readGsdFile("commands/handlers/auto.ts");
+  const bareCommandBranch = autoHandlerSrc.slice(
+    autoHandlerSrc.indexOf('if (trimmed === "")'),
+  );
+
+  assert.ok(
+    bareCommandBranch.includes('await import("../../guided-flow.js")'),
+    "bare /gsd should load the guided smart-entry flow",
+  );
+  assert.ok(
+    bareCommandBranch.includes("await showSmartEntry(ctx, pi, projectRoot(), { step: true })"),
+    "bare /gsd should await the foreground wizard instead of detaching auto-mode",
+  );
+  assert.ok(
+    !bareCommandBranch.includes("startAutoDetached("),
+    "bare /gsd must not enter detached auto bootstrap directly",
+  );
+});
+
+test("auto bootstrap validates blocked directories before touching .gsd migration state", () => {
+  const autoSrc = readGsdFile("auto.ts");
+  const autoStartSrc = readGsdFile("auto-start.ts");
+
+  const startAutoIdx = autoSrc.indexOf("export async function startAuto(");
+  const startAutoBody = autoSrc.slice(startAutoIdx);
+  const startAutoValidationIdx = startAutoBody.indexOf("validateDirectory(base)");
+  const startAutoRecoveryIdx = startAutoBody.indexOf("recoverFailedMigration(base)");
+
+  assert.ok(startAutoIdx > -1, "startAuto should exist");
+  assert.ok(startAutoValidationIdx > -1, "startAuto should validate the base directory");
+  assert.ok(startAutoRecoveryIdx > -1, "startAuto should still recover failed migrations for safe projects");
+  assert.ok(
+    startAutoValidationIdx < startAutoRecoveryIdx,
+    "startAuto must reject blocked directories before recovering or migrating .gsd state",
+  );
+
+  const bootstrapIdx = autoStartSrc.indexOf("export async function bootstrapAutoSession(");
+  const bootstrapBody = autoStartSrc.slice(bootstrapIdx);
+  const bootstrapValidationIdx = bootstrapBody.indexOf("validateDirectory(base)");
+  const lockIdx = bootstrapBody.indexOf("acquireSessionLock(base)");
+  const bootstrapMigrationIdx = bootstrapBody.indexOf("migrateToExternalState(base)");
+
+  assert.ok(bootstrapIdx > -1, "bootstrapAutoSession should exist");
+  assert.ok(bootstrapValidationIdx > -1, "bootstrapAutoSession should validate the base directory");
+  assert.ok(lockIdx > -1, "bootstrapAutoSession should acquire a session lock for safe projects");
+  assert.ok(bootstrapMigrationIdx > -1, "bootstrapAutoSession should still migrate safe projects");
+  assert.ok(
+    bootstrapValidationIdx < lockIdx && bootstrapValidationIdx < bootstrapMigrationIdx,
+    "fresh bootstrap must reject blocked directories before locking or migrating .gsd state",
+  );
+});
+
 test("startAutoDetached reports failures asynchronously (#3733)", () => {
   const autoSrc = readGsdFile("auto.ts");
 

package/src/resources/extensions/gsd/tests/stash-pop-gsd-conflict.test.ts

@@ -21,6 +21,7 @@ import { _clearGsdRootCache } from "../paths.ts";
 // Isolate from user's global preferences (which may have git.main_branch set)
 let originalHome: string | undefined;
 let fakeHome: string;
+const testCwd = process.cwd();
 
 test.before(() => {
   originalHome = process.env.HOME;
@@ -37,6 +38,11 @@ test.after(() => {
   rmSync(fakeHome, { recursive: true, force: true });
 });
 
+function cleanupTempRepo(repo: string): void {
+  try { process.chdir(testCwd); } catch { /* best-effort */ }
+  try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
+}
+
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -106,7 +112,7 @@ test("#2766: stash pop conflict on .gsd/ files is auto-resolved", () => {
     try { stashList = run("git stash list", repo); } catch { /* empty stash */ }
     assert.strictEqual(stashList, "", "stash is empty after .gsd/ conflict auto-resolution");
   } finally {
-    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
+    cleanupTempRepo(repo);
   }
 });
 
@@ -141,6 +147,6 @@ test("#2766: stash pop conflict on non-.gsd files preserves stash for manual res
       "merge succeeds even with non-.gsd stash pop conflict",
     );
   } finally {
-    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
+    cleanupTempRepo(repo);
   }
 });

package/src/resources/extensions/gsd/tests/stash-queued-context-files.test.ts

@@ -35,6 +35,7 @@ import { _clearGsdRootCache } from "../paths.ts";
 // Isolate from user's global preferences (which may have git.main_branch set)
 let originalHome: string | undefined;
 let fakeHome: string;
+const testCwd = process.cwd();
 
 test.before(() => {
   originalHome = process.env.HOME;
@@ -51,6 +52,13 @@ test.after(() => {
   rmSync(fakeHome, { recursive: true, force: true });
 });
 
+function cleanupTempPaths(...paths: string[]): void {
+  try { process.chdir(testCwd); } catch { /* best-effort */ }
+  for (const p of paths) {
+    rmSync(p, { recursive: true, force: true });
+  }
+}
+
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, {
     cwd,
@@ -271,7 +279,7 @@ test("#2505: mergeMilestoneToMain preserves queued CONTEXT files (not swept into
       }
     }
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    cleanupTempPaths(repo);
   }
 });
 
@@ -308,8 +316,7 @@ test("#2505: pre-merge stash handles symlinked .gsd without traversing it", () =
     assert.equal(readFileSync(join(repo, "README.md"), "utf-8").replace(/\r\n/g, "\n"), "# test\n\nDirty change.\n");
     assert.equal(readFileSync(join(repo, "local-note.txt"), "utf-8"), "local scratch\n");
   } finally {
-    rmSync(repo, { recursive: true, force: true });
-    rmSync(stateDir, { recursive: true, force: true });
+    cleanupTempPaths(repo, stateDir);
   }
 });
 
@@ -375,7 +382,7 @@ test("#2505: back-to-back merges preserve queued CONTEXT files", () => {
       "M013 context content preserved after back-to-back merges",
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    cleanupTempPaths(repo);
   }
 });
 
@@ -430,7 +437,6 @@ test("#4573: gitignored .gsd symlink does not break pre-merge stash", () => {
       ".gsd symlink remains in place",
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
-    rmSync(stateDir, { recursive: true, force: true });
+    cleanupTempPaths(repo, stateDir);
   }
 });

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

package/src/resources/extensions/gsd/tests/sync-worktree-skip-current.test.ts

@@ -1,12 +1,9 @@
 /**
- * Regression test for #3641 — syncWorktreeStateBack skips current milestone
+ * Regression test for DB-authoritative syncWorktreeStateBack behavior.
  *
- * When syncing worktree state back to main, the current milestone being
- * merged should be skipped. Its files are already in the milestone branch
- * and copying them back would conflict with the squash merge.
- *
- * The fix adds a `mid === milestoneId` skip guard inside the milestone
- * iteration loop in syncWorktreeStateBack.
+ * Worktree milestone projections are not authoritative. syncWorktreeStateBack
+ * may reconcile a legacy worktree DB and copy diagnostics, but must not copy
+ * milestone markdown directories back into the project root.
  */
 
 import { describe, it } from 'node:test'
@@ -20,7 +17,7 @@ const src = readFileSync(
   'utf-8',
 )
 
-describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
+describe('syncWorktreeStateBack does not copy worktree milestone projections', () => {
   it('syncWorktreeStateBack function exists', () => {
     assert.ok(
       src.includes('function syncWorktreeStateBack('),
@@ -28,7 +25,7 @@ describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
     )
   })
 
-  it('mid === milestoneId skip guard exists in the milestone loop', () => {
+  it('does not iterate worktree milestones for copy-back', () => {
     // Find syncWorktreeStateBack
     const fnStart = src.indexOf('function syncWorktreeStateBack(')
     assert.ok(fnStart !== -1)
@@ -36,31 +33,11 @@ describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
     // Get a reasonable portion of the function
     const fnBlock = extractSourceRegion(src, 'function syncWorktreeStateBack(', { fromIdx: fnStart })
 
-    // Find the for loop iterating milestones
-    const loopIdx = fnBlock.indexOf('for (const mid of wtMilestones)')
-    assert.ok(loopIdx !== -1, 'milestone iteration loop must exist')
-
-    // After the loop, there should be the skip guard
-    const loopBody = extractSourceRegion(fnBlock, 'for (const mid of wtMilestones)', { fromIdx: loopIdx })
-    assert.ok(
-      loopBody.includes('mid === milestoneId'),
-      'mid === milestoneId skip guard must exist inside the milestone loop',
-    )
-    assert.ok(
-      loopBody.includes('continue'),
-      'skip guard must use continue to skip the current milestone',
-    )
+    assert.ok(!fnBlock.includes('for (const mid of wtMilestones)'), 'must not iterate worktree milestones')
+    assert.ok(!fnBlock.includes('syncMilestoneDir('), 'must not copy milestone markdown projections')
   })
 
-  it('syncMilestoneDir is still called for non-current milestones', () => {
-    const fnStart = src.indexOf('function syncWorktreeStateBack(')
-    assert.ok(fnStart !== -1)
-
-    const fnBlock = extractSourceRegion(src, 'function syncWorktreeStateBack(', { fromIdx: fnStart })
-
-    assert.ok(
-      fnBlock.includes('syncMilestoneDir('),
-      'syncMilestoneDir must still be called for other milestones',
-    )
+  it('legacy milestone copy helper has been removed', () => {
+    assert.ok(!src.includes('function syncMilestoneDir('), 'syncMilestoneDir helper should not exist')
   })
 })

package/src/resources/extensions/gsd/tests/token-counter.test.ts

@@ -20,6 +20,10 @@ describe("token-counter: getCharsPerToken", () => {
     assert.equal(getCharsPerToken("anthropic"), 3.5);
   });
 
+  it("returns 3.5 for claude-code", () => {
+    assert.equal(getCharsPerToken("claude-code"), 3.5);
+  });
+
   it("returns 4.0 for openai", () => {
     assert.equal(getCharsPerToken("openai"), 4.0);
   });
@@ -51,6 +55,11 @@ describe("token-counter: estimateTokensForProvider", () => {
     assert.equal(tokens, Math.ceil(1000 / 3.5));
   });
 
+  it("estimates tokens for claude-code using 3.5 chars/token ratio", () => {
+    const tokens = estimateTokensForProvider(sampleText, "claude-code");
+    assert.equal(tokens, Math.ceil(1000 / 3.5));
+  });
+
   it("estimates tokens for openai using 4.0 chars/token ratio", () => {
     const tokens = estimateTokensForProvider(sampleText, "openai");
     assert.equal(tokens, Math.ceil(1000 / 4.0));