gsd-pi 2.64.0-dev.f8aad9b → 2.65.0-dev.16e10d7

package/src/resources/extensions/gsd/tests/unstructured-continue-context-injection.test.ts

@@ -0,0 +1,163 @@
+// GSD-2 — Regression test for #3615: unstructured "continue" must inject task context
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+/**
+ * Bug #3615: When a user types "continue" (or any bare text) to resume
+ * an in-progress session, buildGuidedExecuteContextInjection() only
+ * matched two hardcoded regex patterns (auto-dispatch and guided-resume).
+ * The function returned null for any other input, so no task context was
+ * injected — causing the agent to rebuild everything from scratch and
+ * burn ~86k tokens.
+ *
+ * This test verifies:
+ *   1. Structural: the fallback exists with phase + intent guards
+ *   2. Behavioral: RESUME_INTENT_PATTERNS matches expected prompts and
+ *      rejects non-resume prompts (control, help, diagnostic, etc.)
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const systemContextSource = readFileSync(
+  join(__dirname, "..", "bootstrap", "system-context.ts"),
+  "utf-8",
+);
+
+// ── Structural tests ────────────────────────────────────────────────
+
+describe("#3615 — structural: fallback exists with correct guards", () => {
+  const fnStart = systemContextSource.indexOf("async function buildGuidedExecuteContextInjection(");
+  assert.ok(fnStart >= 0, "should find buildGuidedExecuteContextInjection");
+  const fnEnd = systemContextSource.indexOf("\nasync function ", fnStart + 1);
+  const fnBody = fnEnd >= 0
+    ? systemContextSource.slice(fnStart, fnEnd)
+    : systemContextSource.slice(fnStart);
+
+  test("has a deriveState fallback after the two regex branches", () => {
+    const deriveStateCalls = fnBody.match(/deriveState\(basePath\)/g);
+    assert.ok(
+      deriveStateCalls && deriveStateCalls.length >= 2,
+      `expected >=2 deriveState(basePath) calls, got ${deriveStateCalls?.length ?? 0}`,
+    );
+  });
+
+  test("fallback is phase-gated to executing only", () => {
+    const afterFallback = fnBody.indexOf("// Fallback:");
+    assert.ok(afterFallback >= 0, "should have a fallback comment");
+    const fallbackSection = fnBody.slice(afterFallback);
+    assert.ok(
+      fallbackSection.includes('state.phase === "executing"'),
+      'fallback must be gated on state.phase === "executing"',
+    );
+  });
+
+  test("fallback is intent-gated via RESUME_INTENT_PATTERNS", () => {
+    const afterFallback = fnBody.indexOf("// Fallback:");
+    const fallbackSection = fnBody.slice(afterFallback);
+    assert.ok(
+      fallbackSection.includes("RESUME_INTENT_PATTERNS"),
+      "fallback must check RESUME_INTENT_PATTERNS before deriveState",
+    );
+  });
+
+  test("fallback calls buildTaskExecutionContextInjection with derived state", () => {
+    const afterFallback = fnBody.indexOf("// Fallback:");
+    const fallbackSection = fnBody.slice(afterFallback);
+    assert.ok(
+      fallbackSection.includes("buildTaskExecutionContextInjection") &&
+      fallbackSection.includes("state.activeMilestone.id") &&
+      fallbackSection.includes("state.activeSlice.id") &&
+      fallbackSection.includes("state.activeTask.id"),
+      "fallback must call buildTaskExecutionContextInjection with state-derived IDs",
+    );
+  });
+
+  test("only one return null at the end", () => {
+    const returnNulls = fnBody.match(/return null;/g);
+    assert.ok(
+      returnNulls && returnNulls.length === 1,
+      `expected exactly 1 'return null' (at end after fallback), got ${returnNulls?.length ?? 0}`,
+    );
+  });
+});
+
+// ── Behavioral tests: RESUME_INTENT_PATTERNS ────────────────────────
+
+describe("#3615 — behavioral: RESUME_INTENT_PATTERNS matches resume prompts", () => {
+  // Extract the regex from source so the test stays in sync
+  const patternMatch = systemContextSource.match(/const RESUME_INTENT_PATTERNS\s*=\s*\/(.+)\/;/);
+  assert.ok(patternMatch, "should find RESUME_INTENT_PATTERNS definition");
+  const pattern = new RegExp(patternMatch[1]);
+
+  // Helper: normalize prompt the same way the production code does
+  const normalize = (s: string) => s.trim().toLowerCase().replace(/[.!?,]+$/g, "");
+
+  const shouldMatch = [
+    "continue",
+    "Continue",
+    "CONTINUE",
+    "continue.",
+    "continue!",
+    "resume",
+    "ok",
+    "OK",
+    "Ok!",
+    "go",
+    "go ahead",
+    "Go ahead.",
+    "proceed",
+    "keep going",
+    "carry on",
+    "next",
+    "yes",
+    "yeah",
+    "yep",
+    "sure",
+    "do it",
+    "let's go",
+    "pick up where you left off",
+    "  continue  ",  // whitespace padded
+  ];
+
+  const shouldNotMatch = [
+    "help",
+    "status",
+    "/gsd auto",
+    "/gsd stats",
+    "what's the plan?",
+    "show me the logs",
+    "abort",
+    "stop",
+    "cancel",
+    "replan this slice",
+    "I think we should change the approach",
+    "can you explain what you just did?",
+    "run the tests",
+    "check the build",
+    "Execute the next task: T01",
+    "what files were changed",
+    "",
+  ];
+
+  for (const prompt of shouldMatch) {
+    test(`matches resume prompt: "${prompt}"`, () => {
+      assert.ok(
+        pattern.test(normalize(prompt)),
+        `expected RESUME_INTENT_PATTERNS to match "${prompt}" (normalized: "${normalize(prompt)}")`,
+      );
+    });
+  }
+
+  for (const prompt of shouldNotMatch) {
+    test(`rejects non-resume prompt: "${prompt}"`, () => {
+      assert.ok(
+        !pattern.test(normalize(prompt)),
+        `expected RESUME_INTENT_PATTERNS to NOT match "${prompt}" (normalized: "${normalize(prompt)}")`,
+      );
+    });
+  }
+});

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

@@ -163,16 +163,15 @@ test("deriveState returns completing-milestone when VALIDATION exists with termi
   }
 });
 
-test("deriveState treats needs-remediation as terminal — does not re-enter validating-milestone (#832)", async () => {
+test("deriveState treats needs-remediation as non-terminal — re-enters validating-milestone (#832)", async () => {
   const base = makeTmpBase();
   try {
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
     writeValidation(base, "M001", "---\nverdict: needs-remediation\nremediation_round: 0\n---\n\n# Validation\nNeeds fixes.");
 
     const state = await deriveState(base);
-    // needs-remediation is now terminal — milestone needs a SUMMARY to be fully complete
-    // Without SUMMARY, it enters completing-milestone (not validating-milestone)
-    assert.notEqual(state.phase, "validating-milestone");
+    // needs-remediation routes back to validating-milestone for re-validation
+    assert.equal(state.phase, "validating-milestone");
     assert.equal(state.activeMilestone?.id, "M001");
   } finally {
     cleanup(base);

package/src/resources/extensions/gsd/tests/verification-operational-gate.test.ts

@@ -80,3 +80,18 @@ test("isVerificationNotApplicable: 'Verify API response times under load' requir
 test("isVerificationNotApplicable: 'Monitor error rates for 24h' requires verification", () => {
   assert.equal(isVerificationNotApplicable("Monitor error rates for 24h"), false);
 });
+
+// Regression: #3634 — "Not provided." default from plan-milestone
+test("isVerificationNotApplicable: 'Not provided.' is not applicable (#3634)", () => {
+  assert.equal(isVerificationNotApplicable("Not provided."), true);
+});
+
+test("isVerificationNotApplicable: 'Not provided' (no period) is not applicable (#3634)", () => {
+  assert.equal(isVerificationNotApplicable("Not provided"), true);
+});
+
+test("isVerificationNotApplicable: trailing period does not defeat match (#3634)", () => {
+  assert.equal(isVerificationNotApplicable("None required."), true);
+  assert.equal(isVerificationNotApplicable("N/A."), true);
+  assert.equal(isVerificationNotApplicable("Not applicable."), true);
+});

package/src/resources/extensions/gsd/tests/verify-artifact-tightened.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Regression test for #3607 — tighten verifyExpectedArtifact legacy branch
+ *
+ * The legacy (pre-migration) fallback in verifyExpectedArtifact previously
+ * accepted either a heading match (### T01 --) or a checked checkbox as proof
+ * that gsd_complete_task ran. A heading alone does not prove completion —
+ * it could result from a rogue write.
+ *
+ * The fix removes the hdRe heading regex and requires only a checked checkbox
+ * (cbRe) in the legacy branch, ensuring that only actual tool-completed tasks
+ * are treated as verified.
+ */
+
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const src = readFileSync(
+  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'auto-recovery.ts'),
+  'utf-8',
+)
+
+describe('verifyExpectedArtifact legacy branch tightened (#3607)', () => {
+  it('legacy branch does NOT define hdRe heading regex', () => {
+    // Find the legacy fallback section
+    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
+    assert.ok(legacyIdx !== -1, 'LEGACY comment must exist')
+
+    // Check the code within a reasonable window after the LEGACY comment
+    const legacyBlock = src.slice(legacyIdx, legacyIdx + 600)
+
+    assert.ok(
+      !legacyBlock.includes('hdRe'),
+      'hdRe heading regex must NOT exist in legacy branch — heading alone is not proof of completion',
+    )
+  })
+
+  it('legacy branch requires checked checkbox via cbRe', () => {
+    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
+    assert.ok(legacyIdx !== -1)
+
+    const legacyBlock = src.slice(legacyIdx, legacyIdx + 600)
+
+    assert.ok(
+      legacyBlock.includes('cbRe'),
+      'cbRe checked-checkbox regex must exist in legacy branch',
+    )
+
+    // cbRe must match checked checkboxes [x] or [X]
+    assert.ok(
+      legacyBlock.includes('[xX]'),
+      'cbRe must match both [x] and [X] checkbox variants',
+    )
+  })
+
+  it('legacy branch returns false when no plan file exists', () => {
+    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
+    assert.ok(legacyIdx !== -1)
+
+    const legacyBlock = src.slice(legacyIdx, legacyIdx + 1000)
+
+    // The else branch: no plan file means cannot verify
+    assert.ok(
+      legacyBlock.includes('no plan file'),
+      'missing plan file must be handled with return false',
+    )
+  })
+
+  it('DB available but task not found returns false', () => {
+    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
+    assert.ok(legacyIdx !== -1)
+
+    const legacyBlock = src.slice(legacyIdx, legacyIdx + 1000)
+
+    assert.ok(
+      legacyBlock.includes('DB available but task row not found'),
+      'must handle case where DB is available but task row is missing',
+    )
+
+    // The comment should be followed by a return false
+    const commentIdx = legacyBlock.indexOf('DB available but task row not found')
+    const afterComment = legacyBlock.slice(commentIdx, commentIdx + 200)
+    assert.ok(
+      afterComment.includes('return false'),
+      'missing task row when DB available must return false',
+    )
+  })
+})

package/src/resources/extensions/gsd/tests/worker-model-override.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Worker model override — tests for parallel.worker_model preference.
+ *
+ * Verifies validation, resolveParallelConfig pass-through, and type definitions.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const typesSrc = readFileSync(join(__dirname, "..", "types.ts"), "utf-8");
+const validationSrc = readFileSync(join(__dirname, "..", "preferences-validation.ts"), "utf-8");
+const preferencesSrc = readFileSync(join(__dirname, "..", "preferences.ts"), "utf-8");
+
+// ─── Type definition ──────────────────────────────────────────────────────
+
+test("ParallelConfig includes worker_model optional field", () => {
+  assert.ok(
+    typesSrc.includes("worker_model?: string"),
+    "ParallelConfig should have optional worker_model field",
+  );
+});
+
+// ─── Validation ───────────────────────────────────────────────────────────
+
+test("validatePreferences accepts valid worker_model string", () => {
+  assert.ok(
+    validationSrc.includes("p.worker_model"),
+    "validation should check parallel.worker_model",
+  );
+  assert.ok(
+    validationSrc.includes('parallel.worker_model must be a non-empty string'),
+    "validation should reject invalid worker_model",
+  );
+});
+
+// ─── resolveParallelConfig ────────────────────────────────────────────────
+
+test("resolveParallelConfig passes through worker_model", () => {
+  assert.ok(
+    preferencesSrc.includes("worker_model: prefs?.parallel?.worker_model"),
+    "resolveParallelConfig should pass through worker_model",
+  );
+});

package/src/resources/extensions/gsd/tests/worktree-expected-warnings.test.ts

@@ -0,0 +1,38 @@
+/**
+ * worktree-expected-warnings.test.ts — #3665
+ *
+ * Verify that auto-worktree.ts and worktree-manager.ts suppress expected
+ * ENOENT and EISDIR conditions instead of logging misleading warnings.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const autoWorktreeFile = join(__dirname, "..", "auto-worktree.ts");
+const worktreeManagerFile = join(__dirname, "..", "worktree-manager.ts");
+
+describe("worktree expected-condition warning suppression (#3665)", () => {
+  const autoSource = readFileSync(autoWorktreeFile, "utf-8");
+
+  test("auto-worktree.ts checks for ENOENT before logging unlink warning", () => {
+    assert.match(autoSource, /code\s*!==\s*["']ENOENT["']/);
+  });
+
+  test("auto-worktree.ts checks for EISDIR before logging unlink warning", () => {
+    assert.match(autoSource, /code\s*!==\s*["']EISDIR["']/);
+  });
+
+  test("auto-worktree.ts references issue #3597", () => {
+    assert.match(autoSource, /#3597/);
+  });
+
+  const managerSource = readFileSync(worktreeManagerFile, "utf-8");
+
+  test("worktree-manager.ts checks isDirectory() before reading .git file", () => {
+    assert.match(managerSource, /lstatSync\(gitPath\)\.isDirectory\(\)/);
+  });
+});

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

@@ -26,9 +26,11 @@ import {
   getSliceBranchName,
   autoCommitCurrentBranch,
   SLICE_BRANCH_RE,
+  _resetServiceCache,
 } from "../worktree.ts";
 
 import { deriveState } from "../state.ts";
+import { _clearGsdRootCache } from "../paths.ts";
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -74,6 +76,14 @@ run("git add .", base);
 run('git commit -m "chore: init"', base);
 
 describe('worktree-integration', async () => {
+  // Isolate from user's global preferences (which may have git.main_branch set).
+  // Reset caches so getService() creates a fresh instance with empty preferences.
+  const originalHome = process.env.HOME;
+  const fakeHome = mkdtempSync(join(tmpdir(), "gsd-fake-home-"));
+  process.env.HOME = fakeHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+
   // ── Verify main tree baseline ──────────────────────────────────────────────
 
   console.log("\n=== Main tree baseline ===");
@@ -197,4 +207,10 @@ describe('worktree-integration', async () => {
   assert.deepStrictEqual(listWorktrees(base).length, 0, "all worktrees removed");
 
   rmSync(base, { recursive: true, force: true });
+
+  // Restore HOME and reset caches
+  process.env.HOME = originalHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+  rmSync(fakeHome, { recursive: true, force: true });
 });

package/src/resources/extensions/gsd/tests/worktree-main-branch.test.ts

@@ -0,0 +1,20 @@
+/**
+ * Regression test for #3461: createAutoWorktree must use git.main_branch
+ * preference when META.json integration branch is absent.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+test("auto-worktree.ts includes main_branch preference in startPoint fallback (#3461)", () => {
+  const src = readFileSync(
+    join(import.meta.dirname, "..", "auto-worktree.ts"),
+    "utf-8",
+  );
+  // The fix adds gitPrefs?.main_branch to the startPoint fallback chain
+  assert.ok(
+    src.includes("gitPrefs?.main_branch") || src.includes("prefs.main_branch"),
+    "createAutoWorktree must check git.main_branch preference before falling back to nativeDetectMainBranch",
+  );
+});

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

@@ -221,7 +221,8 @@ describe('worktree-sync-milestones', async () => {
 
     try {
       // Build worktree milestone structure with slice-level and task-level files
-      const wtSliceDir = join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+      // Use M002 as the milestone to sync, M001 as the "current" being merged (skipped)
+      const wtSliceDir = join(wtBase, '.gsd', 'milestones', 'M002', 'slices', 'S01');
       const wtTasksDir = join(wtSliceDir, 'tasks');
       mkdirSync(wtTasksDir, { recursive: true });
       writeFileSync(join(wtSliceDir, 'S01-SUMMARY.md'), '# S01 Summary');
@@ -229,11 +230,12 @@ describe('worktree-sync-milestones', async () => {
       writeFileSync(join(wtTasksDir, 'T02-SUMMARY.md'), '# T02 Summary');
 
       // Main project root starts with only the milestone directory (no slices yet)
-      mkdirSync(join(mainBase, '.gsd', 'milestones', 'M001'), { recursive: true });
+      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', 'M001', 'slices', 'S01');
+      const mainSliceDir = join(mainBase, '.gsd', 'milestones', 'M002', 'slices', 'S01');
       const mainTasksDir = join(mainSliceDir, 'tasks');
 
       assert.ok(
@@ -341,16 +343,16 @@ describe('worktree-sync-milestones', async () => {
         'M002 missing in main before sync',
       );
 
-      // Sync with milestoneId = M001 (the current milestone)
+      // Sync with milestoneId = M001 (the current milestone being merged — skipped)
       const { synced } = syncWorktreeStateBack(mainBase, wtBase, 'M001');
 
-      // M001 should be synced (current milestone — always synced)
+      // M001 should be SKIPPED (current milestone being merged — #3641)
       assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'M001', 'M001-SUMMARY.md')),
-        'M001 SUMMARY synced to main',
+        !existsSync(join(mainBase, '.gsd', 'milestones', 'M001', 'M001-SUMMARY.md')),
+        'M001 SUMMARY NOT synced (current milestone skipped to prevent merge conflicts)',
       );
 
-      // M002 should ALSO be synced (next milestone — the fix)
+      // M002 should be synced (other milestone — not skipped)
       assert.ok(
         existsSync(join(mainBase, '.gsd', 'milestones', 'M002-abc123', 'M002-abc123-CONTEXT.md')),
         'M002 CONTEXT synced to main (next-milestone fix)',
@@ -407,20 +409,17 @@ describe('worktree-sync-milestones', async () => {
       writeFileSync(join(wtBase, '.gsd', 'REQUIREMENTS.md'), '# Requirements\n## R001-R089\n## R090 — SCIM\n## R091 — WebAuthn');
       writeFileSync(join(wtBase, '.gsd', 'PROJECT.md'), '# Project\nMilestones: M001-M007');
 
-      // Sync with milestoneId = M006 (the completing milestone)
+      // Sync with milestoneId = M006 (the completing milestone — skipped by sync)
       const { synced } = syncWorktreeStateBack(mainBase, wtBase, 'M006-589wvh');
 
-      // Verify M006 artifacts synced
-      assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'M006-589wvh', 'M006-589wvh-SUMMARY.md')),
-        'M006 SUMMARY synced',
-      );
+      // M006 is the current milestone being merged — it should be SKIPPED (#3641)
+      // Its files are already in the milestone branch and would conflict with squash merge.
       assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'M006-589wvh', 'slices', 'S01', 'S01-SUMMARY.md')),
-        'M006 S01 SUMMARY synced',
+        !existsSync(join(mainBase, '.gsd', 'milestones', 'M006-589wvh', 'M006-589wvh-SUMMARY.md')),
+        'M006 SUMMARY NOT synced (current milestone skipped)',
       );
 
-      // Verify M007 artifacts synced (the critical fix)
+      // Verify M007 artifacts synced (the critical fix — other milestones still sync)
       assert.ok(
         existsSync(join(mainBase, '.gsd', 'milestones', 'M007-wortc8', 'M007-wortc8-CONTEXT.md')),
         'M007 CONTEXT synced to main (next-milestone)',

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

@@ -47,7 +47,8 @@ function writeFile(dir: string, relativePath: string, content: string): void {
 test("syncWorktreeStateBack copies task summaries from tasks/ subdirectory (#1678)", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const mid = "M001";
+  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
@@ -64,8 +65,8 @@ test("syncWorktreeStateBack copies task summaries from tasks/ subdirectory (#167
     // Set up main with empty .gsd
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    // Run sync
-    const result = syncWorktreeStateBack(mainBase, wtBase, mid);
+    // Run sync — currentMid is skipped, mid (M001) should be synced
+    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
 
     // Verify milestone-level files synced
     assert.ok(
@@ -126,7 +127,8 @@ test("syncWorktreeStateBack copies task summaries from tasks/ subdirectory (#167
 test("syncWorktreeStateBack handles multiple slices with tasks (#1678)", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const mid = "M002";
+  const currentMid = "M000"; // milestone being merged (skipped)
+  const mid = "M002";        // other milestone that should be synced
 
   try {
     // Set up two slices with tasks
@@ -139,7 +141,7 @@ test("syncWorktreeStateBack handles multiple slices with tasks (#1678)", () => {
 
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    const result = syncWorktreeStateBack(mainBase, wtBase, mid);
+    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`)));
@@ -160,7 +162,8 @@ test("syncWorktreeStateBack handles multiple slices with tasks (#1678)", () => {
 test("syncWorktreeStateBack handles slices without tasks/ directory", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const mid = "M003";
+  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)
@@ -168,7 +171,7 @@ test("syncWorktreeStateBack handles slices without tasks/ directory", () => {
 
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    const result = syncWorktreeStateBack(mainBase, wtBase, mid);
+    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`)));
@@ -183,7 +186,8 @@ test("syncWorktreeStateBack handles slices without tasks/ directory", () => {
 test("syncWorktreeStateBack ignores non-md files in tasks/", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const mid = "M004";
+  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");
@@ -194,7 +198,7 @@ test("syncWorktreeStateBack ignores non-md files in tasks/", () => {
 
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    const result = syncWorktreeStateBack(mainBase, wtBase, mid);
+    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
 
     // Only .md files should be synced
     assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`)));

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

@@ -14,9 +14,11 @@ import {
   resolveProjectRoot,
   setActiveMilestoneId,
   SLICE_BRANCH_RE,
+  _resetServiceCache,
 } from "../worktree.ts";
 import { readIntegrationBranch } from "../git-service.ts";
 import { _resetHasChangesCache } from "../native-git-bridge.ts";
+import { _clearGsdRootCache } from "../paths.ts";
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -165,15 +167,30 @@ describe('worktree', async () => {
     run("git checkout -b my-feature", repo);
     captureIntegrationBranch(repo, "M001");
 
-    // Without milestone set, getMainBranch returns "main"
-    setActiveMilestoneId(repo, null);
-    assert.deepStrictEqual(getMainBranch(repo), "main",
-      "getMainBranch returns main without milestone set");
-
-    // With milestone set, getMainBranch returns feature branch
-    setActiveMilestoneId(repo, "M001");
-    assert.deepStrictEqual(getMainBranch(repo), "my-feature",
-      "getMainBranch returns integration branch with milestone set");
+    // Isolate from user's global preferences (which may have git.main_branch set).
+    // Reset caches so getService() creates a fresh instance with empty preferences.
+    const originalHome = process.env.HOME;
+    const fakeHome = mkdtempSync(join(tmpdir(), "gsd-fake-home-"));
+    process.env.HOME = fakeHome;
+    _clearGsdRootCache();
+    _resetServiceCache();
+
+    try {
+      // Without milestone set, getMainBranch returns "main"
+      setActiveMilestoneId(repo, null);
+      assert.deepStrictEqual(getMainBranch(repo), "main",
+        "getMainBranch returns main without milestone set");
+
+      // With milestone set, getMainBranch returns feature branch
+      setActiveMilestoneId(repo, "M001");
+      assert.deepStrictEqual(getMainBranch(repo), "my-feature",
+        "getMainBranch returns integration branch with milestone set");
+    } finally {
+      process.env.HOME = originalHome;
+      _clearGsdRootCache();
+      _resetServiceCache();
+      rmSync(fakeHome, { recursive: true, force: true });
+    }
 
     rmSync(repo, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/zero-slice-roadmap-guided.test.ts

@@ -0,0 +1,19 @@
+/**
+ * Regression test for #3441: guided flow must treat a roadmap with zero
+ * parseable slices the same as no roadmap — offer "Create roadmap" not "Go auto".
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+test("guided-flow checks roadmap slice count before offering auto (#3441)", () => {
+  const src = readFileSync(
+    join(import.meta.dirname, "..", "guided-flow.ts"),
+    "utf-8",
+  );
+  assert.ok(
+    src.includes("roadmapHasSlices") || src.includes("parseRoadmapSlices"),
+    "Guided flow must parse roadmap for slices before deciding which options to show",
+  );
+});