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

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/validate-milestone-write-order.test.ts

@@ -85,7 +85,7 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     assert.doesNotMatch(validationMd, /## Verification Class Compliance/);
   });
 
-  it("rolls back DB row when disk write fails", async () => {
+  it("keeps DB row and reports stale projection when disk write fails", async () => {
     base = makeTmpBase();
     const dbPath = join(base, ".gsd", "gsd.db");
     openDatabase(dbPath);
@@ -101,16 +101,15 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
 
     const result = await handleValidateMilestone(VALID_PARAMS, base);
 
-    // Should return error
-    assert.ok("error" in result, "should return error when disk write fails");
-    assert.ok(result.error.includes("disk render failed"));
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+    assert.equal(result.stale, true, "result should report stale projection");
 
-    // DB row should have been rolled back (deleted)
     const adapter = _getAdapter()!;
     const row = adapter.prepare(
-      `SELECT * FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
-    ).get();
-    assert.equal(row, undefined, "assessment row should be deleted after disk-write rollback");
+      `SELECT status FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get() as { status: string } | undefined;
+    assert.ok(row, "assessment row should remain committed");
+    assert.equal(row!.status, "pass");
   });
 
   it("persists milestone validation gate_runs rows when UOK gates are enabled", async () => {

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

@@ -394,7 +394,7 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
   }
 });
 
-test("dispatch rule fails closed for failure-path SUMMARY when DB milestone is not complete (#4658)", async () => {
+test("dispatch rule ignores failure-path SUMMARY projection when DB milestone is not complete (#4658 superseded)", async () => {
   const state: GSDState = {
     activeMilestone: { id: "M001", title: "Test" },
     activeSlice: null,
@@ -422,17 +422,14 @@ test("dispatch rule fails closed for failure-path SUMMARY when DB milestone is n
       prefs: undefined,
     };
     const result = await resolveDispatch(ctx);
-    assert.equal(result.action, "stop");
-    if (result.action === "stop") {
-      assert.equal(result.level, "warning");
-      assert.match(result.reason, /failure-path SUMMARY/i);
-    }
+    assert.equal(result.action, "dispatch");
+    assert.equal(getMilestone("M001")?.status, "active");
   } finally {
     cleanup(base);
   }
 });
 
-test("dispatch rule reconciles DB for successful stale SUMMARY (#4658)", async () => {
+test("dispatch rule does not reconcile DB from successful stale SUMMARY projection (#4658 superseded)", async () => {
   const state: GSDState = {
     activeMilestone: { id: "M001", title: "Test" },
     activeSlice: null,
@@ -473,15 +470,15 @@ test("dispatch rule reconciles DB for successful stale SUMMARY (#4658)", async (
       prefs: undefined,
     };
     const result = await resolveDispatch(ctx);
-    assert.equal(result.action, "skip");
+    assert.equal(result.action, "dispatch");
     const milestone = getMilestone("M001");
-    assert.equal(milestone?.status, "complete");
+    assert.equal(milestone?.status, "active");
   } finally {
     cleanup(base);
   }
 });
 
-test("dispatch rule fails closed for ambiguous stale SUMMARY (#4658)", async () => {
+test("dispatch rule ignores ambiguous stale SUMMARY projection (#4658 superseded)", async () => {
   const state: GSDState = {
     activeMilestone: { id: "M001", title: "Test" },
     activeSlice: null,
@@ -509,11 +506,8 @@ test("dispatch rule fails closed for ambiguous stale SUMMARY (#4658)", async ()
       prefs: undefined,
     };
     const result = await resolveDispatch(ctx);
-    assert.equal(result.action, "stop");
-    if (result.action === "stop") {
-      assert.equal(result.level, "warning");
-      assert.match(result.reason, /ambiguous SUMMARY/i);
-    }
+    assert.equal(result.action, "dispatch");
+    assert.equal(getMilestone("M001")?.status, "active");
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/workflow-logger-wiring.test.ts

@@ -205,17 +205,22 @@ test("readTransaction logs ROLLBACK failures as split-brain signal", () => {
   );
 });
 
-// ─── Runtime: state.ts and workflow-projections.ts log silent bailouts ─────
+// ─── Runtime: startup/projection diagnostics stay explicit ─────────────────
 
-test("state.ts logs roadmap read failures instead of silently continuing", () => {
-  const stateSrc = readFileSync(
-    join(import.meta.dirname, "..", "state.ts"),
+test("auto-start initializes the DB without implicit markdown migration", () => {
+  const autoStartSrc = readFileSync(
+    join(import.meta.dirname, "..", "auto-start.ts"),
     "utf-8",
   );
+  assert.doesNotMatch(
+    autoStartSrc,
+    /migrateFromMarkdown|md-importer/,
+    "auto-start must not import markdown into the runtime DB implicitly",
+  );
   assert.match(
-    stateSrc,
-    /logWarning\("state",\s*"reconcileDiskToDb: roadmap read failed/,
-    "state.ts reconcileDiskToDb should log roadmap read failures",
+    autoStartSrc,
+    /failed to initialize project database/,
+    "DB initialization failures should still be logged",
   );
 });
 

package/src/resources/extensions/gsd/tests/workflow-mcp-auto-prep.test.ts

@@ -15,7 +15,7 @@ test("shouldAutoPrepareWorkflowMcp enables prep for externalCli local transport"
   assert.equal(result, true);
 });
 
-test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is ready", () => {
+test("shouldAutoPrepareWorkflowMcp stays disabled for non-Claude active provider even when claude-code is ready", () => {
   const result = shouldAutoPrepareWorkflowMcp({
     model: { provider: "openai", baseUrl: "https://api.openai.com" },
     modelRegistry: {
@@ -24,10 +24,10 @@ test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is rea
     },
   });
 
-  assert.equal(result, true);
+  assert.equal(result, false);
 });
 
-test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is registered", () => {
+test("shouldAutoPrepareWorkflowMcp stays disabled for non-Claude active provider even when claude-code is registered", () => {
   const result = shouldAutoPrepareWorkflowMcp({
     model: { provider: "openai", baseUrl: "https://api.openai.com" },
     modelRegistry: {
@@ -36,7 +36,7 @@ test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is reg
     },
   });
 
-  assert.equal(result, true);
+  assert.equal(result, false);
 });
 
 test("shouldAutoPrepareWorkflowMcp stays disabled when neither transport nor provider readiness match", () => {

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -30,6 +30,17 @@ function readSrc(file: string): string {
   return readFileSync(join(gsdDir, file), "utf-8");
 }
 
+function listTsFiles(dir: string): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const stat = statSync(full);
+    if (stat.isDirectory()) out.push(...listTsFiles(full));
+    else if (entry.endsWith(".ts")) out.push(full);
+  }
+  return out;
+}
+
 function extractElicitPayload(request: unknown): ElicitPayload {
   const payload = (request as { params?: unknown }).params ?? request;
   return payload as ElicitPayload;
@@ -772,3 +783,15 @@ test("workflow transport error guidance includes /gsd mcp init hint", () => {
   const src = readSrc("workflow-mcp.ts");
   assert.match(src, /Please run \/gsd mcp init \./);
 });
+
+test("buildWorkflowMcpServers is only imported by tests or Claude Code MCP boundary code", () => {
+  const offenders: string[] = [];
+  for (const file of listTsFiles(gsdDir)) {
+    const rel = file.slice(gsdDir.length + 1).replace(/\\/g, "/");
+    if (rel === "workflow-mcp.ts" || rel.startsWith("tests/")) continue;
+    const src = readFileSync(file, "utf-8");
+    if (/\bimport\b[\s\S]*\bbuildWorkflowMcpServers\b/.test(src)) offenders.push(rel);
+  }
+
+  assert.deepEqual(offenders, []);
+});

package/src/resources/extensions/gsd/tests/worktree-db-same-file.test.ts

@@ -15,6 +15,7 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
+  readFileSync,
   rmSync,
   symlinkSync,
   writeFileSync,
@@ -157,6 +158,18 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
   });
 });
 
+test("merge-time DB reconciliation only runs when legacy worktree DB exists", () => {
+  const src = readFileSync(join(import.meta.dirname, "..", "auto-worktree.ts"), "utf-8");
+  const reconcileIdx = src.indexOf("reconcileWorktreeDb(mainDbPath, worktreeDbPath)");
+  assert.ok(reconcileIdx !== -1, "merge-time reconcile call exists");
+  const guardWindow = src.slice(Math.max(0, reconcileIdx - 240), reconcileIdx);
+
+  assert.ok(
+    guardWindow.includes("existsSync(worktreeDbPath)") && guardWindow.includes("!isSamePath(worktreeDbPath, mainDbPath)"),
+    "merge-time reconcile requires a real legacy worktree DB and distinct DB paths",
+  );
+});
+
 // ─── Fix 3: infrastructure error classification ─────────────────────
 
 describe("#2823: malformed DB classified as infrastructure error", () => {

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

@@ -5,8 +5,8 @@
  * from the main repo's .gsd/ into the worktree's .gsd/ for the
  * specified milestone, and deletes gsd.db so it rebuilds from fresh state.
  *
- * Also verifies that syncWorktreeStateBack recurses into tasks/ subdirectories
- * so task-level summaries are not dropped on milestone teardown (#1678).
+ * Also verifies that syncWorktreeStateBack does not import worktree markdown
+ * projections back into the project root.
  *
  * Covers:
  *   - Milestone directory synced from main to worktree
@@ -15,12 +15,12 @@
  *   - No-op when paths are equal
  *   - No-op when milestoneId is null
  *   - Non-existent directories handled gracefully
- *   - syncWorktreeStateBack recurses into tasks/ subdirectory (#1678)
- *   - syncWorktreeStateBack syncs root-level .gsd/ files (REQUIREMENTS, PROJECT, etc.)
- *   - syncWorktreeStateBack syncs ALL milestone directories, not just the current one
- *   - syncWorktreeStateBack handles next-milestone artifacts created during completion
+ *   - syncWorktreeStateBack skips milestone markdown projections
+ *   - syncWorktreeStateBack does not import root-level .gsd/ state projections
+ *   - syncWorktreeStateBack does not copy worktree milestone projections back
+ *   - syncWorktreeStateBack leaves next-milestone projections DB/project-root authoritative
  *   - syncGsdStateToWorktree syncs non-standard milestone dir names (#1547)
- *   - syncWorktreeStateBack syncs non-standard milestone dir names (#1547)
+ *   - syncWorktreeStateBack skips non-standard milestone projection dir names
  */
 
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
@@ -213,8 +213,8 @@ describe('worktree-sync-milestones', async () => {
     }
   }
 
-  // ─── 8. syncWorktreeStateBack recurses into tasks/ (#1678) ───────────
-  console.log('\n=== 8. syncWorktreeStateBack copies tasks/ subdirectory (#1678) ===');
+  // ─── 8. syncWorktreeStateBack does not copy task projections ───────────
+  console.log('\n=== 8. syncWorktreeStateBack leaves task projections in worktree ===');
   {
     const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-main-'));
     const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-wt-'));
@@ -232,27 +232,26 @@ describe('worktree-sync-milestones', async () => {
       // Main project root starts with only the milestone directory (no slices yet)
       mkdirSync(join(mainBase, '.gsd', 'milestones', 'M002'), { recursive: true });
 
-      // Pass M001 as milestoneId (the one being merged/skipped), M002 should still sync
       const { synced } = syncWorktreeStateBack(mainBase, wtBase, 'M001');
 
       const mainSliceDir = join(mainBase, '.gsd', 'milestones', 'M002', 'slices', 'S01');
       const mainTasksDir = join(mainSliceDir, 'tasks');
 
       assert.ok(
-        existsSync(join(mainSliceDir, 'S01-SUMMARY.md')),
-        '#1678: slice SUMMARY synced to project root',
+        !existsSync(join(mainSliceDir, 'S01-SUMMARY.md')),
+        'slice SUMMARY projection is not copied to project root',
       );
       assert.ok(
-        existsSync(join(mainTasksDir, 'T01-SUMMARY.md')),
-        '#1678: task T01-SUMMARY synced to project root',
+        !existsSync(join(mainTasksDir, 'T01-SUMMARY.md')),
+        'task T01-SUMMARY projection is not copied to project root',
       );
       assert.ok(
-        existsSync(join(mainTasksDir, 'T02-SUMMARY.md')),
-        '#1678: task T02-SUMMARY synced to project root',
+        !existsSync(join(mainTasksDir, 'T02-SUMMARY.md')),
+        'task T02-SUMMARY projection is not copied to project root',
       );
       assert.ok(
-        synced.some((p) => p.includes('tasks/T01-SUMMARY.md')),
-        '#1678: task summary appears in synced list',
+        !synced.some((p) => p.includes('tasks/T01-SUMMARY.md')),
+        'task summary does not appear in synced list',
       );
     } finally {
       rmSync(mainBase, { recursive: true, force: true });
@@ -260,8 +259,8 @@ describe('worktree-sync-milestones', async () => {
     }
   }
 
-  // ─── 9. syncWorktreeStateBack syncs root-level .gsd/ files ──────────
-  console.log('\n=== 9. syncWorktreeStateBack syncs root-level files (REQUIREMENTS, PROJECT) ===');
+  // ─── 9. syncWorktreeStateBack does not import root-level state projections ──────────
+  console.log('\n=== 9. syncWorktreeStateBack leaves root-level state projections authoritative ===');
   {
     const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-root-main-'));
     const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-root-wt-'));
@@ -281,31 +280,31 @@ describe('worktree-sync-milestones', async () => {
 
       const { synced } = syncWorktreeStateBack(mainBase, wtBase, 'M001');
 
-      // Root-level files should be overwritten with worktree versions
+      // Root-level state projections must not be overwritten with worktree versions.
       const reqContent = readFileSync(join(mainBase, '.gsd', 'REQUIREMENTS.md'), 'utf-8');
       assert.ok(
-        reqContent.includes('R002'),
-        'REQUIREMENTS.md updated with worktree content',
+        !reqContent.includes('R002'),
+        'REQUIREMENTS.md ignores worktree projection content',
       );
 
       const projContent = readFileSync(join(mainBase, '.gsd', 'PROJECT.md'), 'utf-8');
       assert.ok(
-        projContent.includes('M002'),
-        'PROJECT.md updated with worktree content',
+        !projContent.includes('M002'),
+        'PROJECT.md ignores worktree projection content',
       );
 
       assert.ok(
-        existsSync(join(mainBase, '.gsd', 'KNOWLEDGE.md')),
-        'KNOWLEDGE.md synced from worktree',
+        !existsSync(join(mainBase, '.gsd', 'KNOWLEDGE.md')),
+        'KNOWLEDGE.md is not copied back from worktree',
       );
 
       assert.ok(
-        synced.includes('REQUIREMENTS.md'),
-        'REQUIREMENTS.md appears in synced list',
+        !synced.includes('REQUIREMENTS.md'),
+        'REQUIREMENTS.md does not appear in synced list',
       );
       assert.ok(
-        synced.includes('PROJECT.md'),
-        'PROJECT.md appears in synced list',
+        !synced.includes('PROJECT.md'),
+        'PROJECT.md does not appear in synced list',
       );
     } finally {
       rmSync(mainBase, { recursive: true, force: true });
@@ -313,8 +312,8 @@ describe('worktree-sync-milestones', async () => {
     }
   }
 
-  // ─── 10. syncWorktreeStateBack syncs ALL milestone directories ─────
-  console.log('\n=== 10. syncWorktreeStateBack syncs all milestone dirs, not just current ===');
+  // ─── 10. syncWorktreeStateBack does not copy milestone directories ─────
+  console.log('\n=== 10. syncWorktreeStateBack does not copy milestone dirs ===');
   {
     const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-all-main-'));
     const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-all-wt-'));
@@ -352,19 +351,19 @@ describe('worktree-sync-milestones', async () => {
         'M001 SUMMARY NOT synced (current milestone skipped to prevent merge conflicts)',
       );
 
-      // M002 should be synced (other milestone — not skipped)
+      // M002 should not be synced either; worktree projections are not authoritative.
       assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'M002-abc123', 'M002-abc123-CONTEXT.md')),
-        'M002 CONTEXT synced to main (next-milestone fix)',
+        !existsSync(join(mainBase, '.gsd', 'milestones', 'M002-abc123', 'M002-abc123-CONTEXT.md')),
+        'M002 CONTEXT projection is not copied to main',
       );
       assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'M002-abc123', 'M002-abc123-ROADMAP.md')),
-        'M002 ROADMAP synced to main (next-milestone fix)',
+        !existsSync(join(mainBase, '.gsd', 'milestones', 'M002-abc123', 'M002-abc123-ROADMAP.md')),
+        'M002 ROADMAP projection is not copied to main',
       );
 
       assert.ok(
-        synced.some((p) => p.includes('M002-abc123')),
-        'M002 appears in synced list',
+        !synced.some((p) => p.includes('M002-abc123')),
+        'M002 does not appear in synced list',
       );
     } finally {
       rmSync(mainBase, { recursive: true, force: true });
@@ -373,7 +372,7 @@ describe('worktree-sync-milestones', async () => {
   }
 
   // ─── 11. Full M006→M007 transition scenario ───────────────────────────
-  console.log('\n=== 11. complete-milestone creates next-milestone artifacts that survive sync ===');
+  console.log('\n=== 11. complete-milestone worktree projections do not overwrite project root ===');
   {
     const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-transition-main-'));
     const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-transition-wt-'));
@@ -419,27 +418,27 @@ describe('worktree-sync-milestones', async () => {
         'M006 SUMMARY NOT synced (current milestone skipped)',
       );
 
-      // Verify M007 artifacts synced (the critical fix — other milestones still sync)
+      // Verify M007 worktree projections are not copied back.
       assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'M007-wortc8', 'M007-wortc8-CONTEXT.md')),
-        'M007 CONTEXT synced to main (next-milestone)',
+        !existsSync(join(mainBase, '.gsd', 'milestones', 'M007-wortc8', 'M007-wortc8-CONTEXT.md')),
+        'M007 CONTEXT projection is not copied to main',
       );
       assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'M007-wortc8', 'M007-wortc8-ROADMAP.md')),
-        'M007 ROADMAP synced to main (next-milestone)',
+        !existsSync(join(mainBase, '.gsd', 'milestones', 'M007-wortc8', 'M007-wortc8-ROADMAP.md')),
+        'M007 ROADMAP projection is not copied to main',
       );
 
-      // Verify root-level files updated
+      // Verify root-level projections remain project-root authoritative.
       const reqContent = readFileSync(join(mainBase, '.gsd', 'REQUIREMENTS.md'), 'utf-8');
       assert.ok(
-        reqContent.includes('R090'),
-        'REQUIREMENTS.md has R090 from worktree',
+        !reqContent.includes('R090'),
+        'REQUIREMENTS.md ignores worktree projection updates',
       );
 
       const projContent = readFileSync(join(mainBase, '.gsd', 'PROJECT.md'), 'utf-8');
       assert.ok(
-        projContent.includes('M007'),
-        'PROJECT.md has M007 from worktree',
+        !projContent.includes('M007'),
+        'PROJECT.md ignores worktree projection updates',
       );
     } finally {
       rmSync(mainBase, { recursive: true, force: true });
@@ -478,8 +477,8 @@ describe('worktree-sync-milestones', async () => {
     }
   }
 
-  // ─── 13. syncWorktreeStateBack syncs QUEUE.md and completed-units.json (#1787) ──
-  console.log('\n=== 13. QUEUE.md and completed-units.json synced from worktree (#1787) ===');
+  // ─── 13. syncWorktreeStateBack skips QUEUE.md but preserves completed-units diagnostics ──
+  console.log('\n=== 13. QUEUE.md skipped; completed-units.json diagnostic synced ===');
   {
     const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-queue-main-'));
     const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-queue-wt-'));
@@ -488,7 +487,7 @@ describe('worktree-sync-milestones', async () => {
       mkdirSync(join(mainBase, '.gsd', 'milestones', 'M001'), { recursive: true });
       mkdirSync(join(wtBase, '.gsd', 'milestones', 'M001'), { recursive: true });
 
-      // Worktree has QUEUE.md and completed-units.json written during milestone closeout
+      // Worktree has QUEUE.md projection and completed-units.json diagnostic.
       writeFileSync(join(wtBase, '.gsd', 'QUEUE.md'), '# Queue\n- M002 next');
       writeFileSync(
         join(wtBase, '.gsd', 'completed-units.json'),
@@ -507,22 +506,17 @@ describe('worktree-sync-milestones', async () => {
 
       const { synced } = syncWorktreeStateBack(mainBase, wtBase, 'M001');
 
-      // QUEUE.md should be synced
-      assert.ok(
-        existsSync(join(mainBase, '.gsd', 'QUEUE.md')),
-        '#1787: QUEUE.md synced from worktree to main',
-      );
-      const queueContent = readFileSync(join(mainBase, '.gsd', 'QUEUE.md'), 'utf-8');
+      // QUEUE.md is state/projection content and should not be copied back.
       assert.ok(
-        queueContent.includes('M002 next'),
-        '#1787: QUEUE.md has correct content',
+        !existsSync(join(mainBase, '.gsd', 'QUEUE.md')),
+        'QUEUE.md is not synced from worktree to main',
       );
       assert.ok(
-        synced.includes('QUEUE.md'),
-        '#1787: QUEUE.md appears in synced list',
+        !synced.includes('QUEUE.md'),
+        'QUEUE.md does not appear in synced list',
       );
 
-      // completed-units.json should be synced
+      // completed-units.json is diagnostic and may be copied for operator visibility.
       assert.ok(
         existsSync(join(mainBase, '.gsd', 'completed-units.json')),
         '#1787: completed-units.json synced from worktree to main',
@@ -578,8 +572,8 @@ describe('worktree-sync-milestones', async () => {
     }
   }
 
-  // ─── 15. syncWorktreeStateBack syncs non-standard milestone dir names (#1547) ──
-  console.log('\n=== 15. syncWorktreeStateBack syncs non-standard milestone dir names (#1547) ===');
+  // ─── 15. syncWorktreeStateBack skips non-standard milestone dir names ──
+  console.log('\n=== 15. syncWorktreeStateBack skips non-standard milestone dir names ===');
   {
     const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-custom-main-'));
     const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-custom-wt-'));
@@ -601,12 +595,12 @@ describe('worktree-sync-milestones', async () => {
       const { synced } = syncWorktreeStateBack(mainBase, wtBase, 'M001');
 
       assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'sprint-beta', 'SUMMARY.md')),
-        '#1547: non-standard milestone dir "sprint-beta" synced back to main',
+        !existsSync(join(mainBase, '.gsd', 'milestones', 'sprint-beta', 'SUMMARY.md')),
+        'non-standard milestone projection is not copied back to main',
       );
       assert.ok(
-        synced.some((p) => p.includes('sprint-beta')),
-        '#1547: sprint-beta appears in synced list',
+        !synced.some((p) => p.includes('sprint-beta')),
+        'sprint-beta does not appear in synced list',
       );
     } finally {
       rmSync(mainBase, { recursive: true, force: true });