gsd-pi 2.24.0 → 2.26.0

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -1165,6 +1165,34 @@ export class InteractiveMode {
 		return registeredTool?.definition;
 	}
 
+	/**
+	 * Format web search result content for display in the TUI.
+	 */
+	private formatWebSearchResult(content: unknown): string {
+		if (!content) return "Web search completed";
+
+		// Error result
+		if (typeof content === "object" && "type" in (content as any) && (content as any).type === "web_search_tool_result_error") {
+			const error = content as any;
+			return `Search error: ${error.error_code || "unknown"}`;
+		}
+
+		// Array of search results
+		if (Array.isArray(content)) {
+			const results = content.filter((r: any) => r.type === "web_search_result");
+			if (results.length === 0) return "No results found";
+			return results
+				.map((r: any) => {
+					const title = r.title || "Untitled";
+					const url = r.url || "";
+					return `${title}\n  ${url}`;
+				})
+				.join("\n");
+		}
+
+		return "Web search completed";
+	}
+
 	/**
 	 * Set up keyboard shortcuts registered by extensions.
 	 */
@@ -2035,6 +2063,12 @@ export class InteractiveMode {
 				this.handleThinkingCommand(arg);
 				return;
 			}
+			if (text === "/edit-mode" || text.startsWith("/edit-mode ")) {
+				const arg = text.startsWith("/edit-mode ") ? text.slice(11).trim() : undefined;
+				this.editor.setText("");
+				this.handleEditModeCommand(arg);
+				return;
+			}
 			if (text === "/debug") {
 				this.handleDebugCommand();
 				this.editor.setText("");
@@ -2201,6 +2235,35 @@ export class InteractiveMode {
 									component.updateArgs(content.arguments);
 								}
 							}
+						} else if (content.type === "serverToolUse") {
+							// Server-side tool (e.g., native web search) — show as pending tool execution
+							if (!this.pendingTools.has(content.id)) {
+								const component = new ToolExecutionComponent(
+									content.name,
+									content.input ?? {},
+									{
+										showImages: this.settingsManager.getShowImages(),
+									},
+									undefined,
+									this.ui,
+								);
+								component.setExpanded(this.toolOutputExpanded);
+								this.chatContainer.addChild(component);
+								this.pendingTools.set(content.id, component);
+							}
+						} else if (content.type === "webSearchResult") {
+							// Server-side tool result — resolve the pending server tool execution
+							const component = this.pendingTools.get(content.toolUseId);
+							if (component) {
+								const searchContent = content.content;
+								const isError = searchContent && typeof searchContent === "object" && "type" in (searchContent as any) && (searchContent as any).type === "web_search_tool_result_error";
+								const resultText = this.formatWebSearchResult(searchContent);
+								component.updateResult({
+									content: [{ type: "text", text: resultText }],
+									isError: !!isError,
+								});
+								this.pendingTools.delete(content.toolUseId);
+							}
 						}
 					}
 					this.ui.requestRender();
@@ -2594,6 +2657,33 @@ export class InteractiveMode {
 						} else {
 							this.pendingTools.set(content.id, component);
 						}
+					} else if (content.type === "serverToolUse") {
+						// Server-side tool (e.g., native web search)
+						const component = new ToolExecutionComponent(
+							content.name,
+							content.input ?? {},
+							{ showImages: this.settingsManager.getShowImages() },
+							undefined,
+							this.ui,
+						);
+						component.setExpanded(this.toolOutputExpanded);
+						this.chatContainer.addChild(component);
+						// Find matching webSearchResult in this message's content
+						const resultBlock = message.content.find(
+							(c) => c.type === "webSearchResult" && c.toolUseId === content.id,
+						);
+						if (resultBlock && resultBlock.type === "webSearchResult") {
+							const searchContent = resultBlock.content;
+							const isError = searchContent && typeof searchContent === "object" && "type" in (searchContent as any) && (searchContent as any).type === "web_search_tool_result_error";
+							const resultText = this.formatWebSearchResult(searchContent);
+							component.updateResult({
+								content: [{ type: "text", text: resultText }],
+								isError: !!isError,
+							});
+						} else {
+							// No result yet (aborted stream?) — show as pending
+							this.pendingTools.set(content.id, component);
+						}
 					}
 				}
 			} else if (message.role === "toolResult") {
@@ -2807,6 +2897,27 @@ export class InteractiveMode {
 		this.showThinkingSelector();
 	}
 
+	private handleEditModeCommand(arg?: string): void {
+		const modes = ["standard", "hashline"] as const;
+
+		if (arg) {
+			const mode = arg.toLowerCase();
+			if (!modes.includes(mode as typeof modes[number])) {
+				this.showStatus(`Invalid edit mode "${arg}". Available: standard, hashline`);
+				return;
+			}
+			this.session.setEditMode(mode as "standard" | "hashline");
+			this.showStatus(`Edit mode: ${mode}${mode === "hashline" ? " (LINE#ID anchored edits)" : " (text-match edits)"}`);
+			return;
+		}
+
+		// Toggle
+		const current = this.session.editMode;
+		const next = current === "standard" ? "hashline" : "standard";
+		this.session.setEditMode(next);
+		this.showStatus(`Edit mode: ${next}${next === "hashline" ? " (LINE#ID anchored edits)" : " (text-match edits)"}`);
+	}
+
 	private showThinkingSelector(): void {
 		const availableLevels = this.session.getAvailableThinkingLevels();
 		this.showSelector((done) => {
@@ -3799,12 +3910,16 @@ export class InteractiveMode {
 			const selector = new OAuthSelectorComponent(
 				mode,
 				this.session.modelRegistry.authStorage,
-				async (providerId: string) => {
+				(providerId: string) => {
 					done();
 
-					if (mode === "login") {
-						await this.showLoginDialog(providerId);
-					} else {
+					// OAuthSelectorComponent calls this synchronously (no await),
+					// so we must catch async errors here to prevent unhandled rejections
+					// when the user cancels the login dialog (#821).
+					const handleAsync = async () => {
+						if (mode === "login") {
+							await this.showLoginDialog(providerId);
+						} else {
 						// Logout flow
 						const providerInfo = this.session.modelRegistry.authStorage
 							.getOAuthProviders()
@@ -3835,6 +3950,11 @@ export class InteractiveMode {
 							this.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
 						}
 					}
+					};
+					handleAsync().catch(() => {
+						// Swallow — showLoginDialog already handles its own errors.
+						// This prevents unhandled rejections when login is cancelled.
+					});
 				},
 				() => {
 					done();

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/GSD-WORKFLOW.md

@@ -565,25 +565,28 @@ One commit per slice. Individually revertable. Reads like a changelog.
 
 ```
 gsd/M001/S01:
-  test(S01): round-trip tests passing
+  test(S01/T03): round-trip tests passing
   feat(S01/T03): file writer with round-trip fidelity
-  chore(S01/T03): auto-commit after task
   feat(S01/T02): markdown parser for plan files
-  chore(S01/T02): auto-commit after task
   feat(S01/T01): core types and interfaces
-  chore(S01/T01): auto-commit after task
+  docs(S01): add slice plan
 ```
 
 ### Commit Conventions
 
 | When | Format | Example |
 |------|--------|---------|
-| Auto-commit (dirty state) | `chore(S01/T02): auto-commit after task` | Automatic save of work in progress |
-| After task verified | `feat(S01/T02): <what was built>` | The real work |
-| Plan/docs committed | `docs(S01): add slice plan` | Bundled with first task |
-| Slice squash to main | `type(M001/S01): <slice title>` | Type inferred from title (`feat`, `fix`, `docs`, etc.) |
+| Task completed | `{type}(S01/T02): <one-liner from summary>` | Type inferred from title (`feat`, `fix`, `test`, etc.) |
+| Plan/docs committed | `docs(S01): add slice plan` | Planning artifacts |
+| Slice squash to main | `type(M001/S01): <slice title>` | Type inferred from title |
+| State rebuild | `chore(S01/T02): auto-commit after state-rebuild` | Bookkeeping only |
 
-Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `chore`
+The system reads the task summary after execution and builds a meaningful commit message:
+- **Subject**: `{type}({sliceId}/{taskId}): {one-liner}` — the one-liner from the summary frontmatter
+- **Type**: Inferred from the task title and one-liner (`feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`)
+- **Body**: Key files from the summary frontmatter (up to 8 files listed)
+
+Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`
 
 ### Squash Merge Message
 

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/bg-shell/overlay.ts

@@ -328,12 +328,9 @@ export class BgManagerOverlay {
 		return this.box(inner, width);
 	}
 
-	private renderOutput(width: number): string[] {
+	private processStatusHeader(p: typeof this.viewingProcess, activeTab: "output" | "events"): { statusIcon: string; headerLine: string } {
 		const th = this.theme;
-		const p = this.viewingProcess;
-		if (!p) return [""];
-		const inner: string[] = [];
-
+		if (!p) return { statusIcon: "", headerLine: "" };
 		const statusIcon = p.alive
 			? (p.status === "ready" ? th.fg("success", "●")
 				: p.status === "error" ? th.fg("error", "●")
@@ -343,9 +340,21 @@ export class BgManagerOverlay {
 		const uptime = th.fg("dim", formatUptime(Date.now() - p.startedAt));
 		const typeTag = th.fg("dim", `[${p.processType}]`);
 		const portInfo = p.ports.length > 0 ? th.fg("dim", ` :${p.ports.join(",")}`) : "";
-		const tabIndicator = th.fg("accent", "[Output]") + " " + th.fg("dim", "Events");
+		const tabIndicator = activeTab === "output"
+			? th.fg("accent", "[Output]") + " " + th.fg("dim", "Events")
+			: th.fg("dim", "Output") + " " + th.fg("accent", "[Events]");
+		const headerLine = `${statusIcon} ${name} ${typeTag} ${uptime}${portInfo}  ${tabIndicator}`;
+		return { statusIcon, headerLine };
+	}
+
+	private renderOutput(width: number): string[] {
+		const th = this.theme;
+		const p = this.viewingProcess;
+		if (!p) return [""];
+		const inner: string[] = [];
 
-		inner.push(`${statusIcon} ${name} ${typeTag} ${uptime}${portInfo}  ${tabIndicator}`);
+		const { headerLine } = this.processStatusHeader(p, "output");
+		inner.push(headerLine);
 		inner.push("");
 
 		// Unified buffer is already chronologically interleaved
@@ -384,16 +393,8 @@ export class BgManagerOverlay {
 		if (!p) return [""];
 		const inner: string[] = [];
 
-		const statusIcon = p.alive
-			? (p.status === "ready" ? th.fg("success", "●")
-				: p.status === "error" ? th.fg("error", "●")
-				: th.fg("warning", "●"))
-			: th.fg("dim", "○");
-		const name = th.fg("muted", p.label);
-		const uptime = th.fg("dim", formatUptime(Date.now() - p.startedAt));
-		const tabIndicator = th.fg("dim", "Output") + " " + th.fg("accent", "[Events]");
-
-		inner.push(`${statusIcon} ${name} ${uptime}  ${tabIndicator}`);
+		const { headerLine } = this.processStatusHeader(p, "events");
+		inner.push(headerLine);
 		inner.push("");
 
 		if (p.events.length === 0) {

package/src/resources/extensions/get-secrets-from-user.ts

@@ -369,32 +369,14 @@ async function applySecrets(
 		}
 	}
 
-	if (destination === "vercel" && opts.exec) {
+	if ((destination === "vercel" || destination === "convex") && opts.exec) {
 		const env = opts.environment ?? "development";
 		for (const { key, value } of provided) {
+			const cmd = destination === "vercel"
+				? `printf %s ${shellEscapeSingle(value)} | vercel env add ${key} ${env}`
+				: `npx convex env set ${key} ${shellEscapeSingle(value)}`;
 			try {
-				const result = await opts.exec("sh", [
-					"-c",
-					`printf %s ${shellEscapeSingle(value)} | vercel env add ${key} ${env}`,
-				]);
-				if (result.code !== 0) {
-					errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
-				} else {
-					applied.push(key);
-				}
-			} catch (err: any) {
-				errors.push(`${key}: ${err.message}`);
-			}
-		}
-	}
-
-	if (destination === "convex" && opts.exec) {
-		for (const { key, value } of provided) {
-			try {
-				const result = await opts.exec("sh", [
-					"-c",
-					`npx convex env set ${key} ${shellEscapeSingle(value)}`,
-				]);
+				const result = await opts.exec("sh", ["-c", cmd]);
 				if (result.code !== 0) {
 					errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
 				} else {

package/src/resources/extensions/gsd/activity-log.ts

@@ -103,10 +103,10 @@ export function saveActivityLog(
   basePath: string,
   unitType: string,
   unitId: string,
-): void {
+): string | null {
   try {
     const entries = ctx.sessionManager.getEntries();
-    if (!entries || entries.length === 0) return;
+    if (!entries || entries.length === 0) return null;
 
     const activityDir = join(gsdRoot(basePath), "activity");
     mkdirSync(activityDir, { recursive: true });
@@ -116,7 +116,7 @@ export function saveActivityLog(
     const unitKey = `${unitType}\0${safeUnitId}`;
     // Use lightweight fingerprint instead of serializing all entries (#611)
     const key = snapshotKey(unitType, safeUnitId, entries);
-    if (state.lastSnapshotKeyByUnit.get(unitKey) === key) return;
+    if (state.lastSnapshotKeyByUnit.get(unitKey) === key) return null;
 
     const filePath = nextActivityFilePath(activityDir, state, unitType, safeUnitId);
     // Stream entries to disk line-by-line instead of building one massive string (#611).
@@ -131,9 +131,11 @@ export function saveActivityLog(
     }
     state.nextSeq += 1;
     state.lastSnapshotKeyByUnit.set(unitKey, key);
+    return filePath;
   } catch (e) {
     // Don't let logging failures break auto-mode
     void e;
+    return null;
   }
 }
 

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

@@ -637,6 +637,12 @@ export async function buildPlanSlicePrompt(
   const executorContextConstraints = formatExecutorConstraints();
 
   const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
+  const prefs = loadEffectiveGSDPreferences();
+  const commitDocsEnabled = prefs?.preferences?.git?.commit_docs !== false;
+  const commitInstruction = commitDocsEnabled
+    ? `Commit: \`docs(${sid}): add slice plan\``
+    : "Do not commit — planning docs are not tracked in git for this project.";
+
   return loadPrompt("plan-slice", {
     workingDirectory: base,
     milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
@@ -647,6 +653,7 @@ export async function buildPlanSlicePrompt(
     inlinedContext,
     dependencySummaries: depContent,
     executorContextConstraints,
+    commitInstruction,
   });
 }
 
@@ -1071,6 +1078,12 @@ export async function buildReassessRoadmapPrompt(
     // Non-fatal — captures module may not be available
   }
 
+  const reassessPrefs = loadEffectiveGSDPreferences();
+  const reassessCommitDocsEnabled = reassessPrefs?.preferences?.git?.commit_docs !== false;
+  const reassessCommitInstruction = reassessCommitDocsEnabled
+    ? `Commit: \`docs(${mid}): reassess roadmap after ${completedSliceId}\``
+    : "Do not commit — planning docs are not tracked in git for this project.";
+
   return loadPrompt("reassess-roadmap", {
     workingDirectory: base,
     milestoneId: mid,
@@ -1081,6 +1094,7 @@ export async function buildReassessRoadmapPrompt(
     assessmentPath,
     inlinedContext,
     deferredCaptures,
+    commitInstruction: reassessCommitInstruction,
   });
 }
 

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.