gsd-pi 2.67.0-dev.5399650 → 2.67.0-dev.6fc2289

package/src/resources/extensions/claude-code-cli/tests/stream-adapter.test.ts

@@ -4,15 +4,15 @@ import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "nod
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import {
+	makeStreamExhaustedErrorMessage,
 	buildPromptFromContext,
-	buildFinalClaudeCodeContent,
 	buildSdkOptions,
+	extractToolResultsFromSdkUserMessage,
 	getClaudeLookupCommand,
-	makeStreamExhaustedErrorMessage,
 	parseClaudeLookupOutput,
-	sanitizeClaudeCodeStreamingEvent,
 } from "../stream-adapter.ts";
-import type { AssistantMessage, Context, Message } from "@gsd/pi-ai";
+import type { Context, Message } from "@gsd/pi-ai";
+import type { SDKUserMessage } from "../sdk-types.ts";
 
 // ---------------------------------------------------------------------------
 // Existing tests — exhausted stream fallback (#2575)
@@ -108,6 +108,65 @@ describe("stream-adapter — full context prompt (#2859)", () => {
 	});
 });
 
+describe("stream-adapter — Claude Code external tool results", () => {
+	test("extractToolResultsFromSdkUserMessage maps tool_result content to tool payloads", () => {
+		const message: SDKUserMessage = {
+			type: "user",
+			session_id: "sess-1",
+			parent_tool_use_id: "tool-bash-1",
+			message: {
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool-bash-1",
+						content: "line 1\nline 2",
+						is_error: false,
+					},
+				],
+			},
+		};
+
+		const results = extractToolResultsFromSdkUserMessage(message);
+		assert.deepEqual(results, [
+			{
+				toolUseId: "tool-bash-1",
+				result: {
+					content: [{ type: "text", text: "line 1\nline 2" }],
+					details: {},
+					isError: false,
+				},
+			},
+		]);
+	});
+
+	test("extractToolResultsFromSdkUserMessage falls back to tool_use_result", () => {
+		const message: SDKUserMessage = {
+			type: "user",
+			session_id: "sess-1",
+			parent_tool_use_id: "tool-read-1",
+			message: { role: "user", content: [] },
+			tool_use_result: {
+				tool_use_id: "tool-read-1",
+				content: "file contents",
+				is_error: true,
+			},
+		};
+
+		const results = extractToolResultsFromSdkUserMessage(message);
+		assert.deepEqual(results, [
+			{
+				toolUseId: "tool-read-1",
+				result: {
+					content: [{ type: "text", text: "file contents" }],
+					details: {},
+					isError: true,
+				},
+			},
+		]);
+	});
+});
+
 describe("stream-adapter — session persistence (#2859)", () => {
 	test("buildSdkOptions enables persistSession by default", () => {
 		const options = buildSdkOptions("claude-sonnet-4-20250514", "test prompt");
@@ -149,18 +208,15 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			process.env.GSD_WORKFLOW_MCP_CWD = "/tmp/project";
 
 			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
-			assert.deepEqual(options.mcpServers, {
-				"gsd-workflow": {
-					command: "node",
-					args: ["packages/mcp-server/dist/cli.js"],
-					env: {
-						GSD_CLI_PATH: "/tmp/gsd",
-						GSD_PERSIST_WRITE_GATE_STATE: "1",
-						GSD_WORKFLOW_PROJECT_ROOT: "/tmp/project",
-					},
-					cwd: "/tmp/project",
-				},
-			});
+			const mcpServers = options.mcpServers as Record<string, any>;
+			assert.ok(mcpServers?.["gsd-workflow"], "expected gsd-workflow server config");
+			const srv = mcpServers["gsd-workflow"];
+			assert.equal(srv.command, "node");
+			assert.deepEqual(srv.args, ["packages/mcp-server/dist/cli.js"]);
+			assert.equal(srv.cwd, "/tmp/project");
+			assert.equal(srv.env.GSD_CLI_PATH, "/tmp/gsd");
+			assert.equal(srv.env.GSD_PERSIST_WRITE_GATE_STATE, "1");
+			assert.equal(srv.env.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
 		} finally {
 			process.env.GSD_WORKFLOW_MCP_COMMAND = prev.GSD_WORKFLOW_MCP_COMMAND;
 			process.env.GSD_WORKFLOW_MCP_NAME = prev.GSD_WORKFLOW_MCP_NAME;
@@ -170,7 +226,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		}
 	});
 
-	test("buildSdkOptions omits workflow MCP server config when env is unset", () => {
+	test("buildSdkOptions auto-discovers bundled MCP server even without env hints", () => {
 		const prev = {
 			GSD_WORKFLOW_MCP_COMMAND: process.env.GSD_WORKFLOW_MCP_COMMAND,
 			GSD_WORKFLOW_MCP_NAME: process.env.GSD_WORKFLOW_MCP_NAME,
@@ -190,7 +246,13 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			process.chdir(emptyDir);
 			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
 			process.chdir(originalCwd);
-			assert.equal((options as any).mcpServers, undefined);
+			// The bundled CLI may or may not be discoverable depending on
+			// whether the build output exists relative to import.meta.url.
+			// Either outcome is valid — the key invariant is no crash.
+			const mcpServers = (options as any).mcpServers;
+			if (mcpServers) {
+				assert.ok(mcpServers["gsd-workflow"], "if present, must be gsd-workflow");
+			}
 			rmSync(emptyDir, { recursive: true, force: true });
 		} finally {
 			process.env.GSD_WORKFLOW_MCP_COMMAND = prev.GSD_WORKFLOW_MCP_COMMAND;
@@ -227,18 +289,15 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			const resolvedRepoDir = realpathSync(repoDir);
 
 			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
-			assert.deepEqual(options.mcpServers, {
-				"gsd-workflow": {
-					command: process.execPath,
-					args: [realpathSync(resolve(repoDir, "packages", "mcp-server", "dist", "cli.js"))],
-					env: {
-						GSD_CLI_PATH: "/tmp/gsd",
-						GSD_PERSIST_WRITE_GATE_STATE: "1",
-						GSD_WORKFLOW_PROJECT_ROOT: resolvedRepoDir,
-					},
-					cwd: resolvedRepoDir,
-				},
-			});
+			const mcpServers = options.mcpServers as Record<string, any>;
+			assert.ok(mcpServers?.["gsd-workflow"], "expected gsd-workflow server config");
+			const srv = mcpServers["gsd-workflow"];
+			assert.equal(srv.command, process.execPath);
+			assert.deepEqual(srv.args, [realpathSync(resolve(repoDir, "packages", "mcp-server", "dist", "cli.js"))]);
+			assert.equal(srv.cwd, resolvedRepoDir);
+			assert.equal(srv.env.GSD_CLI_PATH, "/tmp/gsd");
+			assert.equal(srv.env.GSD_PERSIST_WRITE_GATE_STATE, "1");
+			assert.equal(srv.env.GSD_WORKFLOW_PROJECT_ROOT, resolvedRepoDir);
 		} finally {
 			process.chdir(originalCwd);
 			rmSync(repoDir, { recursive: true, force: true });
@@ -252,92 +311,6 @@ describe("stream-adapter — session persistence (#2859)", () => {
 	});
 });
 
-describe("stream-adapter — final content filtering (#3861)", () => {
-	test("buildFinalClaudeCodeContent strips intermediate tool calls from the final assistant message", () => {
-		const finalContent = buildFinalClaudeCodeContent(
-			[
-				{ type: "toolCall", id: "tc_1", name: "Read", arguments: {} },
-				{ type: "thinking", thinking: "Planning next step" },
-				{ type: "text", text: "Done." },
-			] as any,
-			"",
-			"",
-		);
-
-		assert.deepEqual(finalContent, [
-			{ type: "thinking", thinking: "Planning next step" },
-			{ type: "text", text: "Done." },
-		]);
-	});
-
-	test("buildFinalClaudeCodeContent falls back to cached text when the final turn only had tool calls", () => {
-		const finalContent = buildFinalClaudeCodeContent(
-			[
-				{ type: "toolCall", id: "tc_2", name: "Edit", arguments: { file_path: "app.ts" } },
-			] as any,
-			"",
-			"User-facing answer",
-		);
-
-		assert.deepEqual(finalContent, [{ type: "text", text: "User-facing answer" }]);
-	});
-});
-
-describe("stream-adapter — streaming content filtering follow-up (#3867)", () => {
-	function makePartial(content: AssistantMessage["content"]): AssistantMessage {
-		return {
-			role: "assistant",
-			content,
-			api: "anthropic-messages",
-			provider: "claude-code",
-			model: "claude-sonnet-4-20250514",
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-			},
-			stopReason: "stop",
-			timestamp: Date.now(),
-		};
-	}
-
-	test("sanitizeClaudeCodeStreamingEvent strips tool calls from streamed partials and remaps contentIndex", () => {
-		const event = sanitizeClaudeCodeStreamingEvent({
-			type: "text_delta",
-			contentIndex: 2,
-			delta: "Done.",
-			partial: makePartial([
-				{ type: "toolCall", id: "tc_1", name: "ToolSearch", arguments: {} },
-				{ type: "thinking", thinking: "Planning next step" },
-				{ type: "text", text: "Done." },
-			] as any),
-		});
-
-		assert.ok(event, "text events should still be forwarded");
-		assert.equal(event!.type, "text_delta");
-		assert.equal((event! as any).contentIndex, 1);
-		assert.deepEqual((event! as any).partial.content, [
-			{ type: "thinking", thinking: "Planning next step" },
-			{ type: "text", text: "Done." },
-		]);
-	});
-
-	test("sanitizeClaudeCodeStreamingEvent suppresses internal tool streaming events entirely", () => {
-		const event = sanitizeClaudeCodeStreamingEvent({
-			type: "toolcall_start",
-			contentIndex: 0,
-			partial: makePartial([
-				{ type: "toolCall", id: "tc_1", name: "Bash", arguments: {} },
-			] as any),
-		});
-
-		assert.equal(event, null);
-	});
-});
-
 describe("stream-adapter — Windows Claude path lookup (#3770)", () => {
 	test("getClaudeLookupCommand uses where on Windows", () => {
 		assert.equal(getClaudeLookupCommand("win32"), "where claude");

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

@@ -119,6 +119,8 @@ export class AutoSession {
   pendingVerificationRetry: PendingVerificationRetry | null = null;
   readonly verificationRetryCount = new Map<string, number>();
   pausedSessionFile: string | null = null;
+  pausedUnitType: string | null = null;
+  pausedUnitId: string | null = null;
   resourceVersionOnStart: string | null = null;
   lastStateRebuildAt = 0;
 
@@ -223,6 +225,8 @@ export class AutoSession {
     this.pendingVerificationRetry = null;
     this.verificationRetryCount.clear();
     this.pausedSessionFile = null;
+    this.pausedUnitType = null;
+    this.pausedUnitId = null;
     this.resourceVersionOnStart = null;
     this.lastStateRebuildAt = 0;
 

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

@@ -178,7 +178,7 @@ export function incrementUatCount(basePath: string, mid: string, sid: string): n
 export function isVerificationNotApplicable(value: string): boolean {
   const v = (value ?? "").toLowerCase().trim().replace(/[.\s]+$/, "");
   if (!v || v === "none") return true;
-  return /^(?:none[\s._-]*(?:required|needed|planned)?|n\/?a|not[\s._-]+(?:applicable|required|needed|provided)|no[\s._-]+operational[\s\S]*)$/i.test(v);
+  return /^(?:none(?:[\s._\u2014-]+[\s\S]*)?|n\/?a|not[\s._-]+(?:applicable|required|needed|provided)|no[\s._-]+operational[\s\S]*)$/i.test(v);
 }
 
 // ─── Rules ────────────────────────────────────────────────────────────────

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

@@ -15,6 +15,7 @@ import type {
 } from "@gsd/pi-coding-agent";
 import { deriveState } from "./state.js";
 import { loadFile, getManifestStatus } from "./files.js";
+import type { InterruptedSessionAssessment } from "./interrupted-session.js";
 import {
   loadEffectiveGSDPreferences,
   resolveSkillDiscoveryMode,
@@ -23,16 +24,9 @@ import {
 import { ensureGsdSymlink, isInheritedRepo, validateProjectId } from "./repo-identity.js";
 import { migrateToExternalState, recoverFailedMigration } from "./migrate-external.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
-import { gsdRoot, resolveMilestoneFile, milestonesDir } from "./paths.js";
+import { gsdRoot, resolveMilestoneFile } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
-import { synthesizeCrashRecovery } from "./session-forensics.js";
-import {
-  writeLock,
-  clearLock,
-  readCrashLock,
-  formatCrashInfo,
-  isLockProcessAlive,
-} from "./crash-recovery.js";
+import { writeLock, clearLock } from "./crash-recovery.js";
 import {
   acquireSessionLock,
   releaseSessionLock,
@@ -248,6 +242,7 @@ export async function bootstrapAutoSession(
   verboseMode: boolean,
   requestedStepMode: boolean,
   deps: BootstrapDeps,
+  interrupted: InterruptedSessionAssessment,
 ): Promise<boolean> {
   const {
     shouldUseWorktreeIsolation,
@@ -340,57 +335,27 @@ export async function bootstrapAutoSession(
       }
     }
 
+    if (ctx.model?.provider === "claude-code") {
+      try {
+        const { ensureProjectWorkflowMcpConfig } = await import("./mcp-project-config.js");
+        const result = ensureProjectWorkflowMcpConfig(base);
+        if (result.status !== "unchanged") {
+          ctx.ui.notify(`Claude Code MCP prepared at ${result.configPath}`, "info");
+        }
+      } catch (err) {
+        ctx.ui.notify(
+          `Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}`,
+          "warning",
+        );
+      }
+    }
+
     // Initialize GitServiceImpl
     s.gitService = new GitServiceImpl(
       s.basePath,
       loadEffectiveGSDPreferences()?.preferences?.git ?? {},
     );
 
-    // Check for crash from previous session. Skip our own fresh bootstrap lock.
-    const crashLock = readCrashLock(base);
-    if (crashLock && crashLock.pid !== process.pid) {
-      if (isLockProcessAlive(crashLock)) {
-        ctx.ui.notify(
-          `Another auto-mode session (PID ${crashLock.pid}) appears to be running.\nStop it with \`kill ${crashLock.pid}\` before starting a new session.`,
-          "error",
-        );
-        return releaseLockAndReturn();
-      }
-      const recoveredMid = parseUnitId(crashLock.unitId).milestone;
-      const milestoneAlreadyComplete = recoveredMid
-        ? !!resolveMilestoneFile(base, recoveredMid, "SUMMARY")
-        : false;
-
-      if (milestoneAlreadyComplete) {
-        ctx.ui.notify(
-          `Crash recovery: discarding stale context for ${crashLock.unitId} — milestone ${recoveredMid} is already complete.`,
-          "info",
-        );
-      } else {
-        const activityDir = join(gsdRoot(base), "activity");
-        const recovery = synthesizeCrashRecovery(
-          base,
-          crashLock.unitType,
-          crashLock.unitId,
-          crashLock.sessionFile,
-          activityDir,
-        );
-        if (recovery && recovery.trace.toolCallCount > 0) {
-          s.pendingCrashRecovery = recovery.prompt;
-          ctx.ui.notify(
-            `${formatCrashInfo(crashLock)}\nRecovered ${recovery.trace.toolCallCount} tool calls from crashed session. Resuming with full context.`,
-            "warning",
-          );
-        } else {
-          ctx.ui.notify(
-            `${formatCrashInfo(crashLock)}\nNo session data recovered. Resuming from disk state.`,
-            "warning",
-          );
-        }
-      }
-      clearLock(base);
-    }
-
     // ── Debug mode ──
     if (!isDebugEnabled() && process.env.GSD_DEBUG === "1") {
       enableDebug(base);
@@ -410,6 +375,10 @@ export async function bootstrapAutoSession(
       ctx.ui.notify(`Debug logging enabled → ${getDebugLogPath()}`, "info");
     }
 
+    if (interrupted.classification !== "recoverable") {
+      s.pendingCrashRecovery = null;
+    }
+
     // Invalidate caches before initial state derivation
     invalidateAllCaches();
 
@@ -909,4 +878,3 @@ export async function bootstrapAutoSession(
     throw err;
   }
 }
-

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

@@ -1137,6 +1137,7 @@ function copyPlanningArtifacts(srcBase: string, wtPath: string): void {
   const srcGsd = join(srcBase, ".gsd");
   const dstGsd = join(wtPath, ".gsd");
   if (!existsSync(srcGsd)) return;
+  if (isSamePath(srcGsd, dstGsd)) return;
 
   // Copy milestones/ directory (planning files, roadmaps, plans, research)
   safeCopyRecursive(join(srcGsd, "milestones"), join(dstGsd, "milestones"), {
@@ -1420,8 +1421,31 @@ export function mergeMilestoneToMain(
   const worktreeCwd = process.cwd();
   const milestoneBranch = autoWorktreeBranch(milestoneId);
 
-  // 1. Auto-commit dirty state in worktree before leaving
-  autoCommitDirtyState(worktreeCwd);
+  // 1. Auto-commit dirty state before leaving.
+  //    Guard: when we entered through an auto-worktree (originalBase is set),
+  //    only auto-commit when cwd is on the milestone branch. In parallel mode,
+  //    cwd may be on the integration branch after a prior merge's
+  //    MergeConflictError left cwd unrestored. Auto-committing on the
+  //    integration branch captures dirty files from OTHER milestones under a
+  //    misleading commit message, contaminating the main branch (#2929).
+  //
+  //    When originalBase is null (branch mode, no worktree), autoCommitDirtyState
+  //    runs unconditionally — the caller is responsible for cwd placement.
+  {
+    let shouldAutoCommit = true;
+    if (originalBase !== null) {
+      try {
+        const currentBranch = nativeGetCurrentBranch(worktreeCwd);
+        shouldAutoCommit = currentBranch === milestoneBranch;
+      } catch {
+        // If we can't determine the branch, skip the auto-commit to be safe
+        shouldAutoCommit = false;
+      }
+    }
+    if (shouldAutoCommit) {
+      autoCommitDirtyState(worktreeCwd);
+    }
+  }
 
   // Reconcile worktree DB into main DB before leaving worktree context.
   // Skip when both paths resolve to the same physical file (shared WAL /
@@ -1778,6 +1802,12 @@ export function mergeMilestoneToMain(
           }
         }
         restoreShelter();
+        // Restore cwd so the caller is not stranded on the integration branch.
+        // Without this, the next mergeMilestoneToMain call in a parallel merge
+        // sequence uses process.cwd() (now the project root) as worktreeCwd,
+        // causing autoCommitDirtyState to commit unrelated milestone files to
+        // the integration branch (#2929).
+        process.chdir(previousCwd);
         throw new MergeConflictError(
           codeConflicts,
           "squash",
@@ -1975,23 +2005,38 @@ export function mergeMilestoneToMain(
   // changes (e.g. nativeHasChanges cache returned stale false, or auto-commit
   // silently failed), force one final commit so code is not destroyed by
   // `git worktree remove --force`.
+  //
+  // Guard: only run when worktreeCwd is on the milestone branch (#2929).
+  // In parallel mode or branch-mode merges, worktreeCwd may be the project
+  // root on the integration branch. Committing dirty state there would
+  // capture unrelated files from other milestones.
   if (existsSync(worktreeCwd)) {
+    let preTeardownBranch: string | null = null;
     try {
-      const dirtyCheck = nativeWorkingTreeStatus(worktreeCwd);
-      if (dirtyCheck) {
+      preTeardownBranch = nativeGetCurrentBranch(worktreeCwd);
+    } catch (err) {
+      debugLog("mergeMilestoneToMain", { phase: "pre-teardown-branch-detect-failed", error: String(err) });
+    }
+    const isOnMilestoneBranch = preTeardownBranch === milestoneBranch;
+
+    if (isOnMilestoneBranch) {
+      try {
+        const dirtyCheck = nativeWorkingTreeStatus(worktreeCwd);
+        if (dirtyCheck) {
+          debugLog("mergeMilestoneToMain", {
+            phase: "pre-teardown-dirty",
+            worktreeCwd,
+            status: dirtyCheck.slice(0, 200),
+          });
+          nativeAddAllWithExclusions(worktreeCwd, RUNTIME_EXCLUSION_PATHS);
+          nativeCommit(worktreeCwd, "chore: pre-teardown auto-commit of uncommitted worktree changes");
+        }
+      } catch (e) {
         debugLog("mergeMilestoneToMain", {
-          phase: "pre-teardown-dirty",
-          worktreeCwd,
-          status: dirtyCheck.slice(0, 200),
+          phase: "pre-teardown-commit-error",
+          error: String(e),
         });
-        nativeAddAllWithExclusions(worktreeCwd, RUNTIME_EXCLUSION_PATHS);
-        nativeCommit(worktreeCwd, "chore: pre-teardown auto-commit of uncommitted worktree changes");
       }
-    } catch (e) {
-      debugLog("mergeMilestoneToMain", {
-        phase: "pre-teardown-commit-error",
-        error: String(e),
-      });
     }
   }
 
@@ -2020,4 +2065,3 @@ export function mergeMilestoneToMain(
 
   return { commitMessage, pushed, prCreated, codeFilesChanged };
 }
-