gsd-pi 2.73.1-dev.47ed32a → 2.73.1-dev.49397e5

package/dist/onboarding.js

@@ -71,8 +71,8 @@ const OTHER_PROVIDERS = [
 ];
 // ─── Dynamic imports ──────────────────────────────────────────────────────────
 /**
- * Dynamically import @clack/prompts and picocolors.
- * Dynamic import with fallback so the module doesn't crash if they're missing.
+ * Dynamically import @clack/prompts.
+ * Dynamic import with fallback so the module doesn't crash if it's missing.
  */
 async function loadClack() {
     try {
@@ -82,10 +82,23 @@ async function loadClack() {
         throw new Error('[gsd] @clack/prompts not found — onboarding wizard requires this dependency');
     }
 }
+/**
+ * Build the PicoModule color surface from chalk. Chalk is already a
+ * dependency of the CLI; this adapter keeps the onboarding call sites stable
+ * while removing the redundant picocolors dep.
+ */
 async function loadPico() {
     try {
-        const mod = await import('picocolors');
-        return mod.default ?? mod;
+        const { default: chalk } = await import('chalk');
+        return {
+            cyan: (s) => chalk.cyan(s),
+            green: (s) => chalk.green(s),
+            yellow: (s) => chalk.yellow(s),
+            dim: (s) => chalk.dim(s),
+            bold: (s) => chalk.bold(s),
+            red: (s) => chalk.red(s),
+            reset: (s) => chalk.reset(s),
+        };
     }
     catch {
         // Fallback: return identity functions
@@ -105,9 +118,29 @@ function openBrowser(url) {
         execFile(cmd, [url], () => { });
     }
 }
-/** Check if an error is a clack cancel signal */
-function isCancelError(p, err) {
-    return p.isCancel(err);
+/** Sentinel returned by runStep when the user cancels — tells the caller
+ *  to abort the entire wizard. */
+const STEP_CANCELLED = Symbol('step-cancelled');
+/**
+ * Run a single onboarding step with shared error handling:
+ *   - user cancel (Ctrl+C) → p.cancel(cancelMessage), returns STEP_CANCELLED
+ *   - other error → p.log.warn + optional info follow-up, returns null
+ *   - success → the step's return value
+ */
+async function runStep(p, warnLabel, fn, opts = {}) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (p.isCancel(err)) {
+            p.cancel(opts.cancelMessage ?? 'Setup cancelled.');
+            return STEP_CANCELLED;
+        }
+        p.log.warn(`${warnLabel}: ${err instanceof Error ? err.message : String(err)}`);
+        if (opts.errorInfo)
+            p.log.info(opts.errorInfo);
+        return null;
+    }
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
 /**
@@ -160,55 +193,28 @@ export async function runOnboarding(authStorage) {
     process.stderr.write(renderLogo(pc.cyan));
     p.intro(pc.bold('Welcome to GSD — let\'s get you set up'));
     // ── LLM Provider Selection ────────────────────────────────────────────────
-    let llmConfigured = false;
-    try {
-        llmConfigured = await runLlmStep(p, pc, authStorage);
-    }
-    catch (err) {
-        // User cancelled (Ctrl+C in clack throws) or unexpected error
-        if (isCancelError(p, err)) {
-            p.cancel('Setup cancelled — you can run /login inside GSD later.');
-            return;
-        }
-        p.log.warn(`LLM setup failed: ${err instanceof Error ? err.message : String(err)}`);
-        p.log.info('You can configure your LLM provider later with /login inside GSD.');
-    }
+    const llmResult = await runStep(p, 'LLM setup failed', () => runLlmStep(p, pc, authStorage), {
+        cancelMessage: 'Setup cancelled — you can run /login inside GSD later.',
+        errorInfo: 'You can configure your LLM provider later with /login inside GSD.',
+    });
+    if (llmResult === STEP_CANCELLED)
+        return;
+    const llmConfigured = llmResult ?? false;
     // ── Web Search Provider ──────────────────────────────────────────────────
-    let searchConfigured = null;
-    try {
-        searchConfigured = await runWebSearchStep(p, pc, authStorage, llmConfigured);
-    }
-    catch (err) {
-        if (isCancelError(p, err)) {
-            p.cancel('Setup cancelled.');
-            return;
-        }
-        p.log.warn(`Web search setup failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    const searchResult = await runStep(p, 'Web search setup failed', () => runWebSearchStep(p, pc, authStorage, llmConfigured));
+    if (searchResult === STEP_CANCELLED)
+        return;
+    const searchConfigured = searchResult;
     // ── Remote Questions ─────────────────────────────────────────────────────
-    let remoteConfigured = null;
-    try {
-        remoteConfigured = await runRemoteQuestionsStep(p, pc, authStorage);
-    }
-    catch (err) {
-        if (isCancelError(p, err)) {
-            p.cancel('Setup cancelled.');
-            return;
-        }
-        p.log.warn(`Remote questions setup failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    const remoteResult = await runStep(p, 'Remote questions setup failed', () => runRemoteQuestionsStep(p, pc, authStorage));
+    if (remoteResult === STEP_CANCELLED)
+        return;
+    const remoteConfigured = remoteResult;
     // ── Tool API Keys ─────────────────────────────────────────────────────────
-    let toolKeyCount = 0;
-    try {
-        toolKeyCount = await runToolKeysStep(p, pc, authStorage);
-    }
-    catch (err) {
-        if (isCancelError(p, err)) {
-            p.cancel('Setup cancelled.');
-            return;
-        }
-        p.log.warn(`Tool key setup failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    const toolResult = await runStep(p, 'Tool key setup failed', () => runToolKeysStep(p, pc, authStorage));
+    if (toolResult === STEP_CANCELLED)
+        return;
+    const toolKeyCount = toolResult ?? 0;
     // ── Summary ───────────────────────────────────────────────────────────────
     const summaryLines = [];
     if (llmConfigured) {

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

@@ -123,6 +123,63 @@ export function buildPromptFromContext(context) {
     }
     return parts.join("\n\n");
 }
+function stripDataUriPrefix(value) {
+    const commaIndex = value.indexOf(",");
+    if (value.startsWith("data:") && commaIndex !== -1) {
+        return value.slice(commaIndex + 1);
+    }
+    return value;
+}
+function inferMimeTypeFromDataUri(value) {
+    const match = /^data:([^;,]+);base64,/.exec(value);
+    return match?.[1] ?? null;
+}
+export function extractImageBlocksFromContext(context) {
+    const imageBlocks = [];
+    for (const msg of context.messages) {
+        if (msg.role !== "user" || !Array.isArray(msg.content))
+            continue;
+        for (const part of msg.content) {
+            if (!part || typeof part !== "object")
+                continue;
+            const block = part;
+            if (block.type !== "image" || typeof block.data !== "string")
+                continue;
+            const mimeType = typeof block.mimeType === "string" && block.mimeType.length > 0
+                ? block.mimeType
+                : inferMimeTypeFromDataUri(block.data);
+            if (!mimeType)
+                continue;
+            imageBlocks.push({
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: mimeType,
+                    data: stripDataUriPrefix(block.data),
+                },
+            });
+        }
+    }
+    return imageBlocks;
+}
+export function buildSdkQueryPrompt(context, textPrompt = buildPromptFromContext(context)) {
+    const imageBlocks = extractImageBlocksFromContext(context);
+    if (imageBlocks.length === 0) {
+        return textPrompt;
+    }
+    const content = [...imageBlocks];
+    if (textPrompt) {
+        content.push({ type: "text", text: textPrompt });
+    }
+    const sdkMessage = {
+        type: "user",
+        message: { role: "user", content },
+        parent_tool_use_id: null,
+    };
+    return (async function* () {
+        yield sdkMessage;
+    })();
+}
 // ---------------------------------------------------------------------------
 // Error helper
 // ---------------------------------------------------------------------------
@@ -622,6 +679,7 @@ async function pumpSdkMessages(model, context, options, stream) {
             options.signal.addEventListener("abort", () => controller.abort(), { once: true });
         }
         const prompt = buildPromptFromContext(context);
+        const queryPrompt = buildSdkQueryPrompt(context, prompt);
         const permissionMode = await resolveClaudePermissionMode();
         const sdkOpts = buildSdkOptions(modelId, prompt, { permissionMode }, typeof options?.extensionUIContext === "object"
             ? {
@@ -630,7 +688,7 @@ async function pumpSdkMessages(model, context, options, stream) {
             }
             : { reasoning: options?.reasoning });
         const queryResult = sdk.query({
-            prompt,
+            prompt: queryPrompt,
             options: {
                 ...sdkOpts,
                 abortController: controller,

package/dist/resources/extensions/gsd/auto/detect-stuck.js

@@ -3,6 +3,7 @@
  *
  * Leaf node in the import DAG.
  */
+import { summarizeLogs } from "../workflow-logger.js";
 /**
  * Pattern matching ENOENT errors with a file path.
  * Matches: "ENOENT: no such file or directory, access '/path/to/file'"
@@ -22,13 +23,19 @@ const ENOENT_PATH_RE = /ENOENT[^']*'([^']+)'/;
 export function detectStuck(window) {
     if (window.length < 2)
         return null;
+    // Peek (not drain) the workflow-logger buffer so stuck reasons can surface
+    // the underlying diagnostic context (projection failures, DB degradations,
+    // reconcile warnings) that usually explains *why* the loop is stuck. The
+    // auto-loop's finalize step owns the buffer lifecycle — this is read-only.
+    const loggerSummary = summarizeLogs();
+    const suffix = loggerSummary ? ` — ${loggerSummary}` : "";
     const last = window[window.length - 1];
     const prev = window[window.length - 2];
     // Rule 1: Same error repeated consecutively
     if (last.error && prev.error && last.error === prev.error) {
         return {
             stuck: true,
-            reason: `Same error repeated: ${last.error.slice(0, 200)}`,
+            reason: `Same error repeated: ${last.error.slice(0, 200)}${suffix}`,
         };
     }
     // Rule 2: Same unit 3+ consecutive times
@@ -37,7 +44,7 @@ export function detectStuck(window) {
         if (lastThree.every((u) => u.key === last.key)) {
             return {
                 stuck: true,
-                reason: `${last.key} derived 3 consecutive times without progress`,
+                reason: `${last.key} derived 3 consecutive times without progress${suffix}`,
             };
         }
     }
@@ -49,7 +56,7 @@ export function detectStuck(window) {
             w[0].key !== w[1].key) {
             return {
                 stuck: true,
-                reason: `Oscillation detected: ${w[0].key} ↔ ${w[1].key}`,
+                reason: `Oscillation detected: ${w[0].key} ↔ ${w[1].key}${suffix}`,
             };
         }
     }
@@ -67,7 +74,7 @@ export function detectStuck(window) {
         if (count >= 2) {
             return {
                 stuck: true,
-                reason: `Missing file referenced twice: ${filePath} (ENOENT)`,
+                reason: `Missing file referenced twice: ${filePath} (ENOENT)${suffix}`,
             };
         }
         enoentPaths.set(filePath, count);

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

@@ -16,7 +16,7 @@ import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
 import { join, basename, dirname, parse as parsePath } from "node:path";
 import { existsSync, cpSync, readdirSync } from "node:fs";
-import { logWarning, logError } from "../workflow-logger.js";
+import { logWarning, logError, _resetLogs, drainLogs, drainAndSummarize, formatForNotification, hasAnyIssues, } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
 import { verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.js";
@@ -100,6 +100,22 @@ async function closeoutAndStop(ctx, pi, s, deps, reason) {
     }
     await deps.stopAuto(ctx, pi, reason);
 }
+async function emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, errorContext) {
+    ic.deps.emitJournalEvent({
+        ts: new Date().toISOString(),
+        flowId: ic.flowId,
+        seq: ic.nextSeq(),
+        eventType: "unit-end",
+        data: {
+            unitType,
+            unitId,
+            status: "cancelled",
+            artifactVerified: false,
+            ...(errorContext ? { errorContext } : {}),
+        },
+        causedBy: { flowId: ic.flowId, seq: unitStartSeq },
+    });
+}
 // ─── runPreDispatch ───────────────────────────────────────────────────────────
 /**
  * Phase 1: Pre-dispatch — resource guard, health gate, state derivation,
@@ -320,10 +336,13 @@ export async function runPreDispatch(ic, loopState) {
         }
         else if (state.phase === "blocked") {
             const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
-            await deps.stopAuto(ctx, pi, blockerMsg);
-            ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
-            deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention", basename(s.originalBasePath || s.basePath));
-            deps.logCmuxEvent(prefs, blockerMsg, "error");
+            // Pause instead of hard-stop so the session is resumable with `/gsd auto`.
+            // Hard-stop here was causing premature termination when slice dependencies
+            // were temporarily unresolvable (e.g. after reassessment added new slices).
+            await deps.pauseAuto(ctx, pi);
+            ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto to resume.`, "warning");
+            deps.sendDesktopNotification("GSD", blockerMsg, "warning", "attention", basename(s.originalBasePath || s.basePath));
+            deps.logCmuxEvent(prefs, blockerMsg, "warning");
         }
         else {
             const ids = incomplete.map((m) => m.id).join(", ");
@@ -392,13 +411,16 @@ export async function runPreDispatch(ic, loopState) {
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "milestone-complete", milestoneId: mid } });
         return { action: "break", reason: "milestone-complete" };
     }
-    // Terminal: blocked
+    // Terminal: blocked — pause instead of hard-stop so the session is resumable.
     if (state.phase === "blocked") {
         const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
-        await closeoutAndStop(ctx, pi, s, deps, blockerMsg);
-        ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
-        deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention", basename(s.originalBasePath || s.basePath));
-        deps.logCmuxEvent(prefs, blockerMsg, "error");
+        if (s.currentUnit) {
+            await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
+        }
+        await deps.pauseAuto(ctx, pi);
+        ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto to resume.`, "warning");
+        deps.sendDesktopNotification("GSD", blockerMsg, "warning", "attention", basename(s.originalBasePath || s.basePath));
+        deps.logCmuxEvent(prefs, blockerMsg, "warning");
         debugLog("autoLoop", { phase: "exit", reason: "blocked" });
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "blocked", blockers: state.blockers } });
         return { action: "break", reason: "blocked" };
@@ -770,6 +792,10 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.currentUnit.type === unitType &&
         s.currentUnit.id === unitId);
     const previousTier = s.currentUnitRouting?.tier;
+    // Scope workflow-logger buffer to this unit so post-finalize drains are
+    // per-unit. Without this, the module-level _buffer accumulates across every
+    // unit in the same Node process (see workflow-logger.ts module header).
+    _resetLogs();
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
     setCurrentPhase(unitType);
     s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
@@ -969,6 +995,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         // 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") {
+            await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
             debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext.isTransient });
             return { action: "break", reason: "provider-pause" };
         }
@@ -982,9 +1009,16 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             ctx.ui.notify(`Session creation timed out for ${unitType} ${unitId}. Pausing auto-mode (recoverable).`, "warning");
             debugLog("autoLoop", { phase: "session-timeout-pause", unitType, unitId });
             await deps.pauseAuto(ctx, pi);
+            await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
+            await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
             return { action: "break", reason: "session-timeout" };
         }
         // All other cancelled states (structural errors, non-transient failures): hard stop
+        if (s.currentUnit) {
+            await deps.closeoutUnit(ctx, s.basePath, unitType, unitId, s.currentUnit.startedAt, deps.buildSnapshotOpts(unitType, unitId));
+        }
+        await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
+        await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
         ctx.ui.notify(`Session creation failed for ${unitType} ${unitId}: ${unitResult.errorContext?.message ?? "unknown"}. Stopping auto-mode.`, "warning");
         await deps.stopAuto(ctx, pi, `Session creation failed: ${unitResult.errorContext?.message ?? "unknown"}`);
         debugLog("autoLoop", { phase: "exit", reason: "session-failed" });
@@ -1118,6 +1152,9 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
         // cannot mutate state for the next unit (#3757).
         s.currentUnit = null;
         clearCurrentPhase();
+        // Drop any logger entries from the timed-out unit so they don't bleed
+        // into the next iteration's drain.
+        drainLogs();
         loopState.consecutiveFinalizeTimeouts++;
         debugLog("autoLoop", {
             phase: "pre-verification-timeout",
@@ -1193,6 +1230,9 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
         // cannot mutate state for the next unit (#3757).
         s.currentUnit = null;
         clearCurrentPhase();
+        // Drop any logger entries from the timed-out unit so they don't bleed
+        // into the next iteration's drain.
+        drainLogs();
         loopState.consecutiveFinalizeTimeouts++;
         debugLog("autoLoop", {
             phase: "post-verification-timeout",
@@ -1224,5 +1264,15 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
     }
     // Both pre and post verification completed without timeout — reset counter
     loopState.consecutiveFinalizeTimeouts = 0;
+    // Surface accumulated workflow-logger issues for this unit to the user.
+    // Warnings/errors logged during the unit are buffered in the logger and
+    // drained here so the user sees a single consolidated post-unit alert.
+    if (hasAnyIssues()) {
+        const { logs } = drainAndSummarize();
+        if (logs.length > 0) {
+            const severity = logs.some((e) => e.severity === "error") ? "error" : "warning";
+            ctx.ui.notify(formatForNotification(logs), severity);
+        }
+    }
     return { action: "next", data: undefined };
 }

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

@@ -216,7 +216,12 @@ export const DISPATCH_RULES = [
     {
         name: "reassess-roadmap (post-completion)",
         match: async ({ state, mid, midTitle, basePath, prefs }) => {
-            if (prefs?.phases?.skip_reassess || !prefs?.phases?.reassess_after_slice)
+            if (prefs?.phases?.skip_reassess)
+                return null;
+            // Default reassess_after_slice to true — reassessment after slice completion
+            // is essential for roadmap integrity. Opt-out via explicit `false`.
+            const reassessEnabled = prefs?.phases?.reassess_after_slice ?? true;
+            if (!reassessEnabled)
                 return null;
             const needsReassess = await checkNeedsReassessment(basePath, mid, state);
             if (!needsReassess)
@@ -710,11 +715,14 @@ export async function resolveDispatch(ctx) {
             return result;
         }
     }
-    // No rule matched — unhandled phase
+    // No rule matched — unhandled phase.
+    // Use level "warning" so the loop pauses (resumable) instead of hard-stopping.
+    // Hard-stop here was causing premature termination for transient phase gaps
+    // (e.g. after reassessment modifies the roadmap and state needs re-derivation).
     return {
         action: "stop",
         reason: `Unhandled phase "${ctx.state.phase}" — run /gsd doctor to diagnose.`,
-        level: "info",
+        level: "warning",
         matchedRule: "<no-match>",
     };
 }

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -67,6 +67,7 @@ const LIFECYCLE_ONLY_UNITS = new Set([
     "replan-slice", "complete-slice", "run-uat",
     "reassess-roadmap", "rewrite-docs",
 ]);
+import { describeNextUnit, } from "./auto-dashboard.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
@@ -179,6 +180,66 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
     }
     return rogues;
 }
+export const STEP_COMPLETE_FALLBACK_MESSAGE = "Step complete. Run /clear, then /gsd to continue (or /gsd auto to run continuously).";
+export function buildStepCompleteMessage(nextState) {
+    if (nextState.phase === "complete") {
+        return "Step complete — milestone finished. Run /gsd status to review, or start the next milestone.";
+    }
+    const next = describeNextUnit(nextState);
+    return `Step complete. Next: ${next.label}\n`
+        + `Run /clear, then /gsd to continue (or /gsd auto to run continuously).`;
+}
+export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
+    try {
+        let taskContext;
+        if (unitType === "execute-task") {
+            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+            if (mid && sid && tid) {
+                const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+                if (summaryPath) {
+                    try {
+                        const summaryContent = await loadFile(summaryPath);
+                        if (summaryContent) {
+                            const summary = parseSummary(summaryContent);
+                            let ghIssueNumber;
+                            try {
+                                const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+                                ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
+                            }
+                            catch (err) {
+                                logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+                            }
+                            taskContext = {
+                                taskId: `${sid}/${tid}`,
+                                taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
+                                oneLiner: summary.oneLiner || undefined,
+                                keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                                issueNumber: ghIssueNumber,
+                            };
+                        }
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
+                    }
+                }
+            }
+        }
+        _resetHasChangesCache();
+        if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
+            return null;
+        }
+        const commitMsg = autoCommitCurrentBranch(basePath, unitType, unitId, taskContext);
+        if (commitMsg) {
+            ctx?.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+        }
+        return commitMsg;
+    }
+    catch (e) {
+        debugLog("postUnit", { phase: "auto-commit", error: String(e) });
+        ctx?.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
+        return null;
+    }
+}
 /**
  * Pre-verification processing: parallel worker signal check, cache invalidation,
  * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
@@ -214,62 +275,7 @@ export async function postUnitPreVerification(pctx, opts) {
     // Auto-commit
     if (s.currentUnit) {
         const unit = s.currentUnit;
-        try {
-            let taskContext;
-            if (s.currentUnit.type === "execute-task") {
-                const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
-                if (mid && sid && tid) {
-                    const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
-                    if (summaryPath) {
-                        try {
-                            const summaryContent = await loadFile(summaryPath);
-                            if (summaryContent) {
-                                const summary = parseSummary(summaryContent);
-                                // Look up GitHub issue number for commit linking
-                                let ghIssueNumber;
-                                try {
-                                    const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
-                                    ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
-                                }
-                                catch (err) {
-                                    // GitHub sync not available — skip
-                                    logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-                                }
-                                taskContext = {
-                                    taskId: `${sid}/${tid}`,
-                                    taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
-                                    oneLiner: summary.oneLiner || undefined,
-                                    keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
-                                    issueNumber: ghIssueNumber,
-                                };
-                            }
-                        }
-                        catch (e) {
-                            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-                        }
-                    }
-                }
-            }
-            // Invalidate the nativeHasChanges cache before auto-commit (#1853).
-            // The cache has a 10-second TTL and is keyed by basePath.  A stale
-            // `false` result causes autoCommit to skip staging entirely, leaving
-            // code files only in the working tree where they are destroyed by
-            // `git worktree remove --force` during teardown.
-            _resetHasChangesCache();
-            // Skip auto-commit for lifecycle-only units (#2553) — they only touch
-            // `.gsd/` internal state files. Those files are picked up by the next
-            // actual task commit via smartStage().
-            if (!LIFECYCLE_ONLY_UNITS.has(s.currentUnit.type)) {
-                const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
-                if (commitMsg) {
-                    ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
-                }
-            }
-        }
-        catch (e) {
-            debugLog("postUnit", { phase: "auto-commit", error: String(e) });
-            ctx.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
-        }
+        await autoCommitUnit(s.basePath, unit.type, unit.id, ctx);
         // GitHub sync (non-blocking, opt-in)
         await runSafely("postUnit", "github-sync", async () => {
             const { runGitHubSync } = await import("../github-sync/sync.js");
@@ -509,6 +515,26 @@ export async function postUnitPreVerification(pctx, opts) {
                     const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
                     s.verificationRetryCount.set(retryKey, attempt);
                     if (attempt > MAX_VERIFICATION_RETRIES) {
+                        // #4175: For complete-milestone, a blocker placeholder is harmful —
+                        // the stub SUMMARY has no recovery value (milestone is terminal),
+                        // it does not update DB status (so deriveState never advances),
+                        // and it fools stopAuto's presence check into merging a milestone
+                        // that was never legitimately completed. Pause auto-mode with a
+                        // clear single failure signal and preserve the worktree branch.
+                        if (s.currentUnit.type === "complete-milestone") {
+                            debugLog("postUnit", {
+                                phase: "artifact-verify-pause-complete-milestone",
+                                unitType: s.currentUnit.type,
+                                unitId: s.currentUnit.id,
+                                attempt,
+                                maxRetries: MAX_VERIFICATION_RETRIES,
+                            });
+                            s.verificationRetryCount.delete(retryKey);
+                            s.pendingVerificationRetry = null;
+                            ctx.ui.notify(`Milestone ${s.currentUnit.id} verification failed after ${MAX_VERIFICATION_RETRIES} retries — worktree branch preserved. Re-run /gsd auto once blockers are resolved.`, "error");
+                            await pauseAuto(ctx, pi);
+                            return "dispatched";
+                        }
                         // Retries exhausted — write a blocker placeholder so the pipeline
                         // can advance past this stuck unit (#2653).
                         debugLog("postUnit", {
@@ -836,8 +862,18 @@ export async function postUnitPostVerification(pctx) {
             debugLog("postUnit", { phase: "quick-task-dispatch", error: String(e) });
         }
     }
-    // Step mode → show wizard instead of dispatch
+    // Step mode → show wizard instead of dispatch.
+    // Without this notify(), /gsd in step mode finishes a unit and silently
+    // exits the loop, leaving the user with no hint to /clear and /gsd again.
     if (s.stepMode) {
+        try {
+            const nextState = await deriveState(s.basePath);
+            ctx.ui.notify(buildStepCompleteMessage(nextState), "info");
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "step-wizard-notify", error: String(e) });
+            ctx.ui.notify(STEP_COMPLETE_FALLBACK_MESSAGE, "info");
+        }
         return "step-wizard";
     }
     return "continue";

package/dist/resources/extensions/gsd/auto-timeout-recovery.js

@@ -156,6 +156,19 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
         ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: steering ${unitType} ${unitId} to produce ${expected} (attempt ${attemptNumber}, session ${recoveryAttempts + 1}/${maxRecoveryAttempts}).`, "warning");
         return "recovered";
     }
+    // #4175: For complete-milestone, never write a blocker placeholder — a stub
+    // SUMMARY has no recovery value (milestone is terminal), it does not update
+    // DB status, and downstream merge paths can treat the stub as a legitimate
+    // completion signal. Pause instead so the worktree branch is preserved.
+    if (unitType === "complete-milestone") {
+        writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+            phase: "paused",
+            recoveryAttempts: recoveryAttempts + 1,
+            lastRecoveryReason: reason,
+        });
+        ctx.ui.notify(`Milestone ${unitId} ${reason}-recovery exhausted ${maxRecoveryAttempts} attempt(s) — worktree branch preserved. Re-run /gsd auto once blockers are resolved.`, "error");
+        return "paused";
+    }
     // Retries exhausted — write a blocker placeholder and advance the pipeline
     // instead of silently stalling.
     const placeholder = writeBlockerPlaceholder(unitType, unitId, basePath, `${reason} recovery exhausted ${maxRecoveryAttempts} attempts without producing the artifact.`);