gsd-pi 2.73.1 → 2.74.0-dev.b741afb

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/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-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,
+    };
 }