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

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

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

@@ -1,8 +1,9 @@
 /**
- * worktree-sync-tasks.test.ts — Regression test for #1678.
+ * worktree-sync-tasks.test.ts
  *
- * Verifies that syncWorktreeStateBack() correctly syncs task summaries
- * from the tasks/ subdirectory within each slice, not just slice-level files.
+ * DB-authoritative worktree contract: task and milestone markdown under a
+ * worktree .gsd directory are legacy projections. syncWorktreeStateBack must
+ * not copy them into the canonical project .gsd tree.
  */
 
 import test from "node:test";
@@ -11,7 +12,6 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
-  readFileSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
@@ -20,19 +20,13 @@ import { tmpdir } from "node:os";
 
 import { syncWorktreeStateBack } from "../auto-worktree.ts";
 
-// ─── Helpers ─────────────────────────────────────────────────────────
-
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), `gsd-sync-test-${prefix}-`));
 }
 
 function cleanup(...dirs: string[]): void {
   for (const dir of dirs) {
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
+    rmSync(dir, { recursive: true, force: true });
   }
 }
 
@@ -42,168 +36,49 @@ function writeFile(dir: string, relativePath: string, content: string): void {
   writeFileSync(fullPath, content, "utf-8");
 }
 
-// ─── Tests ───────────────────────────────────────────────────────────
-
-test("syncWorktreeStateBack copies task summaries from tasks/ subdirectory (#1678)", () => {
+test("syncWorktreeStateBack does not copy task markdown projections from worktree", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const currentMid = "M000"; // milestone being merged (skipped by sync)
-  const mid = "M001";        // other milestone that should be synced
 
   try {
-    // Set up worktree with milestone, slice, and task files
-    writeFile(wtBase, `.gsd/milestones/${mid}/${mid}-ROADMAP.md`, "# Roadmap\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/${mid}-SUMMARY.md`, "# Summary\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-PLAN.md`, "# Plan\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-SUMMARY.md`, "# Slice Summary\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-UAT.md`, "# UAT\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-PLAN.md`, "# Task 1 Plan\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`, "# Task 1 Summary\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T02-PLAN.md`, "# Task 2 Plan\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T02-SUMMARY.md`, "# Task 2 Summary\n");
-
-    // Set up main with empty .gsd
+    writeFile(wtBase, ".gsd/milestones/M001/M001-ROADMAP.md", "# Roadmap\n");
+    writeFile(wtBase, ".gsd/milestones/M001/slices/S01/S01-PLAN.md", "# Plan\n");
+    writeFile(wtBase, ".gsd/milestones/M001/slices/S01/tasks/T01-SUMMARY.md", "# Task Summary\n");
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    // Run sync — currentMid is skipped, mid (M001) should be synced
-    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
-
-    // Verify milestone-level files synced
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/${mid}-ROADMAP.md`)),
-      "ROADMAP should be synced",
-    );
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/${mid}-SUMMARY.md`)),
-      "SUMMARY should be synced",
-    );
-
-    // Verify slice-level files synced
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/S01-PLAN.md`)),
-      "S01-PLAN should be synced",
-    );
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/S01-SUMMARY.md`)),
-      "S01-SUMMARY should be synced",
-    );
+    const result = syncWorktreeStateBack(mainBase, wtBase, "M000");
 
-    // Verify task-level files synced (THE BUG FIX)
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-PLAN.md`)),
-      "T01-PLAN should be synced (was dropped before fix)",
-    );
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`)),
-      "T01-SUMMARY should be synced (was dropped before fix)",
-    );
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T02-PLAN.md`)),
-      "T02-PLAN should be synced (was dropped before fix)",
-    );
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T02-SUMMARY.md`)),
-      "T02-SUMMARY should be synced (was dropped before fix)",
-    );
-
-    // Verify task files appear in synced list
-    const taskSynced = result.synced.filter(p => p.includes("/tasks/"));
-    assert.ok(
-      taskSynced.length >= 4,
-      `Expected at least 4 task files in synced list, got ${taskSynced.length}: ${taskSynced.join(", ")}`,
-    );
-
-    // Verify content integrity
-    const t1Summary = readFileSync(
-      join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`),
-      "utf-8",
+    assert.equal(result.synced.some((p) => p.includes("milestones/")), false);
+    assert.equal(
+      existsSync(join(mainBase, ".gsd/milestones/M001/M001-ROADMAP.md")),
+      false,
+      "milestone markdown projection must not be copied",
     );
-    assert.equal(t1Summary, "# Task 1 Summary\n");
-  } finally {
-    cleanup(mainBase, wtBase);
-  }
-});
-
-test("syncWorktreeStateBack handles multiple slices with tasks (#1678)", () => {
-  const mainBase = makeTempDir("main");
-  const wtBase = makeTempDir("wt");
-  const currentMid = "M000"; // milestone being merged (skipped)
-  const mid = "M002";        // other milestone that should be synced
-
-  try {
-    // Set up two slices with tasks
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-SUMMARY.md`, "# S01\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`, "# S01-T01\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S02/S02-SUMMARY.md`, "# S02\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S02/tasks/T01-SUMMARY.md`, "# S02-T01\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S02/tasks/T02-SUMMARY.md`, "# S02-T02\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S02/tasks/T03-SUMMARY.md`, "# S02-T03\n");
-
-    mkdirSync(join(mainBase, ".gsd"), { recursive: true });
-
-    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
-
-    // All task summaries from both slices should be synced
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`)));
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S02/tasks/T01-SUMMARY.md`)));
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S02/tasks/T02-SUMMARY.md`)));
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S02/tasks/T03-SUMMARY.md`)));
-
-    // Verify content integrity across slices
     assert.equal(
-      readFileSync(join(mainBase, `.gsd/milestones/${mid}/slices/S02/tasks/T03-SUMMARY.md`), "utf-8"),
-      "# S02-T03\n",
+      existsSync(join(mainBase, ".gsd/milestones/M001/slices/S01/tasks/T01-SUMMARY.md")),
+      false,
+      "task summary projection must not be copied",
     );
   } finally {
     cleanup(mainBase, wtBase);
   }
 });
 
-test("syncWorktreeStateBack handles slices without tasks/ directory", () => {
-  const mainBase = makeTempDir("main");
-  const wtBase = makeTempDir("wt");
-  const currentMid = "M000"; // milestone being merged (skipped)
-  const mid = "M003";        // other milestone that should be synced
-
-  try {
-    // Slice with no tasks/ subdirectory (legitimate case: pre-planning)
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-RESEARCH.md`, "# Research\n");
-
-    mkdirSync(join(mainBase, ".gsd"), { recursive: true });
-
-    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
-
-    // Should sync the slice file without errors
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/S01-RESEARCH.md`)));
-    // Should not have any task entries
-    const taskSynced = result.synced.filter(p => p.includes("/tasks/"));
-    assert.equal(taskSynced.length, 0);
-  } finally {
-    cleanup(mainBase, wtBase);
-  }
-});
-
-test("syncWorktreeStateBack ignores non-md files in tasks/", () => {
+test("syncWorktreeStateBack still copies diagnostic root files", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const currentMid = "M000"; // milestone being merged (skipped)
-  const mid = "M004";        // other milestone that should be synced
 
   try {
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-PLAN.md`, "# Plan\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`, "# T01\n");
-    // Non-md file should be ignored
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/.DS_Store`, "junk");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/notes.txt`, "notes");
-
+    writeFile(wtBase, ".gsd/completed-units.json", JSON.stringify({ units: ["M001/S01/T01"] }));
+    writeFile(wtBase, ".gsd/metrics.json", JSON.stringify({ version: 1, units: [] }));
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
+    const result = syncWorktreeStateBack(mainBase, wtBase, "M001");
 
-    // Only .md files should be synced
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`)));
-    assert.ok(!existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/.DS_Store`)));
-    assert.ok(!existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/notes.txt`)));
+    assert.ok(result.synced.includes("completed-units.json"));
+    assert.ok(result.synced.includes("metrics.json"));
+    assert.ok(existsSync(join(mainBase, ".gsd/completed-units.json")));
+    assert.ok(existsSync(join(mainBase, ".gsd/metrics.json")));
   } finally {
     cleanup(mainBase, wtBase);
   }