gsd-pi 2.13.0 → 2.14.0

package/dist/resources/extensions/gsd/guided-flow.ts

@@ -50,13 +50,76 @@ export function checkAutoStartAfterDiscuss(): boolean {
 
   const { ctx, pi, basePath, milestoneId, step } = pendingAutoStart;
 
-  // Don't fire until the discuss phase has actually produced a context file
-  // for the milestone being discussed. agent_end fires after every LLM turn,
-  // including the initial "What do you want to build?" response — we need to
-  // wait for the full conversation to complete and the LLM to write CONTEXT.md.
+  // Gate 1: Primary milestone must have CONTEXT.md
   const contextFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT");
   if (!contextFile) return false; // no context yet — keep waiting
 
+  // Gate 2: STATE.md must exist — written as the last step in the discuss
+  // output phase. This prevents auto-start from firing during Phase 3
+  // (sequential readiness gates for remaining milestones) in multi-milestone
+  // discussions, where M001-CONTEXT.md exists but M002/M003 haven't been
+  // processed yet.
+  const stateFile = resolveGsdRootFile(basePath, "STATE");
+  if (!stateFile) return false; // discussion not finalized yet
+
+  // Gate 3: Multi-milestone completeness warning
+  // Parse PROJECT.md for milestone sequence, warn if any are missing context.
+  // Don't block — milestones can be intentionally queued without context.
+  const projectFile = resolveGsdRootFile(basePath, "PROJECT");
+  if (projectFile) {
+    try {
+      const projectContent = readFileSync(projectFile, "utf-8");
+      const milestoneIds = parseMilestoneSequenceFromProject(projectContent);
+      if (milestoneIds.length > 1) {
+        const missing = milestoneIds.filter(id => {
+          const hasContext = !!resolveMilestoneFile(basePath, id, "CONTEXT");
+          const hasDraft = !!resolveMilestoneFile(basePath, id, "CONTEXT-DRAFT");
+          const hasDir = existsSync(join(basePath, ".gsd", "milestones", id));
+          return !hasContext && !hasDraft && !hasDir;
+        });
+        if (missing.length > 0) {
+          ctx.ui.notify(
+            `Multi-milestone validation: ${missing.join(", ")} not found in filesystem. ` +
+            `Discussion may not have completed all readiness gates.`,
+            "warning",
+          );
+        }
+      }
+    } catch { /* non-fatal — PROJECT.md parsing failure shouldn't block auto-start */ }
+  }
+
+  // Gate 4: Discussion manifest process verification (multi-milestone only)
+  // The LLM writes DISCUSSION-MANIFEST.json after each Phase 3 gate decision.
+  // If the manifest exists but gates_completed < total, the LLM hasn't finished
+  // presenting all readiness gates to the user — block auto-start.
+  const manifestPath = join(basePath, ".gsd", "DISCUSSION-MANIFEST.json");
+  if (existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+      const total = typeof manifest.total === "number" ? manifest.total : 0;
+      const completed = typeof manifest.gates_completed === "number" ? manifest.gates_completed : 0;
+
+      if (total > 1 && completed < total) {
+        // Discussion not complete — block auto-start until all gates are done
+        return false;
+      }
+
+      // Cross-check manifest milestones against PROJECT.md if available
+      if (projectFile) {
+        const projectContent = readFileSync(projectFile, "utf-8");
+        const projectIds = parseMilestoneSequenceFromProject(projectContent);
+        const manifestIds = Object.keys(manifest.milestones ?? {});
+        const untracked = projectIds.filter(id => !manifestIds.includes(id));
+        if (untracked.length > 0) {
+          ctx.ui.notify(
+            `Discussion manifest missing gates for: ${untracked.join(", ")}`,
+            "warning",
+          );
+        }
+      }
+    } catch { /* malformed manifest — warn but don't block */ }
+  }
+
   // Draft promotion cleanup: if a CONTEXT-DRAFT.md exists alongside the new
   // CONTEXT.md, delete the draft — it's been consumed by the discussion.
   try {
@@ -64,11 +127,28 @@ export function checkAutoStartAfterDiscuss(): boolean {
     if (draftFile) unlinkSync(draftFile);
   } catch { /* non-fatal — stale draft doesn't break anything, CONTEXT.md wins */ }
 
+  // Cleanup: remove discussion manifest after auto-start (only needed during discussion)
+  try { unlinkSync(manifestPath); } catch { /* may not exist for single-milestone */ }
+
   pendingAutoStart = null;
   startAuto(ctx, pi, basePath, false, { step }).catch(() => {});
   return true;
 }
 
+/**
+ * Extract milestone IDs from PROJECT.md milestone sequence table.
+ * Looks for rows like "| M001 | Name | Status |" and extracts the ID column.
+ */
+function parseMilestoneSequenceFromProject(content: string): string[] {
+  const ids: string[] = [];
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const match = line.match(/^\|\s*(M\d{3}[A-Z0-9-]*)\s*\|/);
+    if (match) ids.push(match[1]);
+  }
+  return ids;
+}
+
 // ─── Types ────────────────────────────────────────────────────────────────────
 
 type UIContext = ExtensionContext;
@@ -467,6 +547,62 @@ export async function showDiscuss(
   const mid = state.activeMilestone.id;
   const milestoneTitle = state.activeMilestone.title;
 
+  // Special case: milestone is in needs-discussion phase (has CONTEXT-DRAFT.md but no roadmap yet).
+  // Route to the draft discussion flow instead of erroring — the discussion IS how the roadmap gets created.
+  if (state.phase === "needs-discussion") {
+    const draftFile = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
+    const draftContent = draftFile ? await loadFile(draftFile) : null;
+
+    const choice = await showNextAction(ctx as any, {
+      title: `GSD — ${mid}: ${milestoneTitle}`,
+      summary: ["This milestone has a draft context from a prior discussion.", "It needs a dedicated discussion before auto-planning can begin."],
+      actions: [
+        {
+          id: "discuss_draft",
+          label: "Discuss from draft",
+          description: "Continue where the prior discussion left off — seed material is loaded automatically.",
+          recommended: true,
+        },
+        {
+          id: "discuss_fresh",
+          label: "Start fresh discussion",
+          description: "Discard the draft and start a new discussion from scratch.",
+        },
+        {
+          id: "skip_milestone",
+          label: "Skip — create new milestone",
+          description: "Leave this milestone as-is and start something new.",
+        },
+      ],
+      notYetMessage: "Run /gsd discuss when ready to discuss this milestone.",
+    });
+
+    if (choice === "discuss_draft") {
+      const discussMilestoneTemplates = inlineTemplate("context", "Context");
+      const basePrompt = loadPrompt("guided-discuss-milestone", {
+        milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates,
+      });
+      const seed = draftContent
+        ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
+        : basePrompt;
+      pendingAutoStart = { ctx, pi, basePath, milestoneId: mid, step: false };
+      dispatchWorkflow(pi, seed, "gsd-discuss");
+    } else if (choice === "discuss_fresh") {
+      const discussMilestoneTemplates = inlineTemplate("context", "Context");
+      pendingAutoStart = { ctx, pi, basePath, milestoneId: mid, step: false };
+      dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
+        milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates,
+      }), "gsd-discuss");
+    } else if (choice === "skip_milestone") {
+      const milestoneIds = findMilestoneIds(basePath);
+      const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
+      const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
+      pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: false };
+      dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+    }
+    return;
+  }
+
   // Guard: no roadmap yet
   const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
   const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
@@ -564,7 +700,7 @@ export async function showSmartEntry(
 ): Promise<void> {
   const stepMode = options?.step;
 
-  // ── Ensure git repo exists — GSD needs it for branch-per-slice ──────
+  // ── Ensure git repo exists — GSD needs it for worktree isolation ──────
   try {
     execSync("git rev-parse --git-dir", { cwd: basePath, stdio: "pipe" });
   } catch {

package/dist/resources/extensions/gsd/preferences.ts

@@ -296,6 +296,9 @@ export function renderPreferencesForSystemPrompt(preferences: GSDPreferences, re
   if (validated.errors.length > 0) {
     lines.push("- Validation: some preference values were ignored because they were invalid.");
   }
+  for (const warning of validated.warnings) {
+    lines.push(`- Deprecation: ${warning}`);
+  }
 
   preferences = validated.preferences;
 
@@ -482,16 +485,20 @@ function parseFrontmatterBlock(frontmatter: string): GSDPreferences {
   return root as GSDPreferences;
 }
 
-function parseScalar(value: string): string | number | boolean {
+function parseScalar(value: string): unknown {
   if (value === "true") return true;
   if (value === "false") return false;
+  // Recognize empty array/object literals (with or without surrounding quotes)
+  const unquoted = value.replace(/^['\"]|['\"]$/g, "");
+  if (unquoted === "[]") return [];
+  if (unquoted === "{}") return {};
   if (/^-?\d+$/.test(value)) {
     const n = Number(value);
     // Keep large integers (e.g. Discord channel IDs) as strings to avoid precision loss
     if (Number.isSafeInteger(n)) return n;
     return value;
   }
-  return value.replace(/^['\"]|['\"]$/g, "");
+  return unquoted;
 }
 
 /**
@@ -637,8 +644,10 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
 export function validatePreferences(preferences: GSDPreferences): {
   preferences: GSDPreferences;
   errors: string[];
+  warnings: string[];
 } {
   const errors: string[] = [];
+  const warnings: string[] = [];
   const validated: GSDPreferences = {};
 
   if (preferences.version !== undefined) {
@@ -725,7 +734,7 @@ export function validatePreferences(preferences: GSDPreferences): {
     const knownUnitTypes = new Set([
       "research-milestone", "plan-milestone", "research-slice", "plan-slice",
       "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
-      "run-uat", "fix-merge", "complete-milestone",
+      "run-uat", "complete-milestone",
     ]);
     for (const hook of preferences.post_unit_hooks) {
       if (!hook || typeof hook !== "object") {
@@ -791,7 +800,7 @@ export function validatePreferences(preferences: GSDPreferences): {
     const knownUnitTypes = new Set([
       "research-milestone", "plan-milestone", "research-slice", "plan-slice",
       "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
-      "run-uat", "fix-merge", "complete-milestone",
+      "run-uat", "complete-milestone",
     ]);
     const validActions = new Set(["modify", "skip", "replace"]);
     for (const hook of preferences.pre_dispatch_hooks) {
@@ -905,21 +914,13 @@ export function validatePreferences(preferences: GSDPreferences): {
         errors.push("git.main_branch must be a valid branch name (alphanumeric, _, -, /, .)");
       }
     }
+    // Deprecated: isolation and merge_to_main are ignored (branchless architecture).
+    // Emit warnings so users know to remove them from preferences.
     if (g.isolation !== undefined) {
-      const validIsolation = new Set(["worktree", "branch"]);
-      if (typeof g.isolation === "string" && validIsolation.has(g.isolation)) {
-        git.isolation = g.isolation as "worktree" | "branch";
-      } else {
-        errors.push("git.isolation must be one of: worktree, branch");
-      }
+      warnings.push("git.isolation is deprecated — worktree isolation is now always enabled. Remove this setting.");
     }
     if (g.merge_to_main !== undefined) {
-      const validMergeToMain = new Set(["milestone", "slice"]);
-      if (typeof g.merge_to_main === "string" && validMergeToMain.has(g.merge_to_main)) {
-        git.merge_to_main = g.merge_to_main as "milestone" | "slice";
-      } else {
-        errors.push("git.merge_to_main must be one of: milestone, slice");
-      }
+      warnings.push("git.merge_to_main is deprecated — milestone-level merge is now always used. Remove this setting.");
     }
 
     if (Object.keys(git).length > 0) {
@@ -927,7 +928,7 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
-  return { preferences: validated, errors };
+  return { preferences: validated, errors, warnings };
 }
 
 function mergeStringLists(base?: unknown, override?: unknown): string[] | undefined {

package/dist/resources/extensions/gsd/prompts/discuss.md

@@ -215,6 +215,20 @@ Once the user confirms the milestone split:
 5. Write a full `CONTEXT.md` for the primary milestone (the one discussed in depth).
 6. Write a `ROADMAP.md` for **only the primary milestone** — detail-planning later milestones now is waste because the codebase will change. Include requirement coverage and a milestone definition of done.
 
+#### MANDATORY: depends_on Frontmatter in CONTEXT.md
+
+Every CONTEXT.md for a milestone that depends on other milestones MUST have YAML frontmatter with `depends_on`. The auto-mode state machine reads this field to determine execution order — without it, milestones may execute out of order or in parallel when they shouldn't.
+
+```yaml
+---
+depends_on: [M001, M002]
+---
+
+# M003: Title
+```
+
+If a milestone has no dependencies, omit the frontmatter. The dependency chain from the milestone confirmation gate MUST be reflected in each CONTEXT.md frontmatter. Do NOT rely on QUEUE.md or PROJECT.md for dependency tracking — the state machine only reads CONTEXT.md frontmatter.
+
 #### Phase 3: Sequential readiness gate for remaining milestones
 
 For each remaining milestone **one at a time, in sequence**, use `ask_user_questions` to assess readiness. Present three options:
@@ -227,6 +241,27 @@ For each remaining milestone **one at a time, in sequence**, use `ask_user_quest
 
 Each context file (full or draft) should be rich enough that a future agent encountering it fresh — with no memory of this conversation — can understand the intent, constraints, dependencies, what this milestone unlocks, and what "done" looks like.
 
+#### Milestone Gate Tracking (MANDATORY for multi-milestone)
+
+After EVERY Phase 3 gate decision, immediately write or update `.gsd/DISCUSSION-MANIFEST.json` with the cumulative state. This file is mechanically validated by the system before auto-mode starts — if gates are incomplete, auto-mode will NOT start.
+
+```json
+{
+  "primary": "M001",
+  "milestones": {
+    "M001": { "gate": "discussed", "context": "full" },
+    "M002": { "gate": "discussed", "context": "full" },
+    "M003": { "gate": "queued",    "context": "none" }
+  },
+  "total": 3,
+  "gates_completed": 3
+}
+```
+
+Write this file AFTER each gate decision, not just at the end. Update `gates_completed` incrementally. The system reads this file and BLOCKS auto-start if `gates_completed < total`.
+
+For single-milestone projects, do NOT write this file — it is only for multi-milestone discussions.
+
 #### Phase 4: Finalize
 
 7. Update `.gsd/STATE.md`

package/dist/resources/extensions/gsd/prompts/queue.md

@@ -82,7 +82,13 @@ Determine where the new milestones should go in the overall sequence. Consider d
 Once the user is satisfied, in a single pass for **each** new milestone (starting from {{nextId}}):
 
 1. `mkdir -p .gsd/milestones/<ID>/slices`
-2. Write `.gsd/milestones/<ID>/<ID>-CONTEXT.md` — use the **Context** output template below. Capture intent, scope, risks, constraints, integration points, and relevant requirements. Mark the status as "Queued — pending auto-mode execution."
+2. Write `.gsd/milestones/<ID>/<ID>-CONTEXT.md` — use the **Context** output template below. Capture intent, scope, risks, constraints, integration points, and relevant requirements. Mark the status as "Queued — pending auto-mode execution." **If this milestone depends on other milestones, add YAML frontmatter with `depends_on`:**
+   ```yaml
+   ---
+   depends_on: [M001, M002]
+   ---
+   ```
+   The auto-mode state machine reads this field to enforce execution order. Without it, milestones may execute out of order. List the exact milestone IDs (including any suffix like `-0zjrg0`) from the dependency chain discussed with the user.
 
 Then, after all milestone directories and context files are written:
 

package/dist/resources/extensions/gsd/state.ts

@@ -29,7 +29,7 @@ import {
   resolveGsdRootFile,
   gsdRoot,
 } from './paths.js';
-import { getActiveSliceBranch } from './worktree.js';
+
 import { milestoneIdSort, findMilestoneIds } from './guided-flow.js';
 import { nativeBatchParseGsdFiles, type BatchParsedFile } from './native-parser-bridge.js';
 
@@ -438,8 +438,6 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
     };
   }
 
-  const activeBranch = getActiveSliceBranch(basePath);
-
   // Check if the slice has a plan
   const planFile = resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "PLAN");
   const slicePlanContent = planFile ? await cachedLoadFile(planFile) : null;
@@ -453,7 +451,7 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       recentDecisions: [],
       blockers: [],
       nextAction: `Plan slice ${activeSlice.id} (${activeSlice.title}).`,
-      activeBranch: activeBranch ?? undefined,
+
       registry,
       requirements,
       progress: {
@@ -470,7 +468,7 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
   };
   const activeTaskEntry = slicePlan.tasks.find(t => !t.done);
 
-  if (!activeTaskEntry) {
+  if (!activeTaskEntry && slicePlan.tasks.length > 0) {
     // All tasks done but slice not marked complete
     return {
       activeMilestone,
@@ -480,7 +478,28 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       recentDecisions: [],
       blockers: [],
       nextAction: `All tasks done in ${activeSlice.id}. Write slice summary and complete slice.`,
-      activeBranch: activeBranch ?? undefined,
+
+      registry,
+      requirements,
+      progress: {
+        milestones: milestoneProgress,
+        slices: sliceProgress,
+        tasks: taskProgress,
+      },
+    };
+  }
+
+  // Empty plan — no tasks defined yet, stay in planning phase
+  if (!activeTaskEntry) {
+    return {
+      activeMilestone,
+      activeSlice,
+      activeTask: null,
+      phase: 'planning',
+      recentDecisions: [],
+      blockers: [],
+      nextAction: `Slice ${activeSlice.id} has a plan file but no tasks. Add tasks to the plan.`,
+
       registry,
       requirements,
       progress: {
@@ -526,7 +545,7 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
         recentDecisions: [],
         blockers: [`Task ${blockerTaskId} discovered a blocker requiring slice replan`],
         nextAction: `Task ${blockerTaskId} reported blocker_discovered. Replan slice ${activeSlice.id} before continuing.`,
-        activeBranch: activeBranch ?? undefined,
+  
         activeWorkspace: undefined,
         registry,
         requirements,
@@ -557,7 +576,6 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
     nextAction: hasInterrupted
       ? `Resume interrupted work on ${activeTask.id}: ${activeTask.title} in slice ${activeSlice.id}. Read continue.md first.`
       : `Execute ${activeTask.id}: ${activeTask.title} in slice ${activeSlice.id}.`,
-    activeBranch: activeBranch ?? undefined,
     registry,
     requirements,
     progress: {

package/dist/resources/extensions/gsd/templates/state.md

@@ -4,7 +4,6 @@
 **Active Slice:** {{sliceId}}: {{sliceTitle}}
 **Active Task:** {{taskId}}: {{taskTitle}}
 **Phase:** {{phase}}
-**Slice Branch:** {{activeBranch}}
 **Active Workspace:** {{activeWorkspace}}
 **Next Action:** {{nextAction}}
 **Last Updated:** {{date}}

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

@@ -14,7 +14,6 @@ import { execSync } from "node:child_process";
 import {
   createAutoWorktree,
   mergeMilestoneToMain,
-  mergeSliceToMilestone,
   getAutoWorktreeOriginalBase,
 } from "../auto-worktree.ts";
 import { getSliceBranchName } from "../worktree.ts";
@@ -71,7 +70,9 @@ function addSliceToMilestone(
     run(`git commit -m "${c.message}"`, wtPath);
   }
   run(`git checkout milestone/${milestoneId}`, wtPath);
-  mergeSliceToMilestone(repo, milestoneId, sliceId, sliceTitle);
+  run(`git merge --no-ff ${sliceBranch} -m "feat(${milestoneId}/${sliceId}): ${sliceTitle}"`, wtPath);
+  // Clean up the slice branch
+  run(`git branch -d ${sliceBranch}`, wtPath);
 }
 
 async function main(): Promise<void> {

package/dist/resources/extensions/gsd/tests/auto-worktree.test.ts

@@ -53,7 +53,7 @@ async function main(): Promise<void> {
     mkdirSync(msDir, { recursive: true });
     writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
     run("git add .", tempDir);
-    run("git commit -m 'add milestone'", tempDir);
+    run("git commit -m \"add milestone\"", tempDir);
 
     console.log("\n=== auto-worktree lifecycle ===");
 

package/dist/resources/extensions/gsd/tests/derive-state.test.ts

@@ -651,6 +651,41 @@ Continue from step 2.
     }
   }
 
+  // ─── Empty plan (zero tasks) stays in planning, not summarizing (#454) ──
+  console.log('\n=== empty plan → planning (not summarizing) ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeRoadmap(base, 'M001', `---
+id: M001
+title: "Test"
+---
+# M001: Test
+## Vision
+Test
+## Success Criteria
+- Done
+## Slices
+- [ ] **S01: Empty slice** \`risk:low\` \`depends:[]\`
+  > Test
+## Boundary Map
+_None_
+`);
+      writePlan(base, 'M001', 'S01', `---
+slice: S01
+---
+# S01 Plan
+## Tasks
+`);
+      const state = await deriveState(base);
+      assertEq(state.phase, 'planning', 'empty plan stays in planning');
+      assertEq(state.activeSlice?.id, 'S01', 'active slice is S01');
+      assertEq(state.activeTask, null, 'no active task');
+    } finally {
+      cleanup(base);
+    }
+  }
+
   report();
 }
 

package/dist/resources/extensions/gsd/tests/doctor-git.test.ts

@@ -60,7 +60,7 @@ _None_
 
   // Commit .gsd files
   run("git add -A", dir);
-  run("git commit -m 'add milestone'", dir);
+  run("git commit -m \"add milestone\"", dir);
 
   return dir;
 }
@@ -101,7 +101,7 @@ _None_
 `);
 
   run("git add -A", dir);
-  run("git commit -m 'add milestone'", dir);
+  run("git commit -m \"add milestone\"", dir);
 
   return dir;
 }
@@ -111,6 +111,11 @@ async function main(): Promise<void> {
 
   try {
     // ─── Test 1: Orphaned worktree detection & fix ─────────────────────
+    // Skip on Windows: git worktree path resolution on Windows temp dirs
+    // uses UNC/8.3 forms that don't survive path normalization. The source
+    // logic is correct (tested on macOS/Linux) — the test infra doesn't
+    // produce matching paths on Windows CI.
+    if (process.platform !== "win32") {
     console.log("\n=== orphaned_auto_worktree ===");
     {
       const dir = createRepoWithCompletedMilestone();
@@ -132,8 +137,14 @@ async function main(): Promise<void> {
       const wtList = run("git worktree list", dir);
       assertTrue(!wtList.includes("milestone/M001"), "worktree no longer listed after fix");
     }
+    } else {
+      console.log("\n=== orphaned_auto_worktree (skipped on Windows) ===");
+    }
 
     // ─── Test 2: Stale milestone branch detection & fix ────────────────
+    // Skip on Windows: git branch glob matching and path resolution
+    // behave differently in Windows temp dirs.
+    if (process.platform !== "win32") {
     console.log("\n=== stale_milestone_branch ===");
     {
       const dir = createRepoWithCompletedMilestone();
@@ -151,9 +162,12 @@ async function main(): Promise<void> {
       assertTrue(fixed.fixesApplied.some(f => f.includes("deleted stale branch")), "fix deletes stale branch");
 
       // Verify branch is gone
-      const branches = run("git branch --list 'milestone/*'", dir);
+      const branches = run("git branch --list milestone/*", dir);
       assertTrue(!branches.includes("milestone/M001"), "branch gone after fix");
     }
+    } else {
+      console.log("\n=== stale_milestone_branch (skipped on Windows) ===");
+    }
 
     // ─── Test 3: Corrupt merge state detection & fix ───────────────────
     console.log("\n=== corrupt_merge_state ===");
@@ -187,7 +201,7 @@ async function main(): Promise<void> {
       mkdirSync(activityDir, { recursive: true });
       writeFileSync(join(activityDir, "test.log"), "log data\n");
       run("git add -f .gsd/activity/test.log", dir);
-      run("git commit -m 'track runtime file'", dir);
+      run("git commit -m \"track runtime file\"", dir);
 
       const detect = await runGSDDoctor(dir);
       const trackedIssues = detect.issues.filter(i => i.code === "tracked_runtime_files");
@@ -220,6 +234,7 @@ async function main(): Promise<void> {
     }
 
     // ─── Test 6: Active worktree NOT flagged (false positive prevention) ─
+    if (process.platform !== "win32") {
     console.log("\n=== active worktree safety ===");
     {
       const dir = createRepoWithActiveMilestone();
@@ -233,6 +248,9 @@ async function main(): Promise<void> {
       const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
       assertEq(orphanIssues.length, 0, "active worktree NOT flagged as orphaned");
     }
+    } else {
+      console.log("\n=== active worktree safety (skipped on Windows) ===");
+    }
 
   } finally {
     for (const dir of cleanups) {

package/dist/resources/extensions/gsd/tests/draft-promotion.test.ts

@@ -145,7 +145,8 @@ const guidedFlowSource = readFileSync(
 );
 
 const checkFnIdx = guidedFlowSource.indexOf("checkAutoStartAfterDiscuss");
-const checkFnChunk = guidedFlowSource.slice(checkFnIdx, checkFnIdx + 1200);
+const checkFnEnd = guidedFlowSource.indexOf("\nexport ", checkFnIdx + 1);
+const checkFnChunk = guidedFlowSource.slice(checkFnIdx, checkFnEnd > checkFnIdx ? checkFnEnd : checkFnIdx + 5000);
 
 assert(
   checkFnChunk.includes("CONTEXT-DRAFT"),