gsd-pi 2.41.0-dev.9446b20 → 2.41.0-dev.97349b1

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

@@ -386,6 +386,91 @@ test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", ()
   }
 });
 
+// ─── verifyExpectedArtifact: heading-style plan tasks (#1691) ─────────────
+
+test("verifyExpectedArtifact accepts plan-slice with heading-style tasks (### T01 --)", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01 -- Implement feature",
+      "",
+      "Feature description.",
+      "",
+      "### T02 -- Write tests",
+      "",
+      "Test description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+    writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Heading-style plan with task entries should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact accepts plan-slice with colon-style heading tasks (### T01:)", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01: Implement feature",
+      "",
+      "Feature description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Colon heading-style plan should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact execute-task passes for heading-style plan entry (#1691)", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01 -- Implement feature",
+      "",
+      "Feature description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone.");
+    assert.strictEqual(
+      verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+      true,
+      "execute-task should pass for heading-style plan entry when summary exists",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── selfHealRuntimeRecords — worktree base path (#769) ──────────────────
 
 test("selfHealRuntimeRecords clears stale dispatched records (#769)", async () => {

package/src/resources/extensions/gsd/tests/auto-secrets-gate.test.ts

@@ -101,8 +101,8 @@ test('secrets gate: pending keys exist — gate triggers collection, manifest up
     const status = await getManifestStatus(tmp, 'M001');
     assert.notStrictEqual(status, null, 'manifest should exist');
     assert.ok(status!.pending.length > 0, 'should have pending keys');
-    assert.deepStrictEqual(status!.pending, ['GSD_GATE_TEST_PEND_A', 'GSD_GATE_TEST_PEND_B']);
-    assert.deepStrictEqual(status!.existing, ['GSD_GATE_TEST_EXISTING']);
+    assert.deepStrictEqual(status!.pending, ['GSD_GATE_TEST_PEND_A', 'GSD_GATE_TEST_PEND_B'], 'pending keys');
+    assert.deepStrictEqual(status!.existing, ['GSD_GATE_TEST_EXISTING'], 'existing keys');
 
     // (b) Call collectSecretsFromManifest with no-UI context
     // With hasUI: false, collectOneSecret returns null → pending keys become "skipped"

package/src/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -569,6 +569,208 @@ async function main(): Promise<void> {
       assertTrue(existsSync(join(repo, "landed.ts")), "landed.ts present on main");
     }
 
+    // ─── Test 14: Stale branch ref — worktree HEAD ahead of branch (#1846) ─
+    console.log("\n=== stale branch ref — fast-forward before squash merge (#1846) ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M140");
+
+      // Add a first slice normally — this advances both the branch ref and HEAD
+      addSliceToMilestone(repo, wtPath, "M140", "S01", "Initial work", [
+        { file: "initial.ts", content: "export const initial = true;\n", message: "add initial" },
+      ]);
+
+      // Now simulate the bug: detach HEAD in the worktree, then make commits
+      // that advance HEAD but leave the milestone/M140 branch ref behind.
+      const branchRefBefore = run("git rev-parse milestone/M140", wtPath);
+      run("git checkout --detach HEAD", wtPath);
+
+      // Add multiple commits on the detached HEAD (simulates agent work)
+      writeFileSync(join(wtPath, "feature-a.ts"), "export const featureA = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "add feature-a"', wtPath);
+
+      writeFileSync(join(wtPath, "feature-b.ts"), "export const featureB = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "add feature-b"', wtPath);
+
+      writeFileSync(join(wtPath, "feature-c.ts"), "export const featureC = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "add feature-c"', wtPath);
+
+      // Verify: branch ref is stale, HEAD is ahead
+      const branchRefAfter = run("git rev-parse milestone/M140", wtPath);
+      const worktreeHead = run("git rev-parse HEAD", wtPath);
+      assertEq(branchRefBefore, branchRefAfter, "branch ref unchanged (stale)");
+      assertTrue(worktreeHead !== branchRefAfter, "worktree HEAD ahead of branch ref");
+
+      const roadmap = makeRoadmap("M140", "Stale ref milestone", [
+        { id: "S01", title: "Initial work" },
+      ]);
+
+      // The fix should fast-forward the branch ref to worktree HEAD before
+      // squash-merging, so ALL commits are captured.
+      let threw = false;
+      let errMsg = "";
+      try {
+        const result = mergeMilestoneToMain(repo, "M140", roadmap);
+        assertTrue(result.commitMessage.includes("feat(M140)"), "merge commit created");
+      } catch (err) {
+        threw = true;
+        errMsg = err instanceof Error ? err.message : String(err);
+      }
+      assertTrue(!threw, `should not throw with stale branch ref (got: ${errMsg})`);
+
+      // ALL files from detached HEAD commits must be on main — not just
+      // the ones from the stale branch ref
+      assertTrue(existsSync(join(repo, "initial.ts")), "initial.ts on main");
+      assertTrue(existsSync(join(repo, "feature-a.ts")), "feature-a.ts on main (#1846)");
+      assertTrue(existsSync(join(repo, "feature-b.ts")), "feature-b.ts on main (#1846)");
+      assertTrue(existsSync(join(repo, "feature-c.ts")), "feature-c.ts on main (#1846)");
+    }
+
+    // ─── Test 15: Diverged worktree HEAD — throws instead of losing data (#1846) ─
+    console.log("\n=== diverged worktree HEAD — throws on divergence (#1846) ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M150");
+
+      addSliceToMilestone(repo, wtPath, "M150", "S01", "Base work", [
+        { file: "base.ts", content: "export const base = true;\n", message: "add base" },
+      ]);
+
+      run("git checkout --detach HEAD", wtPath);
+      writeFileSync(join(wtPath, "detached-work.ts"), "export const detached = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "detached work"', wtPath);
+
+      run("git checkout milestone/M150", repo);
+      writeFileSync(join(repo, "diverged-work.ts"), "export const diverged = true;\n");
+      run("git add .", repo);
+      run('git commit -m "diverged work on branch"', repo);
+      run("git checkout main", repo);
+
+      process.chdir(wtPath);
+
+      const roadmap = makeRoadmap("M150", "Diverged milestone", [
+        { id: "S01", title: "Base work" },
+      ]);
+
+      let threw = false;
+      let errMsg = "";
+      try {
+        mergeMilestoneToMain(repo, "M150", roadmap);
+      } catch (err) {
+        threw = true;
+        errMsg = err instanceof Error ? err.message : String(err);
+      }
+      assertTrue(threw, "throws when worktree HEAD diverged from branch ref (#1846)");
+      assertTrue(errMsg.includes("diverged"), "error message mentions divergence (#1846)");
+
+      const branches = run("git branch", repo);
+      assertTrue(branches.includes("milestone/M150"), "milestone branch preserved on divergence (#1846)");
+    }
+
+    // ─── Test 16: #1853 Bug 1 — SQUASH_MSG cleaned up after squash-merge ──
+    console.log("\n=== #1853 bug 1: SQUASH_MSG cleaned up after successful squash-merge ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M160");
+
+      addSliceToMilestone(repo, wtPath, "M160", "S01", "SQUASH_MSG cleanup test", [
+        { file: "squash-cleanup.ts", content: "export const cleanup = true;\n", message: "add squash-cleanup" },
+      ]);
+
+      const roadmap = makeRoadmap("M160", "SQUASH_MSG cleanup", [
+        { id: "S01", title: "SQUASH_MSG cleanup test" },
+      ]);
+
+      const squashMsgPath = join(repo, ".git", "SQUASH_MSG");
+      writeFileSync(squashMsgPath, "leftover squash message\n");
+      assertTrue(existsSync(squashMsgPath), "SQUASH_MSG planted before merge");
+
+      const result = mergeMilestoneToMain(repo, "M160", roadmap);
+      assertTrue(result.commitMessage.includes("feat(M160)"), "merge commit created");
+
+      assertTrue(
+        !existsSync(squashMsgPath),
+        "#1853: SQUASH_MSG must not persist after successful squash-merge",
+      );
+    }
+
+    // ─── Test 17: #1853 Bug 2 — uncommitted worktree code survives teardown ──
+    console.log("\n=== #1853 bug 2: uncommitted worktree changes committed before teardown ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M170");
+
+      addSliceToMilestone(repo, wtPath, "M170", "S01", "Teardown safety test", [
+        { file: "safe-file.ts", content: "export const safe = true;\n", message: "add safe file" },
+      ]);
+
+      writeFileSync(join(wtPath, "uncommitted-agent-code.ts"), "export const lost = true;\n");
+
+      const roadmap = makeRoadmap("M170", "Teardown safety", [
+        { id: "S01", title: "Teardown safety test" },
+      ]);
+
+      const result = mergeMilestoneToMain(repo, "M170", roadmap);
+      assertTrue(result.commitMessage.includes("feat(M170)"), "merge commit created");
+
+      assertTrue(
+        existsSync(join(repo, "uncommitted-agent-code.ts")),
+        "#1853: uncommitted worktree code must survive teardown",
+      );
+    }
+
+    // ─── Test 18: #1906 — codeFilesChanged false when only .gsd/ metadata merged ──
+    console.log("\n=== #1906: codeFilesChanged=false when only .gsd/ metadata merged ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M180");
+
+      // Only add .gsd/ metadata files — no actual code
+      mkdirSync(join(wtPath, ".gsd", "milestones", "M180"), { recursive: true });
+      writeFileSync(
+        join(wtPath, ".gsd", "milestones", "M180", "SUMMARY.md"),
+        "# M180 Summary\n\nThis milestone was planned but not implemented.\n",
+      );
+      run("git add .", wtPath);
+      run('git commit -m "chore: add milestone summary"', wtPath);
+
+      const roadmap = makeRoadmap("M180", "Metadata-only milestone", []);
+
+      const result = mergeMilestoneToMain(repo, "M180", roadmap);
+      assertEq(
+        result.codeFilesChanged,
+        false,
+        "#1906: codeFilesChanged must be false when only .gsd/ files were merged",
+      );
+    }
+
+    // ─── Test 19: #1906 — codeFilesChanged true when real code is merged ──
+    console.log("\n=== #1906: codeFilesChanged=true when real code is merged ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M190");
+
+      addSliceToMilestone(repo, wtPath, "M190", "S01", "Real code", [
+        { file: "real-code.ts", content: "export const real = true;\n", message: "add real code" },
+      ]);
+
+      const roadmap = makeRoadmap("M190", "Code milestone", [
+        { id: "S01", title: "Real code" },
+      ]);
+
+      const result = mergeMilestoneToMain(repo, "M190", roadmap);
+      assertEq(
+        result.codeFilesChanged,
+        true,
+        "#1906: codeFilesChanged must be true when real code files were merged",
+      );
+      assertTrue(existsSync(join(repo, "real-code.ts")), "real-code.ts merged to main");
+    }
+
   } finally {
     process.chdir(savedCwd);
     for (const d of tempDirs) {

package/src/resources/extensions/gsd/tests/captures.test.ts

@@ -119,12 +119,23 @@ test("captures: loadPendingCaptures filters resolved entries", () => {
     const id1 = appendCapture(tmp, "pending one");
     appendCapture(tmp, "pending two");
 
-    // Resolve the first one
     markCaptureResolved(tmp, id1, "note", "acknowledged", "just a note");
 
     const pending = loadPendingCaptures(tmp);
     assert.strictEqual(pending.length, 1, "should have 1 pending");
     assert.strictEqual(pending[0].text, "pending two");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("captures: loadAllCaptures preserves resolved entries", () => {
+  const tmp = makeTempDir("cap-all-resolved");
+  try {
+    const id1 = appendCapture(tmp, "pending one");
+    appendCapture(tmp, "pending two");
+
+    markCaptureResolved(tmp, id1, "note", "acknowledged", "just a note");
 
     const all = loadAllCaptures(tmp);
     assert.strictEqual(all.length, 2, "all should still have 2");

package/src/resources/extensions/gsd/tests/context-store.test.ts

@@ -51,17 +51,17 @@ console.log('\n=== context-store: query all active decisions ===');
   insertDecision({
     id: 'D001', when_context: 'M001/S01', scope: 'architecture',
     decision: 'use SQLite', choice: 'node:sqlite', rationale: 'built-in',
-    revisable: 'yes', superseded_by: 'D003', // superseded!
+    revisable: 'yes', made_by: 'agent', superseded_by: 'D003', // superseded!
   });
   insertDecision({
     id: 'D002', when_context: 'M001/S01', scope: 'architecture',
     decision: 'use WAL mode', choice: 'WAL', rationale: 'concurrent reads',
-    revisable: 'no', superseded_by: null,
+    revisable: 'no', made_by: 'agent', superseded_by: null,
   });
   insertDecision({
     id: 'D003', when_context: 'M002/S01', scope: 'performance',
     decision: 'use better-sqlite3', choice: 'better-sqlite3', rationale: 'faster',
-    revisable: 'yes', superseded_by: null,
+    revisable: 'yes', made_by: 'agent', superseded_by: null,
   });
 
   const all = queryDecisions();
@@ -81,11 +81,13 @@ console.log('\n=== context-store: query decisions by milestone ===');
   insertDecision({
     id: 'D001', when_context: 'M001/S01', scope: 'architecture',
     decision: 'decision A', choice: 'A', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
   insertDecision({
     id: 'D002', when_context: 'M002/S02', scope: 'architecture',
     decision: 'decision B', choice: 'B', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -107,11 +109,13 @@ console.log('\n=== context-store: query decisions by scope ===');
   insertDecision({
     id: 'D001', when_context: 'M001/S01', scope: 'architecture',
     decision: 'decision A', choice: 'A', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
   insertDecision({
     id: 'D002', when_context: 'M001/S01', scope: 'performance',
     decision: 'decision B', choice: 'B', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -248,12 +252,12 @@ console.log('\n=== context-store: formatDecisionsForPrompt ===');
     {
       seq: 1, id: 'D001', when_context: 'M001/S01', scope: 'architecture',
       decision: 'use SQLite', choice: 'node:sqlite', rationale: 'built-in',
-      revisable: 'yes', superseded_by: null,
+      revisable: 'yes', made_by: 'agent', superseded_by: null,
     },
     {
       seq: 2, id: 'D002', when_context: 'M001/S02', scope: 'performance',
       decision: 'use WAL', choice: 'WAL', rationale: 'concurrent',
-      revisable: 'no', superseded_by: null,
+      revisable: 'no', made_by: 'human', superseded_by: null,
     },
   ]);
 
@@ -323,6 +327,7 @@ console.log('\n=== context-store: sub-5ms query timing ===');
       choice: `choice ${i}`,
       rationale: `rationale ${i}`,
       revisable: i % 3 === 0 ? 'no' : 'yes',
+      made_by: 'agent',
       superseded_by: null,
     });
   }

package/src/resources/extensions/gsd/tests/continue-here.test.ts

@@ -72,18 +72,17 @@ describe("continue-here", () => {
       const budget = computeBudgets(128_000);
       const threshold = budget.continueThresholdPercent;
 
-      // Simulate repeated polls with percent above threshold
-      let fired = false;
-      let fireCount = 0;
+      // Simulate repeated polls with percent above threshold using a reducer
+      // so there is no control flow inside the test body.
       const usagePercents = [75, 80, 85, 90, 95];
-
-      for (const percent of usagePercents) {
-        if (fired) continue; // one-shot guard
-        if (percent >= threshold) {
-          fired = true;
-          fireCount++;
-        }
-      }
+      const { fired, fireCount } = usagePercents.reduce(
+        (acc, percent) => {
+          if (acc.fired) return acc; // one-shot guard
+          if (percent >= threshold) return { fired: true, fireCount: acc.fireCount + 1 };
+          return acc;
+        },
+        { fired: false, fireCount: 0 },
+      );
 
       assert.equal(fireCount, 1, "must fire exactly once");
       assert.equal(fired, true);
@@ -97,16 +96,17 @@ describe("continue-here", () => {
       { name: "1M", contextWindow: 1_000_000 },
     ];
 
-    it("all model sizes produce continueThresholdPercent of 70", () => {
-      for (const { name, contextWindow } of modelSizes) {
+    const thresholdCases: Array<[string, number]> = [
+      ["128K", 128_000],
+      ["200K", 200_000],
+      ["1M", 1_000_000],
+    ];
+    for (const [name, contextWindow] of thresholdCases) {
+      it(`${name} model produces continueThresholdPercent of 70`, () => {
         const budget = computeBudgets(contextWindow);
-        assert.equal(
-          budget.continueThresholdPercent,
-          70,
-          `${name} model should have 70% threshold`,
-        );
-      }
-    });
+        assert.equal(budget.continueThresholdPercent, 70, `${name} model should have 70% threshold`);
+      });
+    }
 
     it("larger models produce larger verificationBudgetChars", () => {
       const budgets = modelSizes.map(({ contextWindow }) => computeBudgets(contextWindow));

package/src/resources/extensions/gsd/tests/db-writer.test.ts

@@ -59,6 +59,7 @@ const SAMPLE_DECISIONS: Decision[] = [
     choice: 'better-sqlite3',
     rationale: 'Sync API',
     revisable: 'No',
+    made_by: 'collaborative',
     superseded_by: null,
   },
   {
@@ -70,6 +71,7 @@ const SAMPLE_DECISIONS: Decision[] = [
     choice: '.gsd/gsd.db',
     rationale: 'Derived state',
     revisable: 'No',
+    made_by: 'agent',
     superseded_by: null,
   },
   {
@@ -81,6 +83,7 @@ const SAMPLE_DECISIONS: Decision[] = [
     choice: 'node:sqlite fallback',
     rationale: 'Zero deps',
     revisable: 'Yes',
+    made_by: 'human',
     superseded_by: null,
   },
 ];
@@ -166,6 +169,7 @@ console.log('\n── generateDecisionsMd round-trip ──');
     assertEq(rt.choice, orig.choice, `decision ${orig.id} choice round-trips`);
     assertEq(rt.rationale, orig.rationale, `decision ${orig.id} rationale round-trips`);
     assertEq(rt.revisable, orig.revisable, `decision ${orig.id} revisable round-trips`);
+    assertEq(rt.made_by, orig.made_by, `decision ${orig.id} made_by round-trips`);
   }
 }
 
@@ -177,6 +181,7 @@ console.log('\n── generateDecisionsMd format ──');
   assertTrue(md.includes('<!-- Append-only'), 'contains HTML comment block');
   assertTrue(md.includes('| # | When | Scope'), 'contains table header');
   assertTrue(md.includes('|---|------|-------'), 'contains separator row');
+  assertTrue(md.includes('| Made By |'), 'contains Made By column header');
 }
 
 console.log('\n── generateDecisionsMd empty input ──');
@@ -200,6 +205,7 @@ console.log('\n── generateDecisionsMd pipe escaping ──');
     choice: 'A',
     rationale: 'Better',
     revisable: 'No',
+    made_by: 'agent',
     superseded_by: null,
   };
   const md = generateDecisionsMd([withPipe]);
@@ -291,6 +297,7 @@ console.log('\n── nextDecisionId ──');
     choice: 'test choice',
     rationale: 'test',
     revisable: 'No',
+    made_by: 'agent',
     superseded_by: null,
   });
   upsertDecision({
@@ -301,6 +308,7 @@ console.log('\n── nextDecisionId ──');
     choice: 'test choice',
     rationale: 'test',
     revisable: 'No',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -520,6 +528,7 @@ console.log('\n── Full DB round-trip: decisions ──');
       choice: d.choice,
       rationale: d.rationale,
       revisable: d.revisable,
+      made_by: d.made_by,
       superseded_by: d.superseded_by,
     });
   }
@@ -536,6 +545,7 @@ console.log('\n── Full DB round-trip: decisions ──');
     choice: row['choice'] as string,
     rationale: row['rationale'] as string,
     revisable: row['revisable'] as string,
+    made_by: (row['made_by'] as string as import('../types.js').DecisionMadeBy) ?? 'agent',
     superseded_by: (row['superseded_by'] as string) ?? null,
   }));
 

package/src/resources/extensions/gsd/tests/doctor-completion-deferral.test.ts

@@ -80,7 +80,7 @@ test("COMPLETION_TRANSITION_CODES only contains slice summary code", () => {
   );
 });
 
-test("fixLevel:task — fixes roadmap checkbox and UAT stub immediately, defers only summary (#1808)", async () => {
+test("fixLevel:task — fixes UAT stub immediately, defers summary and roadmap checkbox (#1808, #1910)", async () => {
   const tmp = makeTmp("partial-deferral");
   try {
     buildScaffold(tmp);
@@ -101,15 +101,16 @@ test("fixLevel:task — fixes roadmap checkbox and UAT stub immediately, defers
     const sliceUatPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-UAT.md");
     assert.ok(existsSync(sliceUatPath), "should have created UAT stub immediately");
 
-    // Roadmap checkbox SHOULD be marked done (mechanical bookkeeping, no longer deferred)
+    // Roadmap checkbox must NOT be checked without summary on disk (#1910).
+    // Checking it without the summary causes deriveState() to skip complete-slice.
     const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-    assert.ok(roadmapContent.includes("- [x] **S01"), "roadmap should show S01 as checked");
+    assert.ok(roadmapContent.includes("- [ ] **S01"), "roadmap must NOT be checked without summary on disk (#1910)");
   } finally {
     rmSync(tmp, { recursive: true, force: true });
   }
 });
 
-test("fixLevel:task — session crash after last task leaves roadmap and UAT consistent (#1808)", async () => {
+test("fixLevel:task — session crash after last task leaves UAT consistent, roadmap deferred with summary (#1808, #1910)", async () => {
   const tmp = makeTmp("crash-consistency");
   try {
     buildScaffold(tmp);
@@ -121,13 +122,7 @@ test("fixLevel:task — session crash after last task leaves roadmap and UAT con
     // A new session starts and runs doctor again at task level.
     const report2 = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
 
-    // The only remaining issue should be the deferred summary.
-    // Roadmap and UAT should already be fixed from the first run.
     const remainingCodes = report2.issues.map(i => i.code);
-    assert.ok(
-      !remainingCodes.includes("all_tasks_done_roadmap_not_checked"),
-      "roadmap should already be fixed from first doctor run"
-    );
     assert.ok(
       !remainingCodes.includes("all_tasks_done_missing_slice_uat"),
       "UAT should already be fixed from first doctor run"
@@ -137,6 +132,16 @@ test("fixLevel:task — session crash after last task leaves roadmap and UAT con
       remainingCodes.includes("all_tasks_done_missing_slice_summary"),
       "summary should still be detected as missing (deferred)"
     );
+    // Roadmap should still be unchecked because summary doesn't exist (#1910)
+    assert.ok(
+      remainingCodes.includes("all_tasks_done_roadmap_not_checked"),
+      "roadmap should still be unchecked — summary does not exist on disk (#1910)"
+    );
+    // Must NOT produce the cascade error from checking roadmap without summary
+    assert.ok(
+      !remainingCodes.includes("slice_checked_missing_summary"),
+      "must not produce slice_checked_missing_summary (#1910)"
+    );
   } finally {
     rmSync(tmp, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/doctor-fixlevel.test.ts

@@ -63,7 +63,7 @@ Done.
 `);
 }
 
-test("fixLevel:task — defers only summary stub, fixes roadmap and UAT immediately (#1808)", async () => {
+test("fixLevel:task — defers summary stub and roadmap checkbox, fixes UAT immediately (#1808, #1910)", async () => {
   const tmp = makeTmp("task-level");
   try {
     buildScaffold(tmp);
@@ -79,13 +79,14 @@ test("fixLevel:task — defers only summary stub, fixes roadmap and UAT immediat
     const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
     assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub");
 
-    // Roadmap SHOULD be marked done (mechanical bookkeeping, no longer deferred)
+    // Roadmap must NOT be checked without summary on disk (#1910)
     const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-    assert.ok(roadmapContent.includes("- [x] **S01"), "roadmap should show S01 as checked");
+    assert.ok(roadmapContent.includes("- [ ] **S01"), "roadmap must NOT be checked without summary (#1910)");
 
-    // Fixes applied should NOT include summary but SHOULD include roadmap
+    // Fixes applied should NOT include summary or roadmap
     for (const f of report.fixesApplied) {
       assert.ok(!f.includes("SUMMARY"), `should not have fixed summary: ${f}`);
+      assert.ok(!f.includes("ROADMAP") && !f.includes("roadmap"), `should not have fixed roadmap: ${f}`);
     }
   } finally {
     rmSync(tmp, { recursive: true, force: true });