gsd-pi 2.67.0-dev.509bd95 → 2.67.0-dev.6fc2289

package/README.md

@@ -95,7 +95,7 @@ See the full [Changelog](./CHANGELOG.md) for details on every release.
 
 ## Documentation
 
-Full documentation is available in the [`docs/`](./docs/) directory:
+Full documentation is available at **[gsd.build](https://gsd.build)** (powered by Mintlify) and in the [`docs/`](./docs/) directory:
 
 - **[Getting Started](./docs/getting-started.md)** — install, first run, basic usage
 - **[Auto Mode](./docs/auto-mode.md)** — autonomous execution deep-dive

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -124,70 +124,6 @@ export function makeStreamExhaustedErrorMessage(model, lastTextContent) {
     }
     return message;
 }
-/**
- * Claude Code executes its own internal tool loop inside the SDK call. The
- * streamed and final assistant messages should therefore contain only
- * user-facing content (text/thinking), not replayable tool blocks that GSD
- * would render again.
- */
-function isUserFacingClaudeCodeBlock(block) {
-    return block.type === "text" || block.type === "thinking";
-}
-function filterUserFacingClaudeCodeContent(blocks) {
-    return blocks.filter(isUserFacingClaudeCodeBlock);
-}
-function remapClaudeCodeContentIndex(blocks, contentIndex) {
-    let visibleCount = 0;
-    for (let i = 0; i <= contentIndex && i < blocks.length; i++) {
-        if (isUserFacingClaudeCodeBlock(blocks[i]))
-            visibleCount++;
-    }
-    return Math.max(0, visibleCount - 1);
-}
-function sanitizeClaudeCodePartial(partial) {
-    return {
-        ...partial,
-        content: filterUserFacingClaudeCodeContent(partial.content),
-    };
-}
-export function sanitizeClaudeCodeStreamingEvent(event) {
-    switch (event.type) {
-        case "toolcall_start":
-        case "toolcall_delta":
-        case "toolcall_end":
-        case "server_tool_use":
-        case "web_search_result":
-            return null;
-        case "text_start":
-        case "text_delta":
-        case "text_end":
-        case "thinking_start":
-        case "thinking_delta":
-        case "thinking_end":
-            return {
-                ...event,
-                contentIndex: remapClaudeCodeContentIndex(event.partial.content, event.contentIndex),
-                partial: sanitizeClaudeCodePartial(event.partial),
-            };
-        default:
-            return event;
-    }
-}
-export function buildFinalClaudeCodeContent(blocks, lastThinkingContent, lastTextContent, resultText) {
-    const finalContent = filterUserFacingClaudeCodeContent(blocks);
-    if (finalContent.length > 0)
-        return finalContent;
-    if (lastThinkingContent) {
-        finalContent.push({ type: "thinking", thinking: lastThinkingContent });
-    }
-    if (lastTextContent) {
-        finalContent.push({ type: "text", text: lastTextContent });
-    }
-    if (finalContent.length === 0 && resultText) {
-        finalContent.push({ type: "text", text: resultText });
-    }
-    return finalContent;
-}
 // ---------------------------------------------------------------------------
 // SDK options builder
 // ---------------------------------------------------------------------------
@@ -213,6 +149,94 @@ export function buildSdkOptions(modelId, prompt) {
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
     };
 }
+function normalizeToolResultContent(content) {
+    if (typeof content === "string") {
+        return [{ type: "text", text: content }];
+    }
+    if (!Array.isArray(content)) {
+        if (content == null)
+            return [{ type: "text", text: "" }];
+        return [{ type: "text", text: JSON.stringify(content) }];
+    }
+    const blocks = [];
+    for (const item of content) {
+        if (typeof item === "string") {
+            blocks.push({ type: "text", text: item });
+            continue;
+        }
+        if (!item || typeof item !== "object") {
+            blocks.push({ type: "text", text: String(item) });
+            continue;
+        }
+        const block = item;
+        if (block.type === "text") {
+            blocks.push({ type: "text", text: typeof block.text === "string" ? block.text : "" });
+            continue;
+        }
+        if (block.type === "image"
+            && typeof block.data === "string"
+            && typeof block.mimeType === "string") {
+            blocks.push({ type: "image", data: block.data, mimeType: block.mimeType });
+            continue;
+        }
+        blocks.push({ type: "text", text: JSON.stringify(block) });
+    }
+    return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
+}
+export function extractToolResultsFromSdkUserMessage(message) {
+    const extracted = [];
+    const seen = new Set();
+    const rawMessage = message.message;
+    const content = Array.isArray(rawMessage?.content) ? rawMessage.content : [];
+    for (const item of content) {
+        if (!item || typeof item !== "object")
+            continue;
+        const block = item;
+        const type = typeof block.type === "string" ? block.type : "";
+        if (type !== "tool_result" && type !== "mcp_tool_result")
+            continue;
+        const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
+        if (!toolUseId || seen.has(toolUseId))
+            continue;
+        seen.add(toolUseId);
+        extracted.push({
+            toolUseId,
+            result: {
+                content: normalizeToolResultContent(block.content),
+                details: {},
+                isError: block.is_error === true,
+            },
+        });
+    }
+    if (extracted.length === 0) {
+        const fallback = message.tool_use_result;
+        if (fallback && typeof fallback === "object") {
+            const toolResult = fallback;
+            const toolUseId = typeof toolResult.tool_use_id === "string" ? toolResult.tool_use_id : "";
+            if (toolUseId) {
+                extracted.push({
+                    toolUseId,
+                    result: {
+                        content: normalizeToolResultContent(toolResult.content),
+                        details: {},
+                        isError: toolResult.is_error === true,
+                    },
+                });
+            }
+        }
+    }
+    return extracted;
+}
+function attachExternalResultsToToolCalls(toolCalls, toolResultsById) {
+    for (const block of toolCalls) {
+        if (block.type !== "toolCall")
+            continue;
+        const externalResult = toolResultsById.get(block.id);
+        if (!externalResult)
+            continue;
+        block.externalResult = externalResult;
+    }
+}
 // ---------------------------------------------------------------------------
 // streamSimple implementation
 // ---------------------------------------------------------------------------
@@ -234,6 +258,10 @@ async function pumpSdkMessages(model, context, options, stream) {
     /** Track the last text content seen across all assistant turns for the final message. */
     let lastTextContent = "";
     let lastThinkingContent = "";
+    /** Collect tool calls from intermediate SDK turns for tool_execution events. */
+    const intermediateToolCalls = [];
+    /** Preserve real external tool results from Claude Code's synthetic user messages. */
+    const toolResultsById = new Map();
     try {
         // Dynamic import — the SDK is an optional dependency.
         const sdkModule = "@anthropic-ai/claude-agent-sdk";
@@ -285,11 +313,9 @@ async function pumpSdkMessages(model, context, options, stream) {
                     if (!builder)
                         break;
                     const assistantEvent = builder.handleEvent(event);
-                    const sanitizedEvent = assistantEvent
-                        ? sanitizeClaudeCodeStreamingEvent(assistantEvent)
-                        : null;
-                    if (sanitizedEvent)
-                        stream.push(sanitizedEvent);
+                    if (assistantEvent) {
+                        stream.push(assistantEvent);
+                    }
                     break;
                 }
                 // -- Complete assistant message (non-streaming fallback) --
@@ -317,6 +343,36 @@ async function pumpSdkMessages(model, context, options, stream) {
                             else if (block.type === "thinking" && block.thinking) {
                                 lastThinkingContent = block.thinking;
                             }
+                            else if (block.type === "toolCall") {
+                                // Collect tool calls for externalToolExecution rendering
+                                intermediateToolCalls.push(block);
+                            }
+                        }
+                    }
+                    // Extract tool results from the SDK's synthetic user message
+                    // and attach to corresponding tool call blocks immediately.
+                    for (const { toolUseId, result } of extractToolResultsFromSdkUserMessage(msg)) {
+                        toolResultsById.set(toolUseId, result);
+                    }
+                    attachExternalResultsToToolCalls(intermediateToolCalls, toolResultsById);
+                    // Push a synthetic toolcall_end for each tool call from this turn
+                    // so the TUI can render tool results in real-time during the SDK
+                    // session instead of waiting until the entire session completes.
+                    if (builder) {
+                        for (const block of builder.message.content) {
+                            if (block.type !== "toolCall")
+                                continue;
+                            const extResult = block.externalResult;
+                            if (!extResult)
+                                continue;
+                            // Push a toolcall_end with result attached so the chat-controller
+                            // can call updateResult on the pending ToolExecutionComponent.
+                            stream.push({
+                                type: "toolcall_end",
+                                contentIndex: builder.message.content.indexOf(block),
+                                toolCall: block,
+                                partial: builder.message,
+                            });
                         }
                     }
                     builder = null;
@@ -325,7 +381,33 @@ async function pumpSdkMessages(model, context, options, stream) {
                 // -- Result (terminal) --
                 case "result": {
                     const result = msg;
-                    const finalContent = buildFinalClaudeCodeContent(builder?.message.content ?? [], lastThinkingContent, lastTextContent, result.subtype === "success" ? result.result : undefined);
+                    // Build final message. Include intermediate tool calls so the
+                    // agent loop's externalToolExecution path emits tool_execution
+                    // events for proper TUI rendering, followed by the text response.
+                    const finalContent = [];
+                    // Add tool calls from intermediate turns first (renders above text)
+                    attachExternalResultsToToolCalls(intermediateToolCalls, toolResultsById);
+                    finalContent.push(...intermediateToolCalls);
+                    // Add text/thinking from the last turn
+                    if (builder && builder.message.content.length > 0) {
+                        for (const block of builder.message.content) {
+                            if (block.type === "text" || block.type === "thinking") {
+                                finalContent.push(block);
+                            }
+                        }
+                    }
+                    else {
+                        if (lastThinkingContent) {
+                            finalContent.push({ type: "thinking", thinking: lastThinkingContent });
+                        }
+                        if (lastTextContent) {
+                            finalContent.push({ type: "text", text: lastTextContent });
+                        }
+                    }
+                    // Fallback: use the SDK's result text if we have no content
+                    if (finalContent.length === 0 && result.subtype === "success" && result.result) {
+                        finalContent.push({ type: "text", text: result.result });
+                    }
                     const finalMessage = {
                         role: "assistant",
                         content: finalContent,

package/dist/resources/extensions/gsd/auto/session.js

@@ -33,6 +33,9 @@ export class AutoSession {
     // ── Paths ────────────────────────────────────────────────────────────────
     basePath = "";
     originalBasePath = "";
+    previousProjectRootEnv = null;
+    hadProjectRootEnv = false;
+    projectRootEnvCaptured = false;
     gitService = null;
     // ── Dispatch counters ────────────────────────────────────────────────────
     unitDispatchCount = new Map();
@@ -60,6 +63,8 @@ export class AutoSession {
     pendingVerificationRetry = null;
     verificationRetryCount = new Map();
     pausedSessionFile = null;
+    pausedUnitType = null;
+    pausedUnitId = null;
     resourceVersionOnStart = null;
     lastStateRebuildAt = 0;
     // ── Sidecar queue ─────────────────────────────────────────────────────
@@ -132,6 +137,9 @@ export class AutoSession {
         // Paths
         this.basePath = "";
         this.originalBasePath = "";
+        this.previousProjectRootEnv = null;
+        this.hadProjectRootEnv = false;
+        this.projectRootEnvCaptured = false;
         this.gitService = null;
         // Dispatch
         this.unitDispatchCount.clear();
@@ -153,6 +161,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;
         // Metrics

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -104,7 +104,7 @@ export function isVerificationNotApplicable(value) {
     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 ────────────────────────────────────────────────────────────────
 export const DISPATCH_RULES = [

package/dist/resources/extensions/gsd/auto-start.js

@@ -16,8 +16,7 @@ import { migrateToExternalState, recoverFailedMigration } from "./migrate-extern
 import { collectSecretsFromManifest } from "../get-secrets-from-user.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, updateSessionLock, } from "./session-lock.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeCheckoutBranch, nativeBranchList, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, } from "./native-git-bridge.js";
@@ -35,7 +34,6 @@ import { isDbAvailable, getMilestone, openDatabase } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
-import { parseUnitId } from "./unit-id.js";
 import { existsSync, mkdirSync, readdirSync, rmSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
@@ -174,7 +172,7 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
     }
     return { recovered, warnings };
 }
-export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, deps) {
+export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, deps, interrupted) {
     const { shouldUseWorktreeIsolation, registerSigtermHandler, lockBase, buildResolver, } = deps;
     const lockResult = acquireSessionLock(base);
     if (!lockResult.acquired) {
@@ -250,35 +248,20 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        // 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");
+        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");
                 }
             }
-            clearLock(base);
+            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 ?? {});
         // ── Debug mode ──
         if (!isDebugEnabled() && process.env.GSD_DEBUG === "1") {
             enableDebug(base);
@@ -296,6 +279,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             });
             ctx.ui.notify(`Debug logging enabled → ${getDebugLogPath()}`, "info");
         }
+        if (interrupted.classification !== "recoverable") {
+            s.pendingCrashRecovery = null;
+        }
         // Invalidate caches before initial state derivation
         invalidateAllCaches();
         // Clean stale runtime unit files for completed milestones (#887)

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -983,6 +983,8 @@ function copyPlanningArtifacts(srcBase, wtPath) {
     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"), {
         force: true,
@@ -1209,8 +1211,32 @@ function autoCommitDirtyState(cwd) {
 export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapContent) {
     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 /
     // symlink layout) — ATTACHing a WAL-mode file to itself corrupts the
@@ -1551,6 +1577,12 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
                     }
                 }
                 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", milestoneBranch, mainBranch);
             }
         }
@@ -1725,25 +1757,40 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // 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 = 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),
-            });
-        }
     }
     // 12. Remove worktree directory first (must happen before branch deletion)
     try {