gsd-pi 2.73.0 → 2.73.1-dev.06e4302

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/resource-loader.js

@@ -358,7 +358,7 @@ function reconcileMergedNodeModules(agentNodeModules, hoisted, internal) {
             if (entry.name.startsWith('.'))
                 continue;
             try {
-                symlinkSync(join(hoisted, entry.name), join(agentNodeModules, entry.name));
+                symlinkSync(join(hoisted, entry.name), join(agentNodeModules, entry.name), 'junction');
                 linkedCount++;
             }
             catch { /* skip individual */ }
@@ -382,7 +382,7 @@ function reconcileMergedNodeModules(agentNodeModules, hoisted, internal) {
             }
             catch { /* didn't exist — will create below */ }
             try {
-                symlinkSync(join(internal, entry.name), link);
+                symlinkSync(join(internal, entry.name), link, 'junction');
                 linkedCount++;
             }
             catch { /* skip individual */ }

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

@@ -6,7 +6,7 @@
  * AssistantMessageEvents for TUI rendering, then strips tool-call blocks from
  * the final AssistantMessage so GSD's agent loop doesn't try to dispatch them.
  */
-import { EventStream } from "@gsd/pi-ai";
+import { EventStream, mapThinkingLevelToEffort, supportsAdaptiveThinking } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
 import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.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
 // ---------------------------------------------------------------------------
@@ -437,6 +494,7 @@ export async function resolveClaudePermissionMode(env = process.env) {
  * behaviour pass `permissionMode: "bypassPermissions"` explicitly.
  */
 export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
+    const { reasoning, ...sdkExtraOptions } = extraOptions;
     const mcpServers = buildWorkflowMcpServers();
     const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
     const disallowedTools = ["AskUserQuestion"];
@@ -455,6 +513,9 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         "Bash(pwd)",
         ...(mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : []),
     ];
+    const effort = reasoning && supportsAdaptiveThinking(modelId)
+        ? mapThinkingLevelToEffort(reasoning, modelId)
+        : undefined;
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,
@@ -469,7 +530,8 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         ...(allowedTools.length > 0 ? { allowedTools } : {}),
         ...(mcpServers ? { mcpServers } : {}),
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
-        ...extraOptions,
+        ...(effort ? { effort } : {}),
+        ...sdkExtraOptions,
     };
 }
 function normalizeToolResultContent(content) {
@@ -617,14 +679,16 @@ 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"
             ? {
+                reasoning: options?.reasoning,
                 onElicitation: createClaudeCodeElicitationHandler(options?.extensionUIContext),
             }
-            : {});
+            : { reasoning: options?.reasoning });
         const queryResult = sdk.query({
-            prompt,
+            prompt: queryPrompt,
             options: {
                 ...sdkOpts,
                 abortController: controller,

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

@@ -320,10 +320,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 +395,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" };

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

@@ -18,6 +18,7 @@ import { logWarning, logError } from "./workflow-logger.js";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
 import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
+import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -215,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)
@@ -330,7 +336,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "research-slice",
                 unitId: `${mid}/parallel-research`,
-                prompt: await buildParallelResearchSlicesPrompt(mid, midTitle, researchReadySlices, basePath),
+                prompt: await buildParallelResearchSlicesPrompt(mid, midTitle, researchReadySlices, basePath, resolveModelWithFallbacksForUnit("subagent")?.primary),
             };
         },
     },
@@ -401,7 +407,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "gate-evaluate",
                 unitId: `${mid}/${sid}/gates+${pending.map(g => g.gate_id).join(",")}`,
-                prompt: await buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, basePath),
+                prompt: await buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, basePath, resolveModelWithFallbacksForUnit("subagent")?.primary),
             };
         },
     },
@@ -436,6 +442,7 @@ export const DISPATCH_RULES = [
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
             const maxParallel = reactiveConfig.max_parallel ?? 2;
+            const subagentModel = reactiveConfig.subagent_model ?? resolveModelWithFallbacksForUnit("subagent")?.primary;
             // Dry-run mode: max_parallel=1 means graph is derived and logged but
             // execution remains sequential
             if (maxParallel <= 1)
@@ -478,7 +485,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "reactive-execute",
                     unitId: `${mid}/${sid}/reactive+${batchSuffix}`,
-                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath),
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel),
                 };
             }
             catch (err) {
@@ -708,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-model-selection.js

@@ -9,10 +9,8 @@ import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabil
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
 import { getSessionModelOverride } from "./session-model-override.js";
-export function resolvePreferredModelConfig(unitType, autoModeStartModel, 
-/** When false, only return explicit per-phase model configs — do not
- *  synthesize a routing ceiling from dynamic_routing.tier_models (#3962). */
-isAutoMode = true) {
+import { logWarning } from "./workflow-logger.js";
+export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true) {
     const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
     if (explicitConfig)
         return explicitConfig;
@@ -24,7 +22,7 @@ isAutoMode = true) {
     if (!routingConfig.enabled || !routingConfig.tier_models)
         return undefined;
     // Don't synthesize a routing config for flat-rate providers (#3453).
-    if (autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider))
+    if (autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider, autoModeStartModel.flatRateCtx))
         return undefined;
     const ceilingModel = routingConfig.tier_models.heavy
         ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
@@ -51,6 +49,17 @@ sessionModelOverride) {
     const effectiveSessionModelOverride = sessionModelOverride === undefined
         ? getSessionModelOverride(ctx.sessionManager.getSessionId())
         : (sessionModelOverride ?? undefined);
+    // Enrich the start model with a flat-rate context up front so routing
+    // synthesis and the dispatch-time guard see the same signals (built-in
+    // list + user `flat_rate_providers` preference + externalCli auto-
+    // detection).  The dispatch-time primary-model check below builds its
+    // own per-provider context when it has a resolved primary model.
+    if (autoModeStartModel) {
+        autoModeStartModel = {
+            ...autoModeStartModel,
+            flatRateCtx: buildFlatRateContext(autoModeStartModel.provider, ctx, prefs),
+        };
+    }
     const modelConfig = effectiveSessionModelOverride
         ? undefined
         : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
@@ -76,12 +85,13 @@ sessionModelOverride) {
         if (routingConfig.enabled) {
             const primaryModel = resolveModelId(modelConfig.primary, availableModels, ctx.model?.provider);
             if (primaryModel) {
-                if (isFlatRateProvider(primaryModel.provider)) {
+                const primaryFlatRateCtx = buildFlatRateContext(primaryModel.provider, ctx, prefs);
+                if (isFlatRateProvider(primaryModel.provider, primaryFlatRateCtx)) {
                     routingConfig.enabled = false;
                 }
             }
-            else if ((autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider))
-                || (ctx.model?.provider && isFlatRateProvider(ctx.model.provider))) {
+            else if ((autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider, autoModeStartModel.flatRateCtx))
+                || (ctx.model?.provider && isFlatRateProvider(ctx.model.provider, buildFlatRateContext(ctx.model.provider, ctx, prefs)))) {
                 // Primary model unresolvable but provider signals indicate flat-rate —
                 // disable routing to prevent quality degradation.
                 routingConfig.enabled = false;
@@ -331,7 +341,40 @@ export function resolveModelId(modelId, availableModels, currentProvider) {
  * Uses case-insensitive matching with alias support to prevent fail-open on
  * provider naming variations (e.g. "copilot" vs "github-copilot").
  */
-const FLAT_RATE_PROVIDERS = new Set(["github-copilot", "copilot", "claude-code"]);
-export function isFlatRateProvider(provider) {
-    return FLAT_RATE_PROVIDERS.has(provider.toLowerCase());
+const BUILTIN_FLAT_RATE = new Set(["github-copilot", "copilot", "claude-code"]);
+export function isFlatRateProvider(provider, opts) {
+    const p = provider.toLowerCase();
+    if (BUILTIN_FLAT_RATE.has(p))
+        return true;
+    if (opts?.userFlatRate?.some(id => id.toLowerCase() === p))
+        return true;
+    if (opts?.authMode === "externalCli")
+        return true;
+    return false;
+}
+/**
+ * Build a FlatRateContext for a given provider from live runtime state.
+ * Safe to call when ctx or prefs are undefined — missing pieces are
+ * treated as "no signal".
+ */
+export function buildFlatRateContext(provider, ctx, prefs) {
+    let authMode;
+    const getAuthMode = ctx?.modelRegistry?.getProviderAuthMode;
+    if (typeof getAuthMode === "function") {
+        try {
+            const mode = getAuthMode(provider);
+            if (mode === "apiKey" || mode === "oauth" || mode === "externalCli" || mode === "none") {
+                authMode = mode;
+            }
+        }
+        catch (err) {
+            // Registry lookup failure must never break flat-rate detection —
+            // fall through with authMode undefined and surface the cause.
+            logWarning("dispatch", `flat-rate auth-mode lookup failed for ${provider}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return {
+        authMode,
+        userFlatRate: prefs?.flat_rate_providers,
+    };
 }

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,15 @@ 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).`;
+}
 /**
  * Pre-verification processing: parallel worker signal check, cache invalidation,
  * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
@@ -509,6 +519,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 +866,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-prompts.js

@@ -1712,7 +1712,7 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
     });
 }
 // ─── Reactive Execute Prompt ──────────────────────────────────────────────
-export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base) {
+export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base, subagentModel) {
     const { loadSliceTaskIO, deriveTaskGraph, graphMetrics } = await import("./reactive-graph.js");
     // Build graph for context
     const taskIO = await loadSliceTaskIO(base, mid, sid);
@@ -1744,10 +1744,11 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
         const depPaths = await getDependencyTaskSummaryPaths(mid, sid, tid, node?.dependsOn ?? [], base);
         // Build a full execute-task prompt with dependency-based carry-forward
         const taskPrompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, { carryForwardPaths: depPaths });
+        const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
             `### ${tid}: ${tTitle}`,
             "",
-            "Use this as the prompt for a `subagent` call:",
+            `Use this as the prompt for a \`subagent\` call${modelSuffix}:`,
             "",
             "```",
             taskPrompt,
@@ -1806,15 +1807,16 @@ function renderGatesToCloseBlock(gates, opts) {
     }
     return lines.join("\n").trimEnd();
 }
-export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, basePath) {
+export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, basePath, subagentModel) {
     // Build individual research-slice prompts for each slice
     const subagentSections = [];
+    const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
     for (const slice of slices) {
         const slicePrompt = await buildResearchSlicePrompt(mid, midTitle, slice.id, slice.title, basePath);
         subagentSections.push([
             `### ${slice.id}: ${slice.title}`,
             "",
-            "Use this as the prompt for a `subagent` call (agent: `gsd-executor` or the default agent):",
+            `Use this as the prompt for a \`subagent\` call${modelSuffix} (agent: \`gsd-executor\` or the default agent):`,
             "",
             "```",
             slicePrompt,
@@ -1829,7 +1831,7 @@ export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, b
         subagentPrompts: subagentSections.join("\n\n---\n\n"),
     });
 }
-export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base) {
+export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base, subagentModel) {
     // Pull only the gates this turn actually owns (Q3/Q4). Filter via the
     // registry so that scope:"slice" gates owned by other turns (Q8) can't
     // leak into this prompt and can't block dispatch via silent skip.
@@ -1873,10 +1875,11 @@ export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base)
             "- `rationale`: one-sentence justification",
             "- `findings`: detailed markdown findings (or empty if omitted)",
         ].join("\n");
+        const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
             `### ${def.id}: ${def.question}`,
             "",
-            "Use this as the prompt for a `subagent` call:",
+            `Use this as the prompt for a \`subagent\` call${modelSuffix}:`,
             "",
             "```",
             subPrompt,