gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/tests/note-captures-executed.test.ts

@@ -6,41 +6,45 @@
  * adds a filter for classification === "note" and calls markCaptureExecuted
  * for each matching capture.
  *
- * Structural verification test — reads source to confirm the note filter
- * and markCaptureExecuted call exist.
+ * Behavior test — resolved note captures should be marked executed without
+ * dispatching inject/replan work.
  */
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const source = readFileSync(join(__dirname, '..', 'triage-resolution.ts'), 'utf-8');
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { loadAllCaptures } from '../captures.ts';
+import { executeTriageResolutions } from '../triage-resolution.ts';
 
 describe('note captures executed in triage resolution (#3578)', () => {
-  test('markCaptureExecuted is imported', () => {
-    assert.match(source, /markCaptureExecuted/,
-      'markCaptureExecuted should be imported');
-  });
+  test('resolved note captures are stamped executed', () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-note-capture-'));
+    try {
+      mkdirSync(join(base, '.gsd'), { recursive: true });
+      writeFileSync(join(base, '.gsd', 'CAPTURES.md'), [
+        '# Captures',
+        '',
+        '### cap-note',
+        '**Text:** Remember this',
+        '**Captured:** 2026-01-01T00:00:00.000Z',
+        '**Status:** resolved',
+        '**Classification:** note',
+        '**Resolution:** informational only',
+        '**Resolved:** 2026-01-01T00:01:00.000Z',
+        '',
+      ].join('\n'));
 
-  test('note classification filter exists', () => {
-    assert.match(source, /classification\s*===\s*"note"/,
-      'filter should check classification === "note"');
-  });
-
-  test('note filter checks resolved status and not-executed', () => {
-    assert.match(source, /status\s*===\s*"resolved"\s*&&\s*!c\.executed\s*&&\s*c\.classification\s*===\s*"note"/,
-      'filter should check resolved + not-executed + note classification');
-  });
+      const result = executeTriageResolutions(base, 'M001', 'S01');
+      const [capture] = loadAllCaptures(base);
 
-  test('markCaptureExecuted is called for note captures', () => {
-    // The source should call markCaptureExecuted for note captures
-    const noteSection = source.slice(source.indexOf('classification === "note"'));
-    assert.match(noteSection, /markCaptureExecuted\(basePath,\s*cap\.id\)/,
-      'markCaptureExecuted should be called for note captures');
+      assert.equal(result.injected, 0);
+      assert.equal(result.replanned, 0);
+      assert.ok(result.actions.some((action) => action.includes('Note acknowledged: cap-note')));
+      assert.equal(capture?.executed, true);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/phantom-ghost-detection.test.ts

@@ -8,48 +8,35 @@
  * The fix makes isGhostMilestone treat a "queued" DB row with no disk
  * artifacts (CONTEXT, ROADMAP, SUMMARY) as a ghost.
  *
- * This structural test verifies the dbRow.status === 'queued' guard exists.
+ * This behavior test exercises isGhostMilestone against real DB rows and
+ * milestone artifacts.
  */
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const source = readFileSync(join(__dirname, '..', 'state.ts'), 'utf-8');
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { closeDatabase, insertMilestone, openDatabase } from '../gsd-db.ts';
+import { clearPathCache } from '../paths.ts';
+import { isGhostMilestone } from '../state.ts';
 
 describe('isGhostMilestone phantom queued detection (#3671)', () => {
-  test('isGhostMilestone function exists', () => {
-    assert.match(source, /export function isGhostMilestone\(/,
-      'isGhostMilestone should be exported');
-  });
-
-  test('checks dbRow.status === queued', () => {
-    assert.match(source, /dbRow\.status\s*===\s*['"]queued['"]/,
-      'isGhostMilestone should check dbRow.status === "queued"');
-  });
-
-  test('checks for CONTEXT disk artifact', () => {
-    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']CONTEXT["']\)/,
-      'should check for CONTEXT file');
-  });
-
-  test('checks for ROADMAP disk artifact', () => {
-    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']ROADMAP["']\)/,
-      'should check for ROADMAP file');
-  });
-
-  test('checks for SUMMARY disk artifact', () => {
-    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']SUMMARY["']\)/,
-      'should check for SUMMARY file');
-  });
-
-  test('returns !hasContent for queued rows (ghost if no artifacts)', () => {
-    assert.match(source, /return !hasContent/,
-      'should return !hasContent for queued phantom milestones');
+  test('queued DB row with no artifacts is a ghost, but content makes it real', () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-phantom-ghost-'));
+    try {
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Reserved only', status: 'queued' });
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+
+      assert.equal(isGhostMilestone(base, 'M001'), true);
+
+      writeFileSync(join(base, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md'), '# Context\n');
+      clearPathCache();
+      assert.equal(isGhostMilestone(base, 'M001'), false);
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/phantom-milestone-default-queued.test.ts

@@ -8,32 +8,17 @@
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const dbSrc = readFileSync(
-  join(__dirname, '..', 'gsd-db.ts'),
-  'utf-8',
-);
+import { closeDatabase, getMilestone, insertMilestone, openDatabase } from '../gsd-db.ts';
 
 describe('insertMilestone defaults status to queued (#3695)', () => {
-  test('insertMilestone function exists', () => {
-    assert.match(dbSrc, /export function insertMilestone\(/,
-      'insertMilestone should be exported from gsd-db.ts');
-  });
-
-  test('default status is "queued" not "active"', () => {
-    // The status parameter should default to "queued" via nullish coalescing
-    assert.match(dbSrc, /m\.status\s*\?\?\s*"queued"/,
-      'insertMilestone should default status to "queued"');
-  });
+  test('omitted status persists as queued, not active', () => {
+    try {
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Reserved milestone' });
 
-  test('comment explains the rationale', () => {
-    assert.match(dbSrc, /never auto-create milestones as "active"/i,
-      'should have a comment explaining why default is queued');
+      assert.equal(getMilestone('M001')?.status, 'queued');
+    } finally {
+      closeDatabase();
+    }
   });
 });

package/src/resources/extensions/gsd/tests/phases-merge-error-stops-auto.test.ts

@@ -0,0 +1,113 @@
+/**
+ * phases-merge-error-stops-auto.test.ts — Regression test for #2766.
+ *
+ * When mergeAndExit throws a non-MergeConflictError, the auto loop must
+ * stop instead of continuing with unmerged work. This test verifies that
+ * all catch blocks in auto/phases.ts that handle mergeAndExit errors
+ * call stopAuto and return { action: "break" } for non-conflict errors.
+ */
+
+import { createTestContext } from "./test-helpers.ts";
+import { runPreDispatch } from "../auto/phases.ts";
+
+const { assertTrue, report } = createTestContext();
+
+console.log("\n=== #2766: Non-MergeConflictError stops auto mode ===");
+
+const notifications: Array<{ message: string; level?: string }> = [];
+const calls: string[] = [];
+const basePath = "/tmp/gsd-test";
+const ic = {
+  ctx: {
+    ui: {
+      notify(message: string, level?: string) {
+        notifications.push({ message, level });
+      },
+    },
+  },
+  pi: {},
+  s: {
+    basePath,
+    originalBasePath: basePath,
+    canonicalProjectRoot: basePath,
+    resourceVersionOnStart: "test",
+    currentMilestoneId: "M001",
+    currentUnit: null,
+    milestoneMergedInPhases: false,
+  },
+  prefs: undefined,
+  iteration: 1,
+  flowId: "test-flow",
+  nextSeq: () => 1,
+  deps: {
+    checkResourcesStale() {
+      return null;
+    },
+    invalidateAllCaches() {
+      calls.push("invalidate");
+    },
+    async preDispatchHealthGate() {
+      calls.push("health");
+      return { proceed: true, fixesApplied: [] };
+    },
+    async deriveState(projectRoot: string) {
+      calls.push(`derive:${projectRoot}`);
+      return {
+        phase: "complete",
+        activeMilestone: { id: "M001", title: "Milestone one" },
+        activeSlice: null,
+        activeTask: null,
+        registry: [{ id: "M001", status: "complete" }],
+        nextAction: "complete",
+      };
+    },
+    syncCmuxSidebar() {
+      calls.push("sync-sidebar");
+    },
+    setActiveMilestoneId(_basePath: string, mid: string) {
+      calls.push(`set-active:${mid}`);
+    },
+    reconcileMergeState() {
+      calls.push("reconcile");
+      return "clean";
+    },
+    preflightCleanRoot() {
+      calls.push("preflight");
+      return { ok: true, stashPushed: true, stashMarker: "marker" };
+    },
+    postflightPopStash() {
+      calls.push("postflight");
+      return { ok: true, needsManualRecovery: false };
+    },
+    resolver: {
+      mergeAndExit() {
+        calls.push("merge");
+        throw new Error("remote rejected push");
+      },
+    },
+    async stopAuto(_ctx: unknown, _pi: unknown, reason?: string) {
+      calls.push(`stop:${reason}`);
+    },
+  },
+} as any;
+
+const result = await runPreDispatch(ic, {
+  recentUnits: [],
+  stuckRecoveryAttempts: 0,
+  consecutiveFinalizeTimeouts: 0,
+});
+
+assertTrue(result.action === "break", "non-conflict merge error returns break");
+if (result.action === "break") {
+  assertTrue(result.reason === "merge-failed", "non-conflict merge error uses merge-failed reason");
+}
+assertTrue(
+  calls.join(" > ") === "invalidate > health > derive:/tmp/gsd-test > sync-sidebar > set-active:M001 > reconcile > preflight > merge > postflight > stop:Merge error on milestone M001: Error: remote rejected push",
+  `pre-dispatch stops immediately after non-conflict merge failure (${calls.join(" > ")})`,
+);
+assertTrue(
+  notifications.some((n) => n.level === "error" && n.message.includes("Merge failed: remote rejected push")),
+  "user is notified with an error that merge failed",
+);
+
+report();

package/src/resources/extensions/gsd/tests/post-unit-state-rebuild.test.ts

@@ -5,31 +5,45 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { AutoSession } from "../auto/session.ts";
+import { postUnitPreVerification } from "../auto-post-unit.ts";
 
-const source = readFileSync(join(import.meta.dirname, "..", "auto-post-unit.ts"), "utf-8");
+test("postUnitPreVerification rebuilds STATE.md after a completed unit", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-state-"));
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "# Roadmap\n\n## Slices\n\n- [ ] **S01: Discussed slice** `risk:low` `depends:[]`\n",
+    );
+    writeFileSync(join(sliceDir, "S01-CONTEXT.md"), "# Slice Context\n\nReady.\n");
 
-test("auto-post-unit imports rebuildState", () => {
-  assert.ok(
-    source.includes('import { rebuildState } from "./doctor.js";'),
-    "auto-post-unit.ts should import rebuildState from doctor.ts",
-  );
-});
-
-test("postUnitPreVerification rebuilds STATE.md before worktree sync", () => {
-  const fnStart = source.indexOf("export async function postUnitPreVerification");
-  assert.ok(fnStart > 0, "postUnitPreVerification should exist");
+    const s = new AutoSession();
+    s.basePath = base;
+    s.originalBasePath = base;
+    s.currentMilestoneId = "M001";
+    s.currentUnit = { type: "discuss-slice", id: "M001/S01", startedAt: Date.now() };
 
-  const fnEnd = source.indexOf("export async function postUnitPostVerification", fnStart);
-  const section = source.slice(fnStart, fnEnd > fnStart ? fnEnd : undefined);
-  const rebuildIdx = section.indexOf('await runSafely("postUnit", "state-rebuild"');
-  const syncIdx = section.indexOf('await runSafely("postUnit", "worktree-sync"');
+    const result = await postUnitPreVerification({
+      s,
+      ctx: { ui: { notify() {} } } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => {},
+      updateProgressWidget: () => {},
+    }, { skipSettleDelay: true, skipWorktreeSync: true });
 
-  assert.ok(rebuildIdx > 0, "postUnitPreVerification should rebuild STATE.md after unit completion");
-  assert.ok(syncIdx > 0, "postUnitPreVerification should sync worktree state back to the project root");
-  assert.ok(
-    rebuildIdx < syncIdx,
-    "STATE.md rebuild should happen before worktree sync so synced state is fresh",
-  );
+    assert.equal(result, "continue");
+    const statePath = join(base, ".gsd", "STATE.md");
+    assert.equal(existsSync(statePath), true);
+    assert.ok(readFileSync(statePath, "utf-8").includes("M001"));
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/pre-exec-backtick-strip.test.ts

@@ -12,14 +12,9 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import { normalizeFilePath, checkFilePathConsistency } from '../pre-execution-checks.ts'
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-const src = readFileSync(
-  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'pre-execution-checks.ts'),
-  'utf-8',
-)
-
 describe('normalizeFilePath backtick stripping (#3649)', () => {
   it('strips backticks from file paths', () => {
     assert.equal(normalizeFilePath('`src/foo.ts`'), 'src/foo.ts')
@@ -58,31 +53,42 @@ describe('normalizeFilePath backtick stripping (#3649)', () => {
 })
 
 describe('checkFilePathConsistency checks task.inputs not task.files (#3626)', () => {
-  it('source uses only task.inputs in filesToCheck', () => {
-    // Verify the fix structurally: the spread should be [...task.inputs] only
-    const fnStart = src.indexOf('export function checkFilePathConsistency(')
-    assert.ok(fnStart !== -1, 'checkFilePathConsistency function must exist')
-
-    // Find the filesToCheck assignment
-    const filesToCheckLine = src.indexOf('filesToCheck', fnStart)
-    assert.ok(filesToCheckLine !== -1, 'filesToCheck assignment must exist')
-
-    // Extract the line
-    const lineEnd = src.indexOf('\n', filesToCheckLine)
-    const line = src.slice(filesToCheckLine, lineEnd)
-
-    // Must include task.inputs
-    assert.ok(
-      line.includes('task.inputs'),
-      'filesToCheck must reference task.inputs',
-    )
+  it('ignores missing task.files entries that are only likely outputs', () => {
+    const task = {
+      milestone_id: 'M001',
+      slice_id: 'S01',
+      id: 'T01',
+      title: 'Create missing file',
+      status: 'pending',
+      one_liner: '',
+      narrative: '',
+      verification_result: '',
+      duration: '',
+      completed_at: null,
+      blocker_discovered: false,
+      deviations: '',
+      known_issues: '',
+      key_files: [],
+      key_decisions: [],
+      full_summary_md: '',
+      description: '',
+      estimate: '',
+      files: ['src/new-file.ts'],
+      verify: '',
+      inputs: [],
+      expected_output: ['src/new-file.ts'],
+      observability_impact: '',
+      full_plan_md: '',
+      sequence: 0,
+    }
 
-    // Must NOT include task.files
-    assert.ok(
-      !line.includes('task.files'),
-      'filesToCheck must NOT reference task.files — files likely touched include ' +
-        'files the task will create, so they do not need to pre-exist',
-    )
+    const tmp = resolve(process.cwd(), '.tmp-pre-exec-files-ignore')
+    try {
+      mkdirSync(tmp, { recursive: true })
+      assert.deepEqual(checkFilePathConsistency([task as any], tmp), [])
+    } finally {
+      rmSync(tmp, { recursive: true, force: true })
+    }
   })
 })
 

package/src/resources/extensions/gsd/tests/pre-execution-pause-wiring.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Integration tests for pre-execution check pause wiring.
 /**
  * pre-execution-pause-wiring.test.ts — Integration tests for pre-execution check → pauseAuto wiring.
  *
@@ -27,6 +29,11 @@ let tempDir: string;
 let dbPath: string;
 let originalCwd: string;
 
+function resetAllCaches(): void {
+  invalidateAllCaches();
+  _clearGsdRootCache();
+}
+
 /**
  * Create a minimal mock ExtensionContext.
  */
@@ -112,8 +119,8 @@ function setupTestEnvironment(): void {
   // Change cwd so loadEffectiveGSDPreferences finds our PREFERENCES.md
   process.chdir(tempDir);
   
-  // Clear gsdRoot cache so it finds the new .gsd directory
-  _clearGsdRootCache();
+  // Clear caches so it finds the new .gsd directory and preferences.
+  resetAllCaches();
   
   // Initialize DB
   dbPath = join(gsdDir, "gsd.db");
@@ -136,6 +143,7 @@ function cleanupTestEnvironment(): void {
   } catch {
     // Ignore close errors
   }
+  resetAllCaches();
   try {
     rmSync(tempDir, { recursive: true, force: true });
   } catch {
@@ -158,8 +166,7 @@ ${yamlLines.join("\n")}
 `;
   writeFileSync(join(tempDir, ".gsd", "PREFERENCES.md"), prefsContent);
   // Invalidate caches so the new preferences file is found
-  invalidateAllCaches();
-  _clearGsdRootCache();
+  resetAllCaches();
 }
 
 /**
@@ -486,6 +493,69 @@ describe("Pre-execution checks → pauseAuto wiring", () => {
     );
   });
 
+  test("files present in s.basePath (worktree) but absent from canonicalProjectRoot do not block", async () => {
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_pre: true,
+      enhanced_verification_strict: false,
+    });
+
+    // Regression: pre-exec checks used canonicalProjectRoot (project root), so
+    // files that a prior slice created in the worktree were falsely flagged as
+    // missing because they hadn't merged to main yet. Fix: use s.basePath.
+
+    // Create a separate "worktree" directory with the referenced files present.
+    const worktreeDir = join(tempDir, "worktree");
+    mkdirSync(join(worktreeDir, "lib"), { recursive: true });
+    mkdirSync(join(worktreeDir, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+    writeFileSync(join(worktreeDir, "lib", "types.ts"), "export type Habit = { id: string; name: string; };");
+    writeFileSync(join(worktreeDir, "lib", "useLocalStorage.ts"), "export function useLocalStorage() {}");
+
+    // The DB lives under tempDir (the "project root"). Insert slice + tasks.
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Test Slice", risk: "low" });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task that reads prior-slice files",
+      status: "pending",
+      planning: {
+        description: "Reads lib/types.ts and lib/useLocalStorage.ts from prior slice",
+        estimate: "1h",
+        files: [],
+        verify: "npm test",
+        inputs: ["lib/types.ts", "lib/useLocalStorage.ts"],
+        expectedOutput: ["lib/utils.ts"],
+        observabilityImpact: "",
+      },
+      sequence: 0,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+
+    // s.basePath = worktreeDir (files exist here)
+    // Override canonicalProjectRoot → tempDir (files do NOT exist there)
+    const s = makeMockSession(worktreeDir, { type: "plan-slice", id: "M001/S01" });
+    Object.defineProperty(s, "canonicalProjectRoot", { get: () => tempDir });
+
+    const pctx = makePostUnitContext(s, ctx, pi, pauseAutoMock);
+    const result = await postUnitPostVerification(pctx);
+
+    assert.equal(
+      pauseAutoMock.mock.callCount(),
+      0,
+      "pauseAuto should NOT be called when referenced files exist in s.basePath (worktree)",
+    );
+    assert.equal(
+      result,
+      "continue",
+      "postUnitPostVerification should return 'continue' when worktree files satisfy pre-exec inputs",
+    );
+  });
+
   test("uok gate runner persists pre-execution gate outcomes when enabled", async () => {
     writePreferences({
       enhanced_verification: true,

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

@@ -12,32 +12,30 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { syncWorktreeStateBack } from "../auto-worktree.ts";
 
-test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)", () => {
-  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const src = readFileSync(srcPath, "utf-8");
+test("#2684: syncWorktreeStateBack does not overwrite project PREFERENCES.md", () => {
+  const mainBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-main-"));
+  const wtBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-worktree-"));
+  const mainGsd = join(mainBase, ".gsd");
+  const wtGsd = join(wtBase, ".gsd");
+  mkdirSync(mainGsd, { recursive: true });
+  mkdirSync(wtGsd, { recursive: true });
 
-  const constIdx = src.indexOf("ROOT_STATE_FILES");
-  assert.ok(constIdx !== -1, "ROOT_STATE_FILES constant exists");
+  try {
+    const authoritative = "---\nversion: 1\n---\n\nmode: team\n";
+    writeFileSync(join(mainGsd, "PREFERENCES.md"), authoritative);
+    writeFileSync(join(wtGsd, "PREFERENCES.md"), "---\nversion: 1\n---\n\nmode: solo\n");
 
-  const arrayStart = src.indexOf("[", constIdx);
-  const arrayEnd = src.indexOf("] as const", arrayStart);
-  const block = src.slice(arrayStart, arrayEnd);
+    const result = syncWorktreeStateBack(mainBase, wtBase, "M001");
 
-  // Project preferences must NOT be in ROOT_STATE_FILES — they are handled separately
-  // in syncGsdStateToWorktree() (forward-only, additive). Including it in
-  // ROOT_STATE_FILES would cause syncWorktreeStateBack() to overwrite the
-  // authoritative project root copy (#2684).
-  const entries = block.split("\n")
-    .map(l => l.trim())
-    .filter(l => l.startsWith('"') && l.includes(".md"));
-  const hasPrefs = entries.some(
-    l => l.includes("PREFERENCES.md") || l.includes("preferences.md"),
-  );
-  assert.ok(
-    !hasPrefs,
-    "preferences files must NOT be in ROOT_STATE_FILES (back-sync would overwrite root)",
-  );
+    assert.equal(readFileSync(join(mainGsd, "PREFERENCES.md"), "utf-8"), authoritative);
+    assert.ok(!result.synced.includes("PREFERENCES.md"));
+    assert.ok(!result.synced.includes("preferences.md"));
+  } finally {
+    rmSync(mainBase, { recursive: true, force: true });
+    rmSync(wtBase, { recursive: true, force: true });
+  }
 });
 
 // Phase C: copyPlanningArtifacts was deleted. Worktrees no longer