gsd-pi 2.51.0 → 2.52.0-dev.655ad8a

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

@@ -88,6 +88,19 @@ function makeErrorMessage(model, errorMsg) {
         timestamp: Date.now(),
     };
 }
+/**
+ * Generator exhaustion without a terminal result means the SDK stream was
+ * interrupted mid-turn. Surface it as an error so downstream recovery logic
+ * can classify and retry it instead of treating it as a clean completion.
+ */
+export function makeStreamExhaustedErrorMessage(model, lastTextContent) {
+    const errorMsg = "stream_exhausted_without_result";
+    const message = makeErrorMessage(model, errorMsg);
+    if (lastTextContent) {
+        message.content = [{ type: "text", text: lastTextContent }];
+    }
+    return message;
+}
 // ---------------------------------------------------------------------------
 // streamSimple implementation
 // ---------------------------------------------------------------------------
@@ -278,25 +291,11 @@ async function pumpSdkMessages(model, context, options, stream) {
                     break;
             }
         }
-        // Generator exhausted without a result message (unexpected)
-        const fallbackContent = [];
-        if (lastTextContent) {
-            fallbackContent.push({ type: "text", text: lastTextContent });
-        }
-        if (fallbackContent.length === 0) {
-            fallbackContent.push({ type: "text", text: "(Claude Code session ended without a response)" });
-        }
-        const fallback = {
-            role: "assistant",
-            content: fallbackContent,
-            api: "anthropic-messages",
-            provider: "claude-code",
-            model: modelId,
-            usage: { ...ZERO_USAGE },
-            stopReason: "stop",
-            timestamp: Date.now(),
-        };
-        stream.push({ type: "done", reason: "stop", message: fallback });
+        // Generator exhaustion without a terminal result is a stream interruption,
+        // not a successful completion. Emitting an error lets GSD classify it as a
+        // transient provider failure instead of advancing auto-mode state.
+        const fallback = makeStreamExhaustedErrorMessage(modelId, lastTextContent);
+        stream.push({ type: "error", reason: "error", error: fallback });
     }
     catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);

package/dist/resources/extensions/get-secrets-from-user.js

@@ -25,6 +25,11 @@ function maskPreview(value) {
 function shellEscapeSingle(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function hydrateProcessEnv(key, value) {
+    // Make newly collected secrets immediately visible to the current session.
+    // Some extensions read process.env directly and do not reload .env on every call.
+    process.env[key] = value;
+}
 async function writeEnvKey(filePath, key, value) {
     let content = "";
     try {
@@ -246,6 +251,7 @@ async function applySecrets(provided, destination, opts) {
             try {
                 await writeEnvKey(opts.envFilePath, key, value);
                 applied.push(key);
+                hydrateProcessEnv(key, value);
             }
             catch (err) {
                 errors.push(`${key}: ${err.message}`);
@@ -265,6 +271,7 @@ async function applySecrets(provided, destination, opts) {
                 }
                 else {
                     applied.push(key);
+                    hydrateProcessEnv(key, value);
                 }
             }
             catch (err) {

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

@@ -15,12 +15,20 @@ import { PROJECT_FILES } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { join } from "node:path";
 import { existsSync, cpSync } from "node:fs";
-import { logWarning } from "../workflow-logger.js";
+import { logWarning, logError } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
 import { verifyExpectedArtifact } from "../auto-recovery.js";
 import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
+/**
+ * Resolve the base path for milestone reports.
+ * Prefers originalBasePath (project root) over basePath (which may be a worktree).
+ * Exported for testing as _resolveReportBasePath.
+ */
+export function _resolveReportBasePath(s) {
+    return s.originalBasePath || s.basePath;
+}
 /**
  * Generate and write an HTML milestone report snapshot.
  * Extracted from the milestone-transition block in autoLoop.
@@ -30,18 +38,19 @@ async function generateMilestoneReport(s, ctx, milestoneId) {
     const { generateHtmlReport } = await importExtensionModule(import.meta.url, "../export-html.js");
     const { writeReportSnapshot } = await importExtensionModule(import.meta.url, "../reports.js");
     const { basename } = await import("node:path");
-    const snapData = await loadVisualizerData(s.basePath);
+    const reportBasePath = _resolveReportBasePath(s);
+    const snapData = await loadVisualizerData(reportBasePath);
     const completedMs = snapData.milestones.find((m) => m.id === milestoneId);
     const msTitle = completedMs?.title ?? milestoneId;
     const gsdVersion = process.env.GSD_VERSION ?? "0.0.0";
-    const projName = basename(s.basePath);
+    const projName = basename(reportBasePath);
     const doneSlices = snapData.milestones.reduce((acc, m) => acc + m.slices.filter((sl) => sl.done).length, 0);
     const totalSlices = snapData.milestones.reduce((acc, m) => acc + m.slices.length, 0);
     const outPath = writeReportSnapshot({
-        basePath: s.basePath,
+        basePath: reportBasePath,
         html: generateHtmlReport(snapData, {
             projectName: projName,
-            projectPath: s.basePath,
+            projectPath: reportBasePath,
             gsdVersion,
             milestoneId,
             indexRelPath: "index.html",
@@ -50,7 +59,7 @@ async function generateMilestoneReport(s, ctx, milestoneId) {
         milestoneTitle: msTitle,
         kind: "milestone",
         projectName: projName,
-        projectPath: s.basePath,
+        projectPath: reportBasePath,
         gsdVersion,
         totalCost: snapData.totals?.cost ?? 0,
         totalTokens: snapData.totals?.tokens.total ?? 0,
@@ -160,8 +169,11 @@ export async function runPreDispatch(ic, loopState) {
                 await deps.stopAuto(ctx, pi, `Merge conflict on milestone ${s.currentMilestoneId}`);
                 return { action: "break", reason: "merge-conflict" };
             }
-            // Non-conflict merge errors — log and continue
-            logWarning("engine", "Milestone merge failed with non-conflict error", { milestone: s.currentMilestoneId, error: String(mergeErr) });
+            // Non-conflict merge errors — stop auto to avoid advancing with unmerged work
+            logError("engine", "Milestone merge failed with non-conflict error", { milestone: s.currentMilestoneId, error: String(mergeErr) });
+            ctx.ui.notify(`Merge failed: ${mergeErr instanceof Error ? mergeErr.message : String(mergeErr)}. Resolve and run /gsd auto to resume.`, "error");
+            await deps.stopAuto(ctx, pi, `Merge error on milestone ${s.currentMilestoneId}: ${String(mergeErr)}`);
+            return { action: "break", reason: "merge-failed" };
         }
         // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         deps.invalidateAllCaches();
@@ -228,6 +240,10 @@ export async function runPreDispatch(ic, loopState) {
                         await deps.stopAuto(ctx, pi, `Merge conflict on milestone ${s.currentMilestoneId}`);
                         return { action: "break", reason: "merge-conflict" };
                     }
+                    logError("engine", "Milestone merge failed with non-conflict error", { milestone: s.currentMilestoneId, error: String(mergeErr) });
+                    ctx.ui.notify(`Merge failed: ${mergeErr instanceof Error ? mergeErr.message : String(mergeErr)}. Resolve and run /gsd auto to resume.`, "error");
+                    await deps.stopAuto(ctx, pi, `Merge error on milestone ${s.currentMilestoneId}: ${String(mergeErr)}`);
+                    return { action: "break", reason: "merge-failed" };
                 }
                 // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
             }
@@ -295,6 +311,10 @@ export async function runPreDispatch(ic, loopState) {
                     await deps.stopAuto(ctx, pi, `Merge conflict on milestone ${s.currentMilestoneId}`);
                     return { action: "break", reason: "merge-conflict" };
                 }
+                logError("engine", "Milestone merge failed with non-conflict error", { milestone: s.currentMilestoneId, error: String(mergeErr) });
+                ctx.ui.notify(`Merge failed: ${mergeErr instanceof Error ? mergeErr.message : String(mergeErr)}. Resolve and run /gsd auto to resume.`, "error");
+                await deps.stopAuto(ctx, pi, `Merge error on milestone ${s.currentMilestoneId}: ${String(mergeErr)}`);
+                return { action: "break", reason: "merge-failed" };
             }
             // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         }
@@ -753,6 +773,12 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
     }
     if (unitResult.status === "cancelled") {
+        // Provider-error pause: pauseAuto already handled cleanup and scheduled
+        // recovery. Don't hard-stop — just break out of the loop (#2762).
+        if (unitResult.errorContext?.category === "provider") {
+            debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext.isTransient });
+            return { action: "break", reason: "provider-pause" };
+        }
         ctx.ui.notify(`Session creation timed out or was cancelled for ${unitType} ${unitId}. Will retry.`, "warning");
         await deps.stopAuto(ctx, pi, "Session creation failed");
         debugLog("autoLoop", { phase: "exit", reason: "session-failed" });

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

@@ -483,6 +483,24 @@ export const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath }) => {
             if (state.phase !== "completing-milestone")
                 return null;
+            // Safety guard (#2675): block completion when VALIDATION verdict is
+            // needs-remediation. The state machine treats needs-remediation as
+            // terminal (to prevent validate-milestone loops per #832), but
+            // completing-milestone should NOT proceed — remediation work is needed.
+            const validationFile = resolveMilestoneFile(basePath, mid, "VALIDATION");
+            if (validationFile) {
+                const validationContent = await loadFile(validationFile);
+                if (validationContent) {
+                    const verdict = extractVerdict(validationContent);
+                    if (verdict === "needs-remediation") {
+                        return {
+                            action: "stop",
+                            reason: `Cannot complete milestone ${mid}: VALIDATION verdict is "needs-remediation". Address the remediation findings and re-run validation, or update the verdict manually.`,
+                            level: "warning",
+                        };
+                    }
+                }
+            }
             // Safety guard (#1368): verify all roadmap slices have SUMMARY files.
             const missingSlices = findMissingSummaries(basePath, mid);
             if (missingSlices.length > 0) {
@@ -513,8 +531,12 @@ export const DISPATCH_RULES = [
                         if (validationPath) {
                             const validationContent = await loadFile(validationPath);
                             if (validationContent) {
-                                const hasOperationalCheck = validationContent.includes("Operational") &&
+                                // Accept either the structured template format (table with MET/N/A)
+                                // or prose evidence patterns the validation agent may emit.
+                                const structuredMatch = validationContent.includes("Operational") &&
                                     (validationContent.includes("MET") || validationContent.includes("N/A"));
+                                const proseMatch = /[Oo]perational[\s:][^\n]*(?:pass|verified|confirmed|met|complete|true|yes|addressed|covered|n\/a|not\s+applicable)/i.test(validationContent);
+                                const hasOperationalCheck = structuredMatch || proseMatch;
                                 if (!hasOperationalCheck) {
                                     return {
                                         action: "stop",

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

@@ -34,6 +34,7 @@ import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { parseUnitId } from "./unit-id.js";
+import { setLogBasePath } from "./workflow-logger.js";
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
@@ -312,6 +313,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         s.verbose = verboseMode;
         s.cmdCtx = ctx;
         s.basePath = base;
+        setLogBasePath(base);
         s.unitDispatchCount.clear();
         s.unitRecoveryCount.clear();
         s.lastBudgetAlertLevel = 0;

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

@@ -9,7 +9,7 @@ import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "./unit-runtime.js
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { resolveAutoSupervisorConfig } from "./preferences.js";
 import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
-import { getInFlightToolCount, getOldestInFlightToolStart, } from "./auto-tool-tracking.js";
+import { getInFlightToolCount, getOldestInFlightToolStart, clearInFlightTools, hasInteractiveToolInFlight, } from "./auto-tool-tracking.js";
 import { detectWorkingTreeActivity } from "./auto-supervisor.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { saveActivityLog } from "./activity-log.js";
@@ -116,7 +116,17 @@ export function startUnitSupervision(sctx) {
                 return;
             // Agent has tool calls currently executing — not idle, just waiting.
             // But only suppress recovery if the tool started recently.
+            let stalledToolDetected = false;
             if (getInFlightToolCount() > 0) {
+                // User-interactive tools (ask_user_questions, secure_env_collect) block
+                // waiting for human input by design — never treat them as stalled (#2676).
+                if (hasInteractiveToolInFlight()) {
+                    writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
+                        lastProgressAt: Date.now(),
+                        lastProgressKind: "interactive-tool-waiting",
+                    });
+                    return;
+                }
                 const oldestStart = getOldestInFlightToolStart();
                 const toolAgeMs = Date.now() - oldestStart;
                 if (toolAgeMs < idleTimeoutMs) {
@@ -126,10 +136,18 @@ export function startUnitSupervision(sctx) {
                     });
                     return;
                 }
+                // Tool has been in-flight longer than idle timeout — treat as hung.
+                // Clear the stale entries so subsequent ticks don't re-detect them,
+                // and set the flag so the filesystem-activity check below does not
+                // override the stall verdict (#2527).
+                stalledToolDetected = true;
+                clearInFlightTools();
                 ctx.ui.notify(`Stalled tool detected: a tool has been in-flight for ${Math.round(toolAgeMs / 60000)}min. Treating as hung — attempting idle recovery.`, "warning");
             }
             // Check if the agent is producing work on disk.
-            if (detectWorkingTreeActivity(s.basePath)) {
+            // Skip this when a stalled tool was just detected — filesystem changes
+            // from earlier in the task should not override the stall verdict (#2527).
+            if (!stalledToolDetected && detectWorkingTreeActivity(s.basePath)) {
                 writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
                     lastProgressAt: Date.now(),
                     lastProgressKind: "filesystem-activity",
@@ -145,6 +163,10 @@ export function startUnitSupervision(sctx) {
             const recovery = await recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle", buildRecoveryContext());
             if (recovery === "recovered")
                 return;
+            // Guard: recoverTimedOutUnit is async — pauseAuto/stopAuto may have
+            // set s.currentUnit = null during the await (#2527).
+            if (!s.currentUnit)
+                return;
             writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
                 phase: "paused",
             });

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -4,14 +4,20 @@
  * can distinguish "waiting for tool completion" from "truly idle".
  */
 const inFlightTools = new Map();
+/**
+ * Tools that block waiting for human input by design.
+ * The idle watchdog must not treat these as stalled.
+ */
+const INTERACTIVE_TOOLS = new Set(["ask_user_questions", "secure_env_collect"]);
 /**
  * Mark a tool execution as in-flight.
- * Records start time so the idle watchdog can detect tools hung longer than the idle timeout.
+ * Records start time and tool name so the idle watchdog can detect tools
+ * hung longer than the idle timeout while exempting interactive tools.
  */
-export function markToolStart(toolCallId, isActive) {
+export function markToolStart(toolCallId, isActive, toolName) {
     if (!isActive)
         return;
-    inFlightTools.set(toolCallId, Date.now());
+    inFlightTools.set(toolCallId, { startedAt: Date.now(), toolName: toolName ?? "unknown" });
 }
 /**
  * Mark a tool execution as completed.
@@ -27,8 +33,8 @@ export function getOldestInFlightToolAgeMs() {
         return 0;
     let oldestStart = Infinity;
     for (const t of inFlightTools.values()) {
-        if (t < oldestStart)
-            oldestStart = t;
+        if (t.startedAt < oldestStart)
+            oldestStart = t.startedAt;
     }
     return Date.now() - oldestStart;
 }
@@ -46,11 +52,23 @@ export function getOldestInFlightToolStart() {
         return undefined;
     let oldest = Infinity;
     for (const t of inFlightTools.values()) {
-        if (t < oldest)
-            oldest = t;
+        if (t.startedAt < oldest)
+            oldest = t.startedAt;
     }
     return oldest;
 }
+/**
+ * Returns true if any currently in-flight tool is a user-interactive tool
+ * (e.g. ask_user_questions, secure_env_collect) that blocks waiting for
+ * human input. These must be exempt from idle stall detection.
+ */
+export function hasInteractiveToolInFlight() {
+    for (const { toolName } of inFlightTools.values()) {
+        if (INTERACTIVE_TOOLS.has(toolName))
+            return true;
+    }
+    return false;
+}
 /**
  * Clear all in-flight tool tracking state.
  */

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

@@ -37,6 +37,10 @@ const ROOT_STATE_FILES = [
     "QUEUE.md",
     "completed-units.json",
     "metrics.json",
+    // NOTE: preferences.md is intentionally NOT in ROOT_STATE_FILES.
+    // Forward-sync (main → worktree) is handled explicitly in syncGsdStateToWorktree().
+    // Back-sync (worktree → main) must NEVER overwrite the project root's copy
+    // because the project root is authoritative for preferences (#2684).
 ];
 /**
  * Check if two filesystem paths resolve to the same real location.
@@ -100,6 +104,21 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
         }
     }
 }
+// ─── Build Artifact Auto-Resolve ─────────────────────────────────────────────
+/** Patterns for machine-generated build artifacts that can be safely
+ * auto-resolved by accepting --theirs during merge. These files are
+ * regenerable and never contain meaningful manual edits. */
+export const SAFE_AUTO_RESOLVE_PATTERNS = [
+    /\.tsbuildinfo$/,
+    /\.pyc$/,
+    /\/__pycache__\//,
+    /\.DS_Store$/,
+    /\.map$/,
+];
+/** Returns true if the file path is safe to auto-resolve during merge.
+ * Covers `.gsd/` state files and common build artifacts. */
+export const isSafeToAutoResolve = (filePath) => filePath.startsWith(".gsd/") ||
+    SAFE_AUTO_RESOLVE_PATTERNS.some((re) => re.test(filePath));
 // ─── Dispatch-Level Sync (project root ↔ worktree) ──────────────────────────
 /**
  * Sync milestone artifacts from project root INTO worktree before deriveState.
@@ -319,6 +338,22 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
             }
         }
     }
+    // Forward-sync preferences.md from project root to worktree (additive only).
+    // NOT in ROOT_STATE_FILES because syncWorktreeStateBack() must never overwrite
+    // the project root's preferences — the project root is authoritative (#2684).
+    {
+        const src = join(mainGsd, "preferences.md");
+        const dst = join(wtGsd, "preferences.md");
+        if (existsSync(src) && !existsSync(dst)) {
+            try {
+                cpSync(src, dst);
+                synced.push("preferences.md");
+            }
+            catch {
+                /* non-fatal */
+            }
+        }
+    }
     // Sync milestones: copy entire milestone directories that are missing
     const mainMilestonesDir = join(mainGsd, "milestones");
     const wtMilestonesDir = join(wtGsd, "milestones");
@@ -801,6 +836,7 @@ function copyPlanningArtifacts(srcBase, wtPath) {
         "STATE.md",
         "KNOWLEDGE.md",
         "OVERRIDES.md",
+        "preferences.md",
     ]) {
         safeCopy(join(srcGsd, file), join(dstGsd, file), { force: true });
     }
@@ -1170,27 +1206,27 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             ? mergeResult.conflicts
             : nativeConflictFiles(originalBasePath_);
         if (conflictedFiles.length > 0) {
-            // Separate .gsd/ state file conflicts from real code conflicts.
-            // GSD state files (STATE.md, auto.lock, etc.)
-            // diverge between branches during normal operation — always prefer the
-            // milestone branch version since it has the latest execution state.
-            const gsdConflicts = conflictedFiles.filter((f) => f.startsWith(".gsd/"));
-            const codeConflicts = conflictedFiles.filter((f) => !f.startsWith(".gsd/"));
-            // Auto-resolve .gsd/ conflicts by accepting the milestone branch version
-            if (gsdConflicts.length > 0) {
-                for (const gsdFile of gsdConflicts) {
+            // Separate auto-resolvable conflicts (GSD state files + build artifacts)
+            // from real code conflicts. GSD state files diverge between branches
+            // during normal operation. Build artifacts are machine-generated and
+            // regenerable. Both are safe to accept from the milestone branch.
+            const autoResolvable = conflictedFiles.filter(isSafeToAutoResolve);
+            const codeConflicts = conflictedFiles.filter((f) => !isSafeToAutoResolve(f));
+            // Auto-resolve safe conflicts by accepting the milestone branch version
+            if (autoResolvable.length > 0) {
+                for (const safeFile of autoResolvable) {
                     try {
-                        nativeCheckoutTheirs(originalBasePath_, [gsdFile]);
-                        nativeAddPaths(originalBasePath_, [gsdFile]);
+                        nativeCheckoutTheirs(originalBasePath_, [safeFile]);
+                        nativeAddPaths(originalBasePath_, [safeFile]);
                     }
                     catch {
                         // If checkout --theirs fails, try removing the file from the merge
                         // (it's a runtime file that shouldn't be committed anyway)
-                        nativeRmForce(originalBasePath_, [gsdFile]);
+                        nativeRmForce(originalBasePath_, [safeFile]);
                     }
                 }
             }
-            // If there are still non-.gsd conflicts, escalate
+            // If there are still real code conflicts, escalate
             if (codeConflicts.length > 0) {
                 // Pop stash before throwing so local work is not lost (#2151).
                 if (stashed) {
@@ -1235,7 +1271,48 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             });
         }
         catch {
-            // Stash pop conflict is non-fatal — stash entry persists for manual resolution.
+            // Stash pop after squash merge can conflict on .gsd/ state files that
+            // diverged between branches.  Left unresolved, these UU entries block
+            // every subsequent merge.  Auto-resolve them the same way we handle
+            // .gsd/ conflicts during the merge itself: accept HEAD (the just-committed
+            // version) and drop the now-applied stash.
+            const uu = nativeConflictFiles(originalBasePath_);
+            const gsdUU = uu.filter((f) => f.startsWith(".gsd/"));
+            const nonGsdUU = uu.filter((f) => !f.startsWith(".gsd/"));
+            if (gsdUU.length > 0) {
+                for (const f of gsdUU) {
+                    try {
+                        // Accept the committed (HEAD) version of the state file
+                        execFileSync("git", ["checkout", "HEAD", "--", f], {
+                            cwd: originalBasePath_,
+                            stdio: ["ignore", "pipe", "pipe"],
+                            encoding: "utf-8",
+                        });
+                        nativeAddPaths(originalBasePath_, [f]);
+                    }
+                    catch {
+                        // Last resort: remove the conflicted state file
+                        nativeRmForce(originalBasePath_, [f]);
+                    }
+                }
+            }
+            if (nonGsdUU.length === 0) {
+                // All conflicts were .gsd/ files — safe to drop the stash
+                try {
+                    execFileSync("git", ["stash", "drop"], {
+                        cwd: originalBasePath_,
+                        stdio: ["ignore", "pipe", "pipe"],
+                        encoding: "utf-8",
+                    });
+                }
+                catch { /* stash may already be consumed */ }
+            }
+            else {
+                // Non-.gsd conflicts remain — leave stash for manual resolution
+                logWarning("reconcile", "Stash pop conflict on non-.gsd files after merge", {
+                    files: nonGsdUU.join(", "),
+                });
+            }
         }
     }
     // 9b. Safety check (#1792): if nothing was committed, verify the milestone

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

@@ -34,6 +34,7 @@ import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
+import { setLogBasePath } from "./workflow-logger.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -184,8 +185,8 @@ export function getAutoModeStartModel() {
     return s.autoModeStartModel;
 }
 // Tool tracking — delegates to auto-tool-tracking.ts
-export function markToolStart(toolCallId) {
-    _markToolStart(toolCallId, s.active);
+export function markToolStart(toolCallId, toolName) {
+    _markToolStart(toolCallId, s.active, toolName);
 }
 export function markToolEnd(toolCallId) {
     _markToolEnd(toolCallId);
@@ -214,6 +215,12 @@ export function stopAutoRemote(projectRoot) {
     const lock = readCrashLock(projectRoot);
     if (!lock)
         return { found: false };
+    // Never SIGTERM ourselves — a stale lock with our own PID is not a remote
+    // session, it is leftover from a prior loop exit in this process. (#2730)
+    if (lock.pid === process.pid) {
+        clearLock(projectRoot);
+        return { found: false };
+    }
     if (!isLockProcessAlive(lock)) {
         // Stale lock — clean it up
         clearLock(projectRoot);
@@ -238,6 +245,10 @@ export function checkRemoteAutoSession(projectRoot) {
     const lock = readCrashLock(projectRoot);
     if (!lock)
         return { running: false };
+    // Our own PID is not a "remote" session — it is a stale lock left by this
+    // process (e.g. after step-mode exit without full cleanup). (#2730)
+    if (lock.pid === process.pid)
+        return { running: false };
     if (!isLockProcessAlive(lock)) {
         // Stale lock from a dead process — not a live remote session
         return { running: false };
@@ -320,6 +331,18 @@ function cleanupAfterLoopExit(ctx) {
     s.currentUnit = null;
     s.active = false;
     clearUnitTimeout();
+    // Clear crash lock and release session lock so the next `/gsd next` does
+    // not see a stale lock with the current PID and treat it as a "remote"
+    // session (which would cause it to SIGTERM itself). (#2730)
+    try {
+        if (lockBase())
+            clearLock(lockBase());
+        if (lockBase())
+            releaseSessionLock(lockBase());
+    }
+    catch {
+        /* best-effort — mirror stopAuto cleanup */
+    }
     ctx.ui.setStatus("gsd-auto", undefined);
     ctx.ui.setWidget("gsd-progress", undefined);
     ctx.ui.setFooter(undefined);
@@ -553,12 +576,14 @@ export async function stopAuto(ctx, pi, reason) {
  * The user can interact with the agent, then `/gsd auto` resumes
  * from disk state. Called when the user presses Escape during auto-mode.
  */
-export async function pauseAuto(ctx, _pi) {
+export async function pauseAuto(ctx, _pi, _errorContext) {
     if (!s.active)
         return;
     clearUnitTimeout();
     // Unblock any pending unit promise so the auto-loop is not orphaned.
-    resolveAgentEndCancelled();
+    // Pass errorContext so runUnitPhase can distinguish user-initiated pause
+    // from provider-error pause and avoid hard-stopping (#2762).
+    resolveAgentEndCancelled(_errorContext);
     s.pausedSessionFile = ctx?.sessionManager?.getSessionFile() ?? null;
     // Persist paused-session metadata so resume survives /exit (#1383).
     // The fresh-start bootstrap checks for this file and restores worktree context.
@@ -815,6 +840,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.stepMode = requestedStepMode;
         s.cmdCtx = ctx;
         s.basePath = base;
+        setLogBasePath(base);
         s.unitDispatchCount.clear();
         s.unitLifetimeDispatches.clear();
         if (!getLedger())