gsd-pi 2.76.0 → 2.77.0

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

@@ -30,7 +30,8 @@ import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
 import { ensurePlanV2Graph } from "../uok/plan-v2.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { UokGateRunner } from "../uok/gate-runner.js";
-import { resetEvidence } from "../safety/evidence-collector.js";
+import { resetEvidence, loadEvidenceFromDisk } from "../safety/evidence-collector.js";
+import { parseUnitId } from "../unit-id.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
 import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, supportsStructuredQuestions, } from "../workflow-mcp.js";
@@ -47,7 +48,11 @@ export function resetSessionTimeoutState() {
  * Exported for testing as _resolveReportBasePath.
  */
 export function _resolveReportBasePath(s) {
-    return s.originalBasePath || s.basePath;
+    // Strip /.gsd/worktrees/ suffix when basePath is itself a worktree path and
+    // originalBasePath is falsy — prevents reports landing in the worktree (#3729).
+    const resolved = s.originalBasePath || s.basePath;
+    const markerIdx = resolved.indexOf("/.gsd/worktrees/");
+    return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
 }
 /**
  * Resolve the authoritative project base for dispatch guards.
@@ -55,7 +60,12 @@ export function _resolveReportBasePath(s) {
  * unit is running inside an auto worktree.
  */
 export function _resolveDispatchGuardBasePath(s) {
-    return s.originalBasePath || s.basePath;
+    // Strip /.gsd/worktrees/ suffix when basePath is itself a worktree path and
+    // originalBasePath is falsy — prevents guard checks running against the
+    // worktree instead of the project root (#3729).
+    const resolved = s.originalBasePath || s.basePath;
+    const markerIdx = resolved.indexOf("/.gsd/worktrees/");
+    return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
 }
 const PLAN_V2_GATE_PHASES = new Set([
     "executing",
@@ -295,7 +305,7 @@ export async function runPreDispatch(ic, loopState) {
                 findings: reason,
                 milestoneId: state.activeMilestone?.id ?? undefined,
             });
-            ctx.ui.notify(`Plan gate failed-closed: ${reason}`, "error");
+            ctx.ui.notify(`Plan gate failed-closed: ${reason}\n\nIf this keeps happening, try: /gsd doctor heal`, "error");
             await deps.pauseAuto(ctx, pi);
             return { action: "break", reason: "plan-v2-gate-failed" };
         }
@@ -389,6 +399,8 @@ export async function runPreDispatch(ic, loopState) {
         loopState.recentUnits.length = 0;
         loopState.stuckRecoveryAttempts = 0;
         // Worktree lifecycle on milestone transition — merge current, enter next
+        // #2909: preflight — warn + stash dirty working tree before merge
+        const preflightTransition = deps.preflightCleanRoot(s.originalBasePath || s.basePath, s.currentMilestoneId, ctx.ui.notify.bind(ctx.ui));
         try {
             deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
         }
@@ -405,6 +417,10 @@ export async function runPreDispatch(ic, loopState) {
             await deps.stopAuto(ctx, pi, `Merge error on milestone ${s.currentMilestoneId}: ${String(mergeErr)}`);
             return { action: "break", reason: "merge-failed" };
         }
+        // #2909: postflight — restore stashed changes after successful merge
+        if (preflightTransition.stashPushed) {
+            deps.postflightPopStash(s.originalBasePath || s.basePath, s.currentMilestoneId, ctx.ui.notify.bind(ctx.ui));
+        }
         // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         deps.invalidateAllCaches();
         state = await deps.deriveState(s.basePath);
@@ -459,6 +475,8 @@ export async function runPreDispatch(ic, loopState) {
         if (incomplete.length === 0 && state.registry.length > 0) {
             // All milestones complete — merge milestone branch before stopping
             if (s.currentMilestoneId) {
+                // #2909: preflight — warn + stash dirty working tree before merge
+                const preflightAllComplete = deps.preflightCleanRoot(s.originalBasePath || s.basePath, s.currentMilestoneId, ctx.ui.notify.bind(ctx.ui));
                 try {
                     deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
                     // Prevent stopAuto from attempting the same merge (#2645)
@@ -475,6 +493,10 @@ export async function runPreDispatch(ic, loopState) {
                     await deps.stopAuto(ctx, pi, `Merge error on milestone ${s.currentMilestoneId}: ${String(mergeErr)}`);
                     return { action: "break", reason: "merge-failed" };
                 }
+                // #2909: postflight — restore stashed changes after successful merge
+                if (preflightAllComplete.stashPushed) {
+                    deps.postflightPopStash(s.originalBasePath || s.basePath, s.currentMilestoneId, ctx.ui.notify.bind(ctx.ui));
+                }
                 // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
             }
             deps.sendDesktopNotification("GSD", "All milestones complete!", "success", "milestone", basename(s.originalBasePath || s.basePath));
@@ -539,6 +561,8 @@ export async function runPreDispatch(ic, loopState) {
     if (state.phase === "complete") {
         // Milestone merge on complete (before closeout so branch state is clean)
         if (s.currentMilestoneId) {
+            // #2909: preflight — warn + stash dirty working tree before merge
+            const preflightComplete = deps.preflightCleanRoot(s.originalBasePath || s.basePath, s.currentMilestoneId, ctx.ui.notify.bind(ctx.ui));
             try {
                 deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
                 // Prevent stopAuto from attempting the same merge (#2645)
@@ -555,6 +579,10 @@ export async function runPreDispatch(ic, loopState) {
                 await deps.stopAuto(ctx, pi, `Merge error on milestone ${s.currentMilestoneId}: ${String(mergeErr)}`);
                 return { action: "break", reason: "merge-failed" };
             }
+            // #2909: postflight — restore stashed changes after successful merge
+            if (preflightComplete.stashPushed) {
+                deps.postflightPopStash(s.originalBasePath || s.basePath, s.currentMilestoneId, ctx.ui.notify.bind(ctx.ui));
+            }
             // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         }
         deps.sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "success", "milestone", basename(s.originalBasePath || s.basePath));
@@ -823,16 +851,44 @@ export async function runGuards(ic, mid) {
         if (threshold) {
             s.lastBudgetAlertLevel =
                 newBudgetAlertLevel;
-            if (threshold.pct === 100 && budgetEnforcementAction !== "none") {
+            // Emit Layer 2 budget_threshold event (post-plan hook recommendation).
+            // Extensions / Layer 0 shell hooks may return an action override.
+            let hookAction;
+            try {
+                const { emitBudgetThreshold } = await import("../hook-emitter.js");
+                const hookResult = await emitBudgetThreshold({
+                    fraction: budgetPct,
+                    spent: totalCost,
+                    limit: budgetCeiling,
+                });
+                if (hookResult?.action)
+                    hookAction = hookResult.action;
+            }
+            catch (hookErr) {
+                logWarning("engine", `budget_threshold hook emission failed: ${hookErr.message}`);
+            }
+            // Apply hook override to enforcement action. "continue" → "none" (no enforcement),
+            // "pause" and "downgrade" map to the matching enforcement path below.
+            let effectiveAction = budgetEnforcementAction;
+            if (hookAction === "continue") {
+                effectiveAction = "none";
+            }
+            else if (hookAction === "pause") {
+                effectiveAction = "pause";
+            }
+            else if (hookAction === "downgrade") {
+                effectiveAction = "warn";
+            }
+            if (threshold.pct === 100 && effectiveAction !== "none") {
                 // 100% — special enforcement logic (halt/pause/warn)
                 const msg = `Budget ceiling ${deps.formatCost(budgetCeiling)} reached (spent ${deps.formatCost(totalCost)}).`;
-                if (budgetEnforcementAction === "halt") {
+                if (effectiveAction === "halt") {
                     deps.sendDesktopNotification("GSD", msg, "error", "budget", basename(s.originalBasePath || s.basePath));
                     await deps.stopAuto(ctx, pi, "Budget ceiling reached");
                     debugLog("autoLoop", { phase: "exit", reason: "budget-halt" });
                     return { action: "break", reason: "budget-halt" };
                 }
-                if (budgetEnforcementAction === "pause") {
+                if (effectiveAction === "pause") {
                     ctx.ui.notify(`${msg} Pausing auto-mode — /gsd auto to override and continue.`, "warning");
                     deps.sendDesktopNotification("GSD", msg, "warning", "budget", basename(s.originalBasePath || s.basePath));
                     deps.logCmuxEvent(prefs, msg, "warning");
@@ -1000,6 +1056,14 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     const safetyConfig = resolveSafetyHarnessConfig(prefs?.safety_harness);
     if (safetyConfig.enabled && safetyConfig.evidence_collection) {
         resetEvidence();
+        // Restore persisted evidence so session-restart resumes don't produce
+        // false-positive "no bash calls" warnings (Bug #4385).
+        if (s.basePath && unitType === "execute-task") {
+            const { milestone: eMid, slice: eSid, task: eTid } = parseUnitId(unitId);
+            if (eMid && eSid && eTid) {
+                loadEvidenceFromDisk(s.basePath, eMid, eSid, eTid);
+            }
+        }
     }
     // Only checkpoint code-executing units (not lifecycle/planning units)
     if (safetyConfig.enabled && safetyConfig.checkpoints && unitType === "execute-task") {
@@ -1066,7 +1130,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         logWarning("engine", "Prompt reorder failed", { error: msg });
     }
     // Select and apply model (with tier escalation on retry — normal units only)
-    const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier }, undefined, s.manualSessionModelOverride);
+    const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier }, undefined, s.manualSessionModelOverride, s.autoModeStartThinkingLevel);
     s.currentUnitRouting =
         modelResult.routing;
     s.currentUnitModel =
@@ -1079,6 +1143,9 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         if (match) {
             const ok = await pi.setModel(match, { persist: false });
             if (ok) {
+                if (s.autoModeStartThinkingLevel) {
+                    pi.setThinkingLevel(s.autoModeStartThinkingLevel);
+                }
                 s.currentUnitModel = match;
                 ctx.ui.notify(`Hook model override: ${match.provider}/${match.id}`, "info");
             }
@@ -1173,20 +1240,23 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
     }
     if (unitResult.status === "cancelled") {
+        const errorCategory = unitResult.errorContext?.category;
         // 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") {
+        if (errorCategory === "provider") {
             await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
-            debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext.isTransient });
+            debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext?.isTransient });
             return { action: "break", reason: "provider-pause" };
         }
         // Timeout category covers two distinct scenarios:
         //   1. Session creation timeout (120s) — transient, auto-resume with backoff
         //   2. Unit hard timeout (30min+) — stuck agent, pause for manual review
+        // Transient session-failed covers recoverable newSession failures and should
+        // pause instead of hard-stopping.
         // Structural errors (TypeError, is not a function) are NOT transient
         // and must hard-stop to avoid infinite retry loops.
         if (unitResult.errorContext?.isTransient &&
-            unitResult.errorContext?.category === "timeout") {
+            errorCategory === "timeout") {
             const isSessionCreationTimeout = unitResult.errorContext.message?.includes("Session creation timed out");
             if (isSessionCreationTimeout) {
                 consecutiveSessionTimeouts += 1;
@@ -1229,6 +1299,15 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
             return { action: "break", reason: "unit-hard-timeout" };
         }
+        if (unitResult.errorContext?.isTransient &&
+            errorCategory === "session-failed") {
+            ctx.ui.notify(`Session creation failed transiently for ${unitType} ${unitId}: ${unitResult.errorContext?.message ?? "unknown"}. Pausing auto-mode (recoverable).`, "warning");
+            debugLog("autoLoop", { phase: "session-start-transient-pause", unitType, unitId, category: errorCategory });
+            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));
@@ -1387,6 +1466,20 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
         }
         else {
             // s.pendingVerificationRetry was set by postUnitPreVerification.
+            // Emit a dedicated journal event so forensics can distinguish bounded
+            // verification retries from genuine stuck-loop dispatch repetitions (#4540).
+            const retryInfo = s.pendingVerificationRetry;
+            deps.emitJournalEvent({
+                ts: new Date().toISOString(),
+                flowId: ic.flowId,
+                seq: ic.nextSeq(),
+                eventType: "artifact-verification-retry",
+                data: {
+                    unitType: preUnitSnapshot?.type,
+                    unitId: retryInfo?.unitId,
+                    attempt: retryInfo?.attempt,
+                },
+            });
             // Continue the loop — next iteration will inject the retry context into the prompt.
             debugLog("autoLoop", { phase: "artifact-verification-retry", iteration: ic.iteration });
             return { action: "continue" };

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

@@ -26,15 +26,24 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     let sessionResult;
     let sessionTimeoutHandle;
     const mySessionSwitchGeneration = ++sessionSwitchGeneration;
+    // #3731: Cancellation controller for newSession(). When the session-creation
+    // timeout fires, we abort this controller so that the still-in-flight
+    // newSession() discards itself after await this.abort() completes, preventing
+    // it from capturing the (now-root) process.cwd() and rebuilding the tool
+    // runtime with the wrong cwd.
+    const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = s.cmdCtx.newSession().finally(() => {
+        const sessionPromise = s.cmdCtx.newSession({ abortSignal: sessionAbortController.signal }).finally(() => {
             if (sessionSwitchGeneration === mySessionSwitchGeneration) {
                 _setSessionSwitchInFlight(false);
             }
         });
         const timeoutPromise = new Promise((resolve) => {
-            sessionTimeoutHandle = setTimeout(() => resolve({ cancelled: true }), NEW_SESSION_TIMEOUT_MS);
+            sessionTimeoutHandle = setTimeout(() => {
+                sessionAbortController.abort();
+                resolve({ cancelled: true });
+            }, NEW_SESSION_TIMEOUT_MS);
         });
         sessionResult = await Promise.race([sessionPromise, timeoutPromise]);
     }
@@ -92,6 +101,33 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     catch (e) {
         logWarning("engine", "Failed to chdir to basePath before dispatch", { basePath: s.basePath, error: String(e) });
     }
+    // ── Provider request-readiness pre-check (#4555) ──
+    // Verify the provider can accept requests before dispatching. If the token
+    // has expired since bootstrap, return cancelled immediately so the unit is
+    // not wasted on a guaranteed 401.
+    {
+        const provider = s.currentUnitModel?.provider ?? ctx.model?.provider;
+        const registry = ctx.modelRegistry;
+        if (provider && registry != null && typeof registry.isProviderRequestReady === "function") {
+            let ready = false;
+            try {
+                ready = registry.isProviderRequestReady(provider);
+            }
+            catch {
+                ready = false;
+            }
+            if (!ready) {
+                return {
+                    status: "cancelled",
+                    errorContext: {
+                        message: `Provider ${provider} is not request-ready (login/token expired)`,
+                        category: "provider",
+                        isTransient: false,
+                    },
+                };
+            }
+        }
+    }
     // ── Send the prompt ──
     debugLog("runUnit", { phase: "send-message", unitType, unitId });
     pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });

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

@@ -65,6 +65,8 @@ export class AutoSession {
     currentDispatchedModelId = null;
     originalModelId = null;
     originalModelProvider = null;
+    autoModeStartThinkingLevel = null;
+    originalThinkingLevel = null;
     lastBudgetAlertLevel = 0;
     // ── Recovery ─────────────────────────────────────────────────────────────
     pendingCrashRecovery = null;
@@ -77,6 +79,17 @@ export class AutoSession {
     lastStateRebuildAt = 0;
     // ── Sidecar queue ─────────────────────────────────────────────────────
     sidecarQueue = [];
+    // ── Pre-exec gate failure context (#4551) ───────────────────────────
+    /**
+     * Persisted when a pre-execution gate fails on a plan-slice or refine-slice
+     * unit. The planning → plan-slice dispatch rule reads this field and injects
+     * the failure details into the next re-dispatch prompt so the LLM can fix the
+     * specific issues instead of producing an identical plan.
+     *
+     * Cleared after it has been consumed (injected into the prompt) to avoid
+     * stale context bleeding into unrelated slices.
+     */
+    lastPreExecFailure = null;
     // ── Tool invocation errors (#2883) ──────────────────────────────────
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
@@ -137,7 +150,12 @@ export class AutoSession {
         this.unitLifetimeDispatches.clear();
     }
     get lockBasePath() {
-        return this.originalBasePath || this.basePath;
+        // Prefer originalBasePath (project root); fall back to basePath.
+        // Strip /.gsd/worktrees/ suffix if basePath is itself a worktree path
+        // to avoid reading/writing the lock inside the worktree (#3729).
+        const resolved = this.originalBasePath || this.basePath;
+        const markerIdx = resolved.indexOf("/.gsd/worktrees/");
+        return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
     }
     reset() {
         this.clearTimers();
@@ -177,6 +195,8 @@ export class AutoSession {
         this.currentDispatchedModelId = null;
         this.originalModelId = null;
         this.originalModelProvider = null;
+        this.autoModeStartThinkingLevel = null;
+        this.originalThinkingLevel = null;
         this.lastBudgetAlertLevel = 0;
         // Recovery
         this.pendingCrashRecovery = null;
@@ -195,6 +215,7 @@ export class AutoSession {
         this.sidecarQueue = [];
         this.rewriteAttemptCount = 0;
         this.consecutiveCompleteBootstraps = 0;
+        this.lastPreExecFailure = null;
         this.lastToolInvocationError = null;
         this.lastGitActionFailure = null;
         this.lastGitActionStatus = null;

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

@@ -451,18 +451,31 @@ export const DISPATCH_RULES = [
     },
     {
         name: "planning → plan-slice",
-        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry }) => {
+        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry, session }) => {
             if (state.phase !== "planning")
                 return null;
             if (!state.activeSlice)
                 return missingSliceStop(mid, state.phase);
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
+            // #4551: Consume any persisted pre-exec failure for this slice so the
+            // re-dispatched prompt includes the exact blocked references. Clear the
+            // field immediately after reading to prevent stale context leaking into
+            // a later, unrelated plan-slice run.
+            const unitId = `${mid}/${sid}`;
+            let priorPreExecFailure;
+            if (session?.lastPreExecFailure?.unitId === unitId) {
+                priorPreExecFailure = {
+                    blockingFindings: session.lastPreExecFailure.blockingFindings,
+                    verdictExcerpt: session.lastPreExecFailure.verdictExcerpt,
+                };
+                session.lastPreExecFailure = null;
+            }
             return {
                 action: "dispatch",
                 unitType: "plan-slice",
-                unitId: `${mid}/${sid}`,
-                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
+                unitId,
+                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry, priorPreExecFailure }),
             };
         },
     },

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -12,10 +12,20 @@ import { getSessionModelOverride } from "./session-model-override.js";
 import { logWarning } from "./workflow-logger.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { applyModelPolicyFilter } from "./uok/model-policy.js";
+import { isModelBlocked } from "./blocked-models.js";
+function reapplyThinkingLevel(pi, level) {
+    if (!level)
+        return;
+    pi.setThinkingLevel(level);
+}
 export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true) {
     const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
-    if (explicitConfig)
-        return explicitConfig;
+    if (explicitConfig) {
+        return {
+            ...explicitConfig,
+            source: "explicit",
+        };
+    }
     // In interactive mode, don't synthesize a routing-based model config.
     // The user's session model (/model) should be used as-is (#3962).
     if (!isAutoMode)
@@ -38,6 +48,7 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAuto
     return {
         primary: ceilingModel,
         fallbacks: [],
+        source: "synthesized",
     };
 }
 /**
@@ -52,7 +63,9 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
  *  Dynamic routing only applies in auto-mode where cost optimization is expected. (#3962) */
 isAutoMode = true, 
 /** Explicit /gsd model pin captured at bootstrap for long-running auto loops. */
-sessionModelOverride) {
+sessionModelOverride, 
+/** Thinking level captured at auto-mode start and re-applied after model swaps. */
+autoModeStartThinkingLevel) {
     const uokFlags = resolveUokFlags(prefs);
     const effectiveSessionModelOverride = sessionModelOverride === undefined
         ? getSessionModelOverride(ctx.sessionManager.getSessionId())
@@ -90,6 +103,11 @@ sessionModelOverride) {
         if (prefs?.token_profile === "burn-max") {
             routingConfig.enabled = false;
         }
+        if (modelConfig.source === "explicit") {
+            // Explicit per-phase model preferences express hard user intent.
+            // Dynamic routing may only treat synthesized tier ceilings as downgradeable.
+            routingConfig.enabled = false;
+        }
         let effectiveModelConfig = modelConfig;
         let routingTierLabel = "";
         let routingEligibleModels = availableModels;
@@ -210,6 +228,7 @@ sessionModelOverride) {
                     effectiveModelConfig = {
                         primary: routingResult.modelId,
                         fallbacks: routingResult.fallbacks,
+                        source: modelConfig.source,
                     };
                     // Always notify on model downgrade — users should see when their
                     // model selection is overridden, not just in verbose mode (#3962).
@@ -249,6 +268,14 @@ sessionModelOverride) {
                 }
                 attemptedPolicyEligible = true;
             }
+            // Skip models the provider has previously rejected for this account
+            // (issue #4513).  The block is persisted in .gsd/runtime/blocked-models.json
+            // so it survives /gsd auto restarts — without this, the same dead model
+            // gets reselected after every restart.
+            if (isModelBlocked(basePath, model.provider, model.id)) {
+                ctx.ui.notify(`Skipping blocked model ${model.provider}/${model.id} (provider rejected it for this account).`, "warning");
+                continue;
+            }
             // Warn if the ID is ambiguous across providers
             if (!modelId.includes("/")) {
                 const providers = availableModels.filter(m => m.id === modelId).map(m => m.provider);
@@ -260,10 +287,11 @@ sessionModelOverride) {
             const ok = await pi.setModel(model, { persist: false });
             if (ok) {
                 appliedModel = model;
+                reapplyThinkingLevel(pi, autoModeStartThinkingLevel);
                 // ADR-005: Adjust active tool set for the selected model's provider capabilities.
                 // Hard-filter incompatible tools, then let extensions override via adjust_tool_set hook.
                 const activeToolNames = pi.getActiveTools();
-                const { toolNames: compatibleTools, removedTools } = adjustToolSet(activeToolNames, model.api);
+                const { toolNames: compatibleTools, removedTools } = adjustToolSet(activeToolNames, model.api, model.provider);
                 let finalToolNames = compatibleTools;
                 // Fire adjust_tool_set hook — extensions can override the filtered tool set
                 if (routingConfig.hooks !== false) {
@@ -314,19 +342,28 @@ sessionModelOverride) {
         // No model preference for this unit type — re-apply the model captured
         // at auto-mode start to prevent bleed from shared global settings.json (#650).
         const availableModels = ctx.modelRegistry.getAvailable();
-        const startModel = availableModels.find(m => m.provider === autoModeStartModel.provider && m.id === autoModeStartModel.id);
-        if (startModel) {
-            const ok = await pi.setModel(startModel, { persist: false });
-            if (!ok) {
-                const byId = availableModels.find(m => m.id === autoModeStartModel.id);
-                if (byId) {
-                    const fallbackOk = await pi.setModel(byId, { persist: false });
-                    if (fallbackOk)
-                        appliedModel = byId;
+        const startBlocked = isModelBlocked(basePath, autoModeStartModel.provider, autoModeStartModel.id);
+        if (startBlocked) {
+            ctx.ui.notify(`Auto-mode start model ${autoModeStartModel.provider}/${autoModeStartModel.id} is blocked for this account. Using current session model instead.`, "warning");
+        }
+        else {
+            const startModel = availableModels.find(m => m.provider === autoModeStartModel.provider && m.id === autoModeStartModel.id);
+            if (startModel) {
+                const ok = await pi.setModel(startModel, { persist: false });
+                if (!ok) {
+                    const byId = availableModels.find(m => m.id === autoModeStartModel.id && !isModelBlocked(basePath, m.provider, m.id));
+                    if (byId) {
+                        const fallbackOk = await pi.setModel(byId, { persist: false });
+                        if (fallbackOk) {
+                            appliedModel = byId;
+                            reapplyThinkingLevel(pi, autoModeStartThinkingLevel);
+                        }
+                    }
+                }
+                else {
+                    appliedModel = startModel;
+                    reapplyThinkingLevel(pi, autoModeStartThinkingLevel);
                 }
-            }
-            else {
-                appliedModel = startModel;
             }
         }
     }

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

@@ -30,7 +30,7 @@ import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookSta
 import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { runSafely } from "./auto-utils.js";
-import { getEvidence } from "./safety/evidence-collector.js";
+import { getEvidence, clearEvidenceFromDisk } from "./safety/evidence-collector.js";
 import { validateFileChanges } from "./safety/file-change-validator.js";
 // crossReferenceEvidence available for future use when verification_evidence is stored in DB
 // import { crossReferenceEvidence, type ClaimedEvidence } from "./safety/evidence-cross-ref.js";
@@ -535,7 +535,7 @@ export async function postUnitPreVerification(pctx, opts) {
                         if (taskRow) {
                             const expectedOutput = taskRow.expected_output ?? [];
                             const plannedFiles = taskRow.files ?? [];
-                            const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles);
+                            const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles, safetyConfig.file_change_allowlist);
                             if (audit && audit.violations.length > 0) {
                                 const warnings = audit.violations.filter(v => v.severity === "warning");
                                 for (const v of warnings) {
@@ -588,6 +588,16 @@ export async function postUnitPreVerification(pctx, opts) {
                         debugLog("postUnit", { phase: "safety-content-validation", error: String(e) });
                     }
                 }
+                // Clear persisted evidence file now that post-unit processing is complete
+                // (Bug #4385 — prevents stale evidence from affecting retries of same unit ID).
+                if (safetyConfig.evidence_collection && s.currentUnit.type === "execute-task" && sMid && sSid && sTid) {
+                    try {
+                        clearEvidenceFromDisk(s.basePath, sMid, sSid, sTid);
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "safety-evidence-clear", error: String(e) });
+                    }
+                }
             }
         }
         catch (e) {
@@ -950,12 +960,25 @@ export async function postUnitPostVerification(pctx) {
                     const suffix = blockingChecks.length > 3 ? `\n  \u2022 ...and ${blockingChecks.length - 3} more` : "";
                     const evidenceNote = `\nSee ${sid}-PRE-EXEC-VERIFY.json for full details.`;
                     ctx.ui.notify(`Pre-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found\n${details}${suffix}${evidenceNote}`, "error");
+                    // Persist failure context so the next plan-slice re-dispatch can inject
+                    // it into the prompt and break the infinite loop (#4551).
+                    s.lastPreExecFailure = {
+                        unitId: currentUnit.id,
+                        blockingFindings: blockingChecks.map(c => `[${c.category}] ${c.target}: ${c.message}`),
+                        verdictExcerpt: `status=${result.status}; ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} detected`,
+                    };
                     preExecPauseNeeded = true;
                 }
                 else if (result.status === "warn") {
                     ctx.ui.notify(`Pre-execution checks passed with warnings`, "warning");
                     // Strict mode: treat warnings as blocking
                     if (prefs?.enhanced_verification_strict === true) {
+                        const warnChecks = result.checks.filter(c => !c.passed);
+                        s.lastPreExecFailure = {
+                            unitId: currentUnit.id,
+                            blockingFindings: warnChecks.map(c => `[${c.category}] ${c.target}: ${c.message}`),
+                            verdictExcerpt: `status=${result.status} (strict mode); ${warnChecks.length} warning${warnChecks.length === 1 ? "" : "s"} treated as blocking`,
+                        };
                         preExecPauseNeeded = true;
                     }
                 }

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

@@ -1223,6 +1223,20 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
         prependBlocks.push(`## Prior Sketch Scope (soft hint — non-binding)\n\n${options.softScopeHint.trim()}\n\n` +
             `This scope was captured during an earlier progressive-planning pass that was later disabled. Treat it as context only — you may plan beyond it if the work genuinely requires more scope. Do NOT treat this as a hard boundary.`);
     }
+    // #4551: inject pre-exec failure context so the re-dispatched plan-slice
+    // addresses the exact blocked references rather than reproducing the same plan.
+    if (options?.priorPreExecFailure) {
+        const { blockingFindings, verdictExcerpt } = options.priorPreExecFailure;
+        const findingsList = blockingFindings.length > 0
+            ? blockingFindings.map(f => `- ${f}`).join("\n")
+            : "- (no specific findings recorded)";
+        prependBlocks.push(`## Fix these specific issues from the prior pre-exec check\n\n` +
+            `The previous plan-slice attempt was blocked by pre-execution validation.\n` +
+            `Gate verdict: ${verdictExcerpt}\n\n` +
+            `Blocked references that must be resolved in this plan:\n${findingsList}\n\n` +
+            `Revise the plan so that every reference listed above is satisfied before execution begins. ` +
+            `Do not reproduce the same file paths, package names, or task ordering that caused these failures.`);
+    }
     return renderSlicePrompt({
         mid, sid, sTitle, base,
         level: level ?? resolveInlineLevel(),