gsd-pi 2.25.0 → 2.26.0

package/packages/pi-coding-agent/src/tests/path-display.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Cross-platform path display tests.
+ *
+ * Verifies that toPosixPath correctly normalizes Windows paths and that
+ * the system prompt builder produces forward-slash paths for LLM consumption.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { toPosixPath } from "../utils/path-display.js";
+import { buildSystemPrompt } from "../core/system-prompt.js";
+
+// ─── toPosixPath ────────────────────────────────────────────────────────────
+
+test("toPosixPath: converts Windows backslash paths to forward slashes", () => {
+	assert.equal(toPosixPath("C:\\Users\\name\\project"), "C:/Users/name/project");
+});
+
+test("toPosixPath: handles mixed separators", () => {
+	assert.equal(toPosixPath("C:\\Users/name\\project/src"), "C:/Users/name/project/src");
+});
+
+test("toPosixPath: no-op for Unix paths", () => {
+	assert.equal(toPosixPath("/home/user/project"), "/home/user/project");
+});
+
+test("toPosixPath: handles empty string", () => {
+	assert.equal(toPosixPath(""), "");
+});
+
+test("toPosixPath: handles Windows UNC paths", () => {
+	assert.equal(toPosixPath("\\\\server\\share\\dir"), "//server/share/dir");
+});
+
+test("toPosixPath: handles .gsd/worktrees path on Windows", () => {
+	assert.equal(
+		toPosixPath("C:\\Users\\name\\project\\.gsd\\worktrees\\M001"),
+		"C:/Users/name/project/.gsd/worktrees/M001",
+	);
+});
+
+// ─── System prompt path normalization ───────────────────────────────────────
+
+test("buildSystemPrompt: cwd uses forward slashes even with Windows input", () => {
+	const prompt = buildSystemPrompt({
+		cwd: "C:\\Users\\name\\development\\app-name",
+	});
+	assert.ok(
+		prompt.includes("C:/Users/name/development/app-name"),
+		"System prompt should contain forward-slash path",
+	);
+	assert.ok(
+		!prompt.includes("C:\\Users\\name\\development\\app-name"),
+		"System prompt must NOT contain backslash path",
+	);
+});
+
+test("buildSystemPrompt: Unix paths pass through unchanged", () => {
+	const prompt = buildSystemPrompt({
+		cwd: "/home/user/project",
+	});
+	assert.ok(prompt.includes("/home/user/project"));
+});
+
+// ─── Regression: no backslash paths in LLM-visible text ────────────────────
+
+/**
+ * Pattern that matches Windows-style absolute paths with backslashes.
+ * Catches: C:\Users\..., D:\Projects\..., \\server\share\...
+ * Does not match: escaped chars in regex, JSON strings, etc.
+ */
+const WINDOWS_ABS_PATH_RE = /[A-Z]:\\[A-Za-z]/;
+
+test("buildSystemPrompt: no Windows absolute paths with backslashes in output", () => {
+	// Simulate a Windows-like cwd
+	const prompt = buildSystemPrompt({
+		cwd: "D:\\Projects\\my-app\\.gsd\\worktrees\\M002",
+	});
+	const lines = prompt.split("\n");
+	const violations = lines.filter(line => WINDOWS_ABS_PATH_RE.test(line));
+	assert.equal(
+		violations.length, 0,
+		`System prompt contains Windows backslash paths:\n${violations.join("\n")}`,
+	);
+});

package/packages/pi-coding-agent/src/utils/clipboard-image.ts

@@ -114,16 +114,43 @@ function readClipboardImageViaWlPaste(): ClipboardImage | null {
 		.filter(Boolean);
 
 	const selectedType = selectPreferredImageMimeType(types);
-	if (!selectedType) {
-		return null;
+	if (selectedType) {
+		const data = runCommand("wl-paste", ["--type", selectedType, "--no-newline"]);
+		if (data.ok && data.stdout.length > 0) {
+			return { bytes: data.stdout, mimeType: baseMimeType(selectedType) };
+		}
 	}
 
-	const data = runCommand("wl-paste", ["--type", selectedType, "--no-newline"]);
-	if (!data.ok || data.stdout.length === 0) {
-		return null;
+	// Fallback for WSLg/BMP: when only image/bmp is available, ask wl-paste
+	// to convert to PNG on the fly. wl-paste supports format conversion for
+	// some compositor types. If that fails, try reading BMP and converting
+	// via ImageMagick (#813).
+	const hasBmp = types.some((t) => baseMimeType(t) === "image/bmp");
+	if (!selectedType && hasBmp) {
+		// Try requesting PNG directly — wl-paste may convert
+		const pngData = runCommand("wl-paste", ["--type", "image/png", "--no-newline"]);
+		if (pngData.ok && pngData.stdout.length > 0) {
+			return { bytes: pngData.stdout, mimeType: "image/png" };
+		}
+
+		// Try reading BMP and converting via ImageMagick convert
+		const bmpData = runCommand("wl-paste", ["--type", "image/bmp", "--no-newline"]);
+		if (bmpData.ok && bmpData.stdout.length > 0) {
+			const converted = spawnSync("convert", ["bmp:-", "png:-"], {
+				input: bmpData.stdout,
+				timeout: 5000,
+				maxBuffer: DEFAULT_MAX_BUFFER_BYTES,
+			});
+			if (!converted.error && converted.status === 0 && converted.stdout.length > 0) {
+				const stdout = Buffer.isBuffer(converted.stdout)
+					? converted.stdout
+					: Buffer.from(converted.stdout);
+				return { bytes: stdout, mimeType: "image/png" };
+			}
+		}
 	}
 
-	return { bytes: data.stdout, mimeType: baseMimeType(selectedType) };
+	return null;
 }
 
 function readClipboardImageViaXclip(): ClipboardImage | null {

package/packages/pi-coding-agent/src/utils/path-display.ts

@@ -0,0 +1,36 @@
+/**
+ * Cross-platform path display utilities.
+ *
+ * Paths injected into LLM prompts, tool results, or any text the model
+ * processes must use forward slashes. Windows backslash paths cause bash
+ * failures when the model copies them into shell commands — bash interprets
+ * backslashes as escape characters, silently stripping them.
+ *
+ * Node's `path` module and `fs` module handle native separators correctly
+ * for filesystem operations. This module is ONLY for paths that enter
+ * text consumed by the LLM or interpreted by a shell.
+ *
+ * Usage:
+ *   import { toPosixPath } from "./path-display.js";
+ *   prompt += `Current working directory: ${toPosixPath(cwd)}`;
+ *
+ * NOT for:
+ *   fs.readFile(path)          — use native path as-is
+ *   path.join(a, b)            — use native path module
+ *   spawn(cmd, { cwd: path })  — Node handles this correctly
+ */
+
+/**
+ * Convert a filesystem path to forward-slash (POSIX) form for display.
+ *
+ * On Unix this is a no-op. On Windows it converts `C:\Users\name\project`
+ * to `C:/Users/name/project`, which is valid in:
+ * - Git Bash / MSYS2
+ * - WSL bash
+ * - PowerShell
+ * - Node.js APIs (which accept both separators)
+ * - Most Windows programs
+ */
+export function toPosixPath(fsPath: string): string {
+	return fsPath.replaceAll("\\", "/");
+}

package/src/resources/extensions/async-jobs/index.ts

@@ -54,6 +54,14 @@ export default function AsyncJobs(pi: ExtensionAPI) {
 					? output.slice(0, maxLen) + "\n\n[... truncated, use await_job for full output]"
 					: output;
 
+				// Deliver as follow-up without triggering a new LLM turn (#875).
+				// When the agent is streaming: the message is queued and picked up
+				// by the agent loop's getFollowUpMessages() after the current turn.
+				// When the agent is idle: the message is appended to context so it's
+				// visible on the next user-initiated prompt. Previously triggerTurn:true
+				// caused spurious autonomous turns — the model would interpret completed
+				// job output as requiring action and cascade into unbounded self-reinforcing
+				// loops (running more commands, spawning more jobs, burning context).
 				pi.sendMessage(
 					{
 						customType: "async_job_result",
@@ -64,7 +72,7 @@ export default function AsyncJobs(pi: ExtensionAPI) {
 						].join("\n"),
 						display: true,
 					},
-					{ deliverAs: "followUp", triggerTurn: true },
+					{ deliverAs: "followUp" },
 				);
 			},
 		});

package/src/resources/extensions/bg-shell/index.ts

@@ -66,6 +66,7 @@ import { waitForReady } from "./readiness-detector.js";
 import { queryShellEnv, sendAndWait, runOnSession } from "./interaction.js";
 import { formatUptime, formatTokenCount, resolveBgShellPersistenceCwd } from "./utilities.js";
 import { BgManagerOverlay } from "./overlay.js";
+import { toPosixPath } from "../shared/path-display.js";
 
 // ── Re-exports for consumers ───────────────────────────────────────────────
 
@@ -337,7 +338,7 @@ export default function (pi: ExtensionAPI) {
 					text += `  type: ${bg.processType}\n`;
 					text += `  status: ${bg.status}\n`;
 					text += `  command: ${bg.command}\n`;
-					text += `  cwd: ${bg.cwd}`;
+					text += `  cwd: ${toPosixPath(bg.cwd)}`;
 
 					if (bg.group) text += `\n  group: ${bg.group}`;
 					if (bg.readyPort) text += `\n  ready_port: ${bg.readyPort}`;
@@ -694,7 +695,7 @@ export default function (pi: ExtensionAPI) {
 					}
 
 					let text = `Shell environment for ${bg.id} (${bg.label}):\n`;
-					text += `  cwd: ${envResult.cwd}\n`;
+					text += `  cwd: ${toPosixPath(envResult.cwd)}\n`;
 					text += `  shell: ${envResult.shell}\n`;
 
 					const envEntries = Object.entries(envResult.env);

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

@@ -90,6 +90,10 @@ export function resolveExpectedArtifactPath(unitType: string, unitId: string, ba
       const dir = resolveMilestonePath(base, mid);
       return dir ? join(dir, buildMilestoneFileName(mid, "SUMMARY")) : null;
     }
+    case "replan-slice": {
+      const dir = resolveSlicePath(base, mid, sid!);
+      return dir ? join(dir, buildSliceFileName(sid!, "REPLAN")) : null;
+    }
     case "rewrite-docs":
       return null;
     default:
@@ -127,10 +131,9 @@ export function verifyExpectedArtifact(unitType: string, unitId: string, base: s
   }
 
   const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
-  // Unit types with no verifiable artifact always pass (e.g. replan-slice).
-  // For all other types, null means the parent directory is missing on disk
-  // — treat as stale completion state so the key gets evicted (#313).
-  if (!absPath) return unitType === "replan-slice";
+  // For unit types with no verifiable artifact (null path), the parent directory
+  // is missing on disk — treat as stale completion state so the key gets evicted (#313).
+  if (!absPath) return false;
   if (!existsSync(absPath)) return false;
 
   // plan-slice must produce a plan with actual task entries, not just a scaffold.

package/src/resources/extensions/gsd/auto-worktree.ts

@@ -6,7 +6,7 @@
  * manages create, enter, detect, and teardown for auto-mode worktrees.
  */
 
-import { existsSync, cpSync, readFileSync, writeFileSync, readdirSync, mkdirSync, realpathSync, utimesSync } from "node:fs";
+import { existsSync, cpSync, readFileSync, writeFileSync, readdirSync, mkdirSync, realpathSync, utimesSync, unlinkSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { copyWorktreeDb, reconcileWorktreeDb, isDbAvailable } from "./gsd-db.js";
 import { execSync, execFileSync } from "node:child_process";
@@ -312,7 +312,8 @@ export function createAutoWorktree(basePath: string, milestoneId: string): strin
 
 /**
  * Copy .gsd/ planning artifacts from source repo to a new worktree.
- * Copies milestones/, DECISIONS.md, REQUIREMENTS.md, PROJECT.md, QUEUE.md.
+ * Copies milestones/, DECISIONS.md, REQUIREMENTS.md, PROJECT.md, QUEUE.md,
+ * STATE.md, KNOWLEDGE.md, and OVERRIDES.md.
  * Skips runtime files (auto.lock, metrics.json, etc.) and the worktrees/ dir.
  * Best-effort — failures are non-fatal since auto-mode can recreate artifacts.
  */
@@ -330,7 +331,7 @@ function copyPlanningArtifacts(srcBase: string, wtPath: string): void {
   }
 
   // Copy top-level planning files
-  for (const file of ["DECISIONS.md", "REQUIREMENTS.md", "PROJECT.md", "QUEUE.md"]) {
+  for (const file of ["DECISIONS.md", "REQUIREMENTS.md", "PROJECT.md", "QUEUE.md", "STATE.md", "KNOWLEDGE.md", "OVERRIDES.md"]) {
     const src = join(srcGsd, file);
     if (existsSync(src)) {
       try {
@@ -559,6 +560,16 @@ export function mergeMilestoneToMain(
   //    when main is already checked out in the project-root worktree, #757)
   const currentBranchAtBase = nativeGetCurrentBranch(originalBasePath_);
   if (currentBranchAtBase !== mainBranch) {
+    // Remove untracked .gsd/ state files that may conflict with the branch
+    // being checked out. These are regenerated by doctor/rebuildState and
+    // are not meaningful in the main working tree — the worktree had the
+    // real state. Without this, `git checkout main` fails with
+    // "Your local changes would be overwritten" (#827).
+    const gsdStateFiles = ["STATE.md", "completed-units.json", "auto.lock"];
+    for (const f of gsdStateFiles) {
+      const p = join(originalBasePath_, ".gsd", f);
+      try { unlinkSync(p); } catch { /* non-fatal — file may not exist */ }
+    }
     nativeCheckoutBranch(originalBasePath_, mainBranch);
   }
 

package/src/resources/extensions/gsd/auto.ts

@@ -166,6 +166,41 @@ import { hasPendingCaptures, loadPendingCaptures, countPendingCaptures } from ".
 // auto-mode reads stale state from the project root and re-dispatches
 // already-completed units.
 
+/**
+ * Sync milestone artifacts from project root INTO worktree before deriveState.
+ * Covers the case where the LLM wrote artifacts to the main repo filesystem
+ * (e.g. via absolute paths) but the worktree has stale data. Also deletes
+ * gsd.db in the worktree so it rebuilds from fresh disk state (#853).
+ * Non-fatal — sync failure should never block dispatch.
+ */
+function syncProjectRootToWorktree(projectRoot: string, worktreePath: string, milestoneId: string | null): void {
+  if (!worktreePath || !projectRoot || worktreePath === projectRoot) return;
+  if (!milestoneId) return;
+
+  const prGsd = join(projectRoot, ".gsd");
+  const wtGsd = join(worktreePath, ".gsd");
+
+  // Copy milestone directory from project root to worktree if the project root
+  // has newer artifacts (e.g. slices that don't exist in the worktree yet)
+  try {
+    const srcMilestone = join(prGsd, "milestones", milestoneId);
+    const dstMilestone = join(wtGsd, "milestones", milestoneId);
+    if (existsSync(srcMilestone)) {
+      mkdirSync(dstMilestone, { recursive: true });
+      cpSync(srcMilestone, dstMilestone, { recursive: true, force: false });
+    }
+  } catch { /* non-fatal */ }
+
+  // Delete worktree gsd.db so it rebuilds from the freshly synced files.
+  // Stale DB rows are the root cause of the infinite skip loop (#853).
+  try {
+    const wtDb = join(wtGsd, "gsd.db");
+    if (existsSync(wtDb)) {
+      unlinkSync(wtDb);
+    }
+  } catch { /* non-fatal */ }
+}
+
 /**
  * Sync dispatch-critical .gsd/ state files from worktree to project root.
  * Only runs when inside an auto-worktree (worktreePath differs from projectRoot).
@@ -261,28 +296,30 @@ const MAX_CONSECUTIVE_SKIPS = 3;
 /** Persisted completed-unit keys — survives restarts. Loaded from .gsd/completed-units.json. */
 const completedKeySet = new Set<string>();
 
-/** Resource sync timestamp captured at auto-mode start. If the managed-resources
- *  manifest changes mid-session (e.g. /gsd:update or dev edit + copy-resources),
+/** Resource version captured at auto-mode start. If the managed-resources
+ *  manifest version changes mid-session (e.g. npm update -g gsd-pi),
  *  templates on disk may expect variables the in-memory code doesn't provide.
- *  Detect this and stop gracefully instead of crashing. */
-let resourceSyncedAtOnStart: number | null = null;
+ *  Detect this and stop gracefully instead of crashing.
+ *  Uses gsdVersion (semver) instead of syncedAt (timestamp) so that
+ *  launching a second session doesn't falsely trigger staleness (#804). */
+let resourceVersionOnStart: string | null = null;
 
-function readResourceSyncedAt(): number | null {
+function readResourceVersion(): string | null {
   const agentDir = process.env.GSD_CODING_AGENT_DIR || join(homedir(), ".gsd", "agent");
   const manifestPath = join(agentDir, "managed-resources.json");
   try {
     const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-    return typeof manifest?.syncedAt === "number" ? manifest.syncedAt : null;
+    return typeof manifest?.gsdVersion === "string" ? manifest.gsdVersion : null;
   } catch {
     return null;
   }
 }
 
 function checkResourcesStale(): string | null {
-  if (resourceSyncedAtOnStart === null) return null;
-  const current = readResourceSyncedAt();
+  if (resourceVersionOnStart === null) return null;
+  const current = readResourceVersion();
   if (current === null) return null;
-  if (current !== resourceSyncedAtOnStart) {
+  if (current !== resourceVersionOnStart) {
     return "GSD resources were updated since this session started. Restart gsd to load the new code.";
   }
   return null;
@@ -942,6 +979,11 @@ export async function startAuto(
     ctx.ui.notify(`Debug logging enabled → ${getDebugLogPath()}`, "info");
   }
 
+  // Invalidate all caches before initial state derivation to ensure we read
+  // fresh disk state. Without this, a stale cache from a prior session (e.g.
+  // after a discussion that wrote new artifacts) may cause deriveState to
+  // return pre-planning when the roadmap already exists (#800).
+  invalidateAllCaches();
   let state = await deriveState(base);
 
   // ── Stale worktree state recovery (#654) ─────────────────────────────────
@@ -1075,7 +1117,7 @@ export async function startAuto(
   restoreHookState(base);
   resetProactiveHealing();
   autoStartTime = Date.now();
-  resourceSyncedAtOnStart = readResourceSyncedAt();
+  resourceVersionOnStart = readResourceVersion();
   completedUnits = [];
   pendingQuickTasks = [];
   currentUnit = null;
@@ -1374,10 +1416,13 @@ export async function handleAgentEnd(
     // fixLevel:"task" ensures doctor only fixes task-level issues (e.g. marking
     // checkboxes). Slice/milestone completion transitions (summary stubs,
     // roadmap [x] marking) are left for the complete-slice dispatch unit.
+    // Exception: after complete-slice itself, use fixLevel:"all" so roadmap
+    // checkboxes get fixed even if complete-slice crashed (#839).
     try {
       const scopeParts = currentUnit.id.split("/").slice(0, 2);
       const doctorScope = scopeParts.join("/");
-      const report = await runGSDDoctor(basePath, { fix: true, scope: doctorScope, fixLevel: "task" });
+      const effectiveFixLevel = currentUnit.type === "complete-slice" ? "all" as const : "task" as const;
+      const report = await runGSDDoctor(basePath, { fix: true, scope: doctorScope, fixLevel: effectiveFixLevel });
       if (report.fixesApplied.length > 0) {
         ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
       }
@@ -2011,6 +2056,7 @@ async function dispatchNextUnit(
   pi: ExtensionAPI,
 ): Promise<void> {
   if (!active || !cmdCtx) {
+    debugLog(`dispatchNextUnit early return — active=${active}, cmdCtx=${!!cmdCtx}`);
     if (active && !cmdCtx) {
       ctx.ui.notify("Auto-mode session expired. Run /gsd auto to restart.", "info");
     }
@@ -2020,6 +2066,7 @@ async function dispatchNextUnit(
   // Reentrancy guard: allow recursive calls from skip paths (_skipDepth > 0)
   // but block concurrent external calls (watchdog, step wizard, etc.)
   if (_dispatching && _skipDepth === 0) {
+    debugLog("dispatchNextUnit reentrancy guard — another dispatch in progress, bailing");
     return; // Another dispatch is in progress — bail silently
   }
   _dispatching = true;
@@ -2055,7 +2102,7 @@ async function dispatchNextUnit(
   // Lightweight check for critical issues that would cause the next unit
   // to fail or corrupt state. Auto-heals what it can, blocks on the rest.
   try {
-    const healthGate = preDispatchHealthGate(basePath);
+    const healthGate = await preDispatchHealthGate(basePath);
     if (healthGate.fixesApplied.length > 0) {
       ctx.ui.notify(`Pre-dispatch: ${healthGate.fixesApplied.join(", ")}`, "info");
     }
@@ -2068,6 +2115,14 @@ async function dispatchNextUnit(
     // Non-fatal — health gate failure should never block dispatch
   }
 
+  // ── Sync project root artifacts into worktree (#853) ─────────────────
+  // When the LLM writes artifacts to the main repo filesystem instead of
+  // the worktree, the worktree's gsd.db becomes stale. Sync before
+  // deriveState to ensure the worktree has the latest artifacts.
+  if (originalBasePath && basePath !== originalBasePath && currentMilestoneId) {
+    syncProjectRootToWorktree(originalBasePath, basePath, currentMilestoneId);
+  }
+
   const stopDeriveTimer = debugTime("derive-state");
   let state = await deriveState(basePath);
   stopDeriveTimer({
@@ -3751,6 +3806,20 @@ export async function dispatchDirectPhase(
           ctx.ui.notify("Cannot dispatch research-slice: no active slice.", "warning");
           return;
         }
+
+        // When require_slice_discussion is enabled, pause auto-mode before
+        // each new slice so the user can discuss requirements first (#789).
+        const sliceContextFile = resolveSliceFile(base, mid, sid, "CONTEXT");
+        const requireDiscussion = loadEffectiveGSDPreferences()?.preferences?.phases?.require_slice_discussion;
+        if (requireDiscussion && !sliceContextFile) {
+          ctx.ui.notify(
+            `Slice ${sid} requires discussion before planning. Run /gsd discuss to discuss this slice, then /gsd auto to resume.`,
+            "info",
+          );
+          await pauseAuto(ctx, pi);
+          return;
+        }
+
         unitType = "research-slice";
         unitId = `${mid}/${sid}`;
         prompt = await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, base);

package/src/resources/extensions/gsd/doctor-proactive.ts

@@ -19,6 +19,7 @@ import { join } from "node:path";
 import { gsdRoot, resolveGsdRootFile } from "./paths.js";
 import { readCrashLock, isLockProcessAlive, clearLock } from "./crash-recovery.js";
 import { abortAndReset } from "./git-self-heal.js";
+import { rebuildState } from "./doctor.js";
 
 // ── Health Score Tracking ──────────────────────────────────────────────────
 
@@ -131,7 +132,7 @@ export interface PreDispatchHealthResult {
  *
  * Returns { proceed: true } if dispatch should continue.
  */
-export function preDispatchHealthGate(basePath: string): PreDispatchHealthResult {
+export async function preDispatchHealthGate(basePath: string): Promise<PreDispatchHealthResult> {
   const issues: string[] = [];
   const fixesApplied: string[] = [];
 
@@ -172,17 +173,17 @@ export function preDispatchHealthGate(basePath: string): PreDispatchHealthResult
   }
 
   // ── STATE.md existence check ──
-  // If STATE.md is missing, deriveState will still work but the LLM
-  // may get confused. Rebuild it silently.
+  // If STATE.md is missing, rebuild it now so the next unit has accurate
+  // context. Non-blocking — if the rebuild throws, dispatch continues anyway.
   try {
     const stateFile = resolveGsdRootFile(basePath, "STATE");
     const milestonesDir = join(gsdRoot(basePath), "milestones");
     if (existsSync(milestonesDir) && !existsSync(stateFile)) {
-      issues.push("STATE.md missing — will rebuild after this unit");
-      // Don't block dispatch — rebuilding happens in post-hook
+      await rebuildState(basePath);
+      fixesApplied.push("rebuilt missing STATE.md before dispatch");
     }
   } catch {
-    // Non-fatal
+    // Non-fatal — dispatch continues without STATE.md if rebuild fails
   }
 
   // If we had critical issues that couldn't be auto-healed, block dispatch

package/src/resources/extensions/gsd/doctor.ts

@@ -1144,8 +1144,31 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
             unitId: taskUnitId,
             message: `Task ${task.id} is marked done but summary is missing`,
             file: relTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY"),
-            fixable: false,
+            fixable: true,
           });
+          // Write a stub summary so validate-milestone can proceed.
+          // This prevents infinite skip loops when tasks are marked done
+          // without summaries (#820).
+          if (shouldFix("task_done_missing_summary")) {
+            const stubPath = join(
+              basePath, ".gsd", "milestones", milestoneId, "slices", slice.id, "tasks",
+              `${task.id}-SUMMARY.md`,
+            );
+            const stubContent = [
+              `---`,
+              `status: done`,
+              `result: unknown`,
+              `doctor_generated: true`,
+              `---`,
+              ``,
+              `# ${task.id}: ${task.title || "Unknown"}`,
+              ``,
+              `Summary stub generated by \`/gsd doctor\` — task was marked done but no summary existed.`,
+              ``,
+            ].join("\n");
+            await saveFile(stubPath, stubContent);
+            fixesApplied.push(`created stub summary for ${taskUnitId}`);
+          }
         }
 
         if (!task.done && hasSummary) {

package/src/resources/extensions/gsd/files.ts

@@ -5,6 +5,7 @@
 
 import { promises as fs } from 'node:fs';
 import { dirname, resolve } from 'node:path';
+import { randomBytes } from 'node:crypto';
 import { resolveMilestoneFile, relMilestoneFile, resolveGsdRootFile } from './paths.js';
 import { milestoneIdSort, findMilestoneIds } from './guided-flow.js';
 
@@ -705,9 +706,19 @@ export async function saveFile(path: string, content: string): Promise<void> {
   const dir = dirname(path);
   await fs.mkdir(dir, { recursive: true });
 
-  const tmpPath = path + '.tmp';
+  // Use a unique temp path per call to avoid collisions when parallel
+  // tool calls target the same file (e.g. concurrent gsd_save_decision).
+  // rename() is atomic on POSIX, so last-writer-wins is correct for
+  // regenerate-from-DB writes.
+  const tmpPath = path + `.tmp.${randomBytes(4).toString("hex")}`;
   await fs.writeFile(tmpPath, content, 'utf-8');
-  await fs.rename(tmpPath, path);
+  try {
+    await fs.rename(tmpPath, path);
+  } catch (err) {
+    // Clean up orphaned temp file on rename failure
+    await fs.unlink(tmpPath).catch(() => {});
+    throw err;
+  }
 }
 
 export function parseRequirementCounts(content: string | null): RequirementCounts {

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

@@ -636,9 +636,11 @@ async function showQueueAdd(
   const existingContext = await buildExistingMilestonesContext(basePath, milestoneIds, state);
 
   // ── Determine next milestone ID ─────────────────────────────────────
+  // Note: the LLM will use the gsd_generate_milestone_id tool to get IDs
+  // at creation time, but we still mention the next ID in the preamble
+  // for context about where the sequence is.
   const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
   const nextId = nextMilestoneId(milestoneIds, uniqueEnabled);
-  const nextIdPlus1 = nextMilestoneId([...milestoneIds, nextId], uniqueEnabled);
 
   // ── Build preamble ──────────────────────────────────────────────────
   const activePart = state.activeMilestone
@@ -659,8 +661,6 @@ async function showQueueAdd(
   const queueInlinedTemplates = inlineTemplate("context", "Context");
   const prompt = loadPrompt("queue", {
     preamble,
-    nextId,
-    nextIdPlus1,
     existingMilestonesContext: existingContext,
     inlinedTemplates: queueInlinedTemplates,
     commitInstruction: buildDocsCommitInstruction("docs: queue <milestone list>"),
@@ -959,12 +959,22 @@ export async function showDiscuss(
 
   // Loop: show picker, dispatch discuss, repeat until "not_yet"
   while (true) {
-    const actions = pendingSlices.map((s, i) => ({
-      id: s.id,
-      label: `${s.id}: ${s.title}`,
-      description: state.activeSlice?.id === s.id ? "active slice" : "upcoming",
-      recommended: i === 0,
-    }));
+    const actions = pendingSlices.map((s, i) => {
+      // Check if this slice has already been discussed (CONTEXT file exists)
+      const contextFile = resolveSliceFile(basePath, mid, s.id, "CONTEXT");
+      const discussed = !!contextFile;
+      const statusParts: string[] = [];
+      if (state.activeSlice?.id === s.id) statusParts.push("active");
+      else statusParts.push("upcoming");
+      statusParts.push(discussed ? "discussed ✓" : "not discussed");
+
+      return {
+        id: s.id,
+        label: `${s.id}: ${s.title}`,
+        description: statusParts.join(" · "),
+        recommended: i === 0,
+      };
+    });
 
     const choice = await showNextAction(ctx, {
       title: "GSD — Discuss a slice",